1.

Maze Game

Project Description:

The Maze Game project in PictoBlox involves creating an interactive game where a player-
controlled sprite (like a cat or ball) navigates through a maze to reach a goal without touching the
walls. The game is designed using block-based coding in PictoBlox, a graphical programming
platform based on Scratch, ideal for beginners and school students.

This project helps students understand game development fundamentals while improving their
logical thinking and problem-solving skills.

Objective

• Move a sprite using arrow keys.

• Detect wall collision and reset position.
• Win the game by reaching the goal.
• Use loops and conditionals for game logic.

Sprites:

• Player sprite (e.g., a ball or character).

• Maze walls as a backdrop or sprite.
• Goal or target sprite to signify the endpoint.

Movement Controls:
The player sprite moves using keyboard inputs (e.g., arrow keys).
Example blocks:

• When [green flag] clicked

• Forever
• If (key [up arrow] pressed) => then change y by 5
• If (key [down arrow] pressed) => then change y by -5
• If (key [right arrow] pressed) => then change x by 5
• If (key [left arrow] pressed) => then change x by -5

Wall Collision Detection:

If the sprite touches the wall (usually colored black or red), it resets to the starting position.

• If (touching color [black]) then

Go to [start position]
Win Condition:
If the sprite touches the goal, a winning message appears.

• If (touching [goal sprite]) then

• Say "You Win!" for 2 seconds
• Stop all

Lessons Learned:

• Programming Fundamentals:
Understanding loops, conditions, events, and sensing blocks in PictoBlox.
• Game Logic Design:
How to plan and structure a simple interactive game.
• Debugging Skills:
Identifying and fixing errors in logic, such as incorrect collision detection or movement
glitches.
• Creativity and Design Thinking:
Designing their own maze layout and customizing sprites and backgrounds.
2. Fruit Catching game

Project Description:

The Fruit Catching Game is an interactive project where a monkey character holds a basket and
moves left or right to catch falling fruits (like apples). The game teaches students how to create
animations, add interactivity, and work with variables to keep score.

Students use block-based coding in PictoBlox to develop the game and learn how to respond to
keyboard input, use motion and sensing blocks, and apply conditions to update scores.

Objective

• Move the monkey left and right using keys.

• Make fruits fall from the top randomly.
• Increase score when fruit is caught.
• Use variables, sensing, and loops.

Sprites:

• Monkey sprite (with a basket).

• Fruit sprite (e.g., apple).
• Optional: background for setting the scene (e.g., jungle or plain color).

Basket Movement (Controlled by Arrow Keys):

The monkey moves left and right when the user presses the arrow keys.

• When [green flag] clicked

• Forever
• If <key [right arrow] pressed> then change x by 10
• If <key [left arrow] pressed> then change x by -10

Falling Fruit:
The fruit falls continuously from the top to the bottom.

• When [green flag] clicked

• Forever
• Go to x: (random position) y: 180
• Repeat until <touching [basket]>
• Change y by -5
• Wait (0.05) seconds
• End
• If <touching [basket]> then
• Change [score] by 1
 • End

Lessons Learned:

• Understanding Events and Inputs:

How to use key press events to control sprite movement.
• Use of Variables:
Learning how to create and update a score variable.
• Randomization and Repetition:
Using random values for fruit positioning and repeat loops for falling motion.
• Conditionals and Collision Detection:
Detecting whether two sprites are touching to trigger score change.
• Game Development Basics:
Structuring a beginning, ongoing interaction, and goal in a simple game.

Final Outcome:

By completing the project, students are able to:

• Develop a fully functional fruit-catching game.

• Move a character using the keyboard to catch falling objects.
• Maintain and display a score counter on the screen.
• Customize their game with different characters, fruits, and backgrounds.
• Present their game confidently, showcasing their understanding of logic and design in
PictoBlox.

Score Tracking:
A variable score is created and increased each time a fruit is caught.
Time Tracking:
Decreasing time to 0 on the screen lets the game to stop.
 T-Rex Game
Project Description:
The T-Rex Game in PictoBlox is inspired by the popular offline Chrome dinosaur game. In this
project, a T-Rex character automatically runs forward and must jump over obstacles like cacti.
The game helps students learn animation, motion, conditionals, and variable use in game
development using block-based programming.
This project enhances logical thinking, timing, and creativity.

Objective
• Jump the T-Rex when the space key is pressed.
• Continuously move obstacles to the left to simulate running.
• Detect collisions between the T-Rex and obstacles.
• Track and display score based on survival time.

Sprites:
• T-Rex sprite (main character).
• Obstacle sprite (e.g., cactus).
• Ground sprite (optional, to create a running effect).
• Backdrop (e.g., desert background).

Game Algorithm:
1. Start Game:
o Initialize score to zero.
o Place T-Rex at starting position.
o Begin background music or animation (optional).
2. Jump Action:
o If space key is pressed and T-Rex is on the ground,
▪ Move T-Rex upward (jump).
▪ Wait briefly.
▪ Move T-Rex downward (fall back to ground).
 3. Obstacle Movement:
o Move obstacle sprite continuously from right to left.
o When the obstacle reaches the left edge, reposition it to the right side to repeat.
4. Collision Detection:
o If T-Rex touches the obstacle,
▪ Show "Game Over" message.
▪ Stop all motions and end the game.
5. Score System:
o Continuously increase score by 1 every second while the game is running.
o Display the current score on the screen.

Lessons Learned:
• Event Handling: Reacting to key presses and green flag events.
• Motion and Timing: Creating natural jump movements and continuous motion.
• Collision Logic: Detecting object interaction for game over conditions.
• Variables and Loops: Using score variables and repeat loops effectively.
• Creative Design: Customizing game elements like characters, backgrounds, and
obstacles.

Final Outcome:
Students are able to:
• Create a functional side-scrolling game.
• Apply logical flow to control jumping and obstacle avoidance.
• Track and display score based on survival time.
• Demonstrate a complete understanding of interactive game development using PictoBlox.
 Water Cycle Animation
Project Description:
The Water Cycle Animation project in PictoBlox visually demonstrates the key stages of the
water cycle—evaporation, condensation, precipitation, and collection—through animated sprites
and backgrounds. It is ideal for combining science with programming and helps students
understand environmental processes while learning to animate, use broadcast messages, and
manage sequences.
This project develops both subject knowledge and creativity using block-based coding.

Objective
• Animate each stage of the water cycle.
• Use broadcast messages to trigger transitions.
• Label each stage with appropriate text.
• Create an educational animation using sprites and backdrops.

Sprites:
• Sun sprite (for evaporation).
• Water source (sea/lake/river) sprite.
• Cloud sprite (for condensation).
• Rain drop sprite (for precipitation).
• Ground or plant sprite (for collection).
• Backdrop (sky, ground, and water).

Animation Algorithm:
1. Start Animation:
o When the green flag is clicked, start the animation from the evaporation stage.
2. Evaporation:
o Show the sun shining on the water surface.
o Animate water turning into vapor rising upwards.
o Broadcast message to move to the condensation stage.
3. Condensation:
 o Show water vapor forming clouds.
o Gradually increase the size or opacity of the cloud sprite.
o Broadcast message to move to the precipitation stage.
4. Precipitation:
o Animate raindrops falling from the cloud to the ground.
o Show rain splashing or collecting at the bottom.
o Broadcast message to move to the collection stage.
5. Collection:
o Animate rainwater collecting in a lake, river, or being absorbed by the ground.
o Loop back to the evaporation stage to show the cycle continuously.
6. Labeling:
o Display text labels for each stage (e.g., "Evaporation", "Condensation") when that
stage is active.
o Optionally add narration or background music.

Lessons Learned:
• Understanding Scientific Concepts:
Visualizing the complete water cycle interactively.
• Sequential Logic:
Using broadcast messages and timing to manage stages in order.
• Animation Skills:
Moving, fading, and resizing sprites to create natural effects.
• Design and Presentation:
Organizing educational content into engaging animations.

Final Outcome:
Students were able to:
• Create a looping animated sequence representing the water cycle.
• Apply logical sequencing using broadcast messages.
• Label and explain each stage of the cycle.
• Present a science-based animation project confidently using PictoBlox.
 Pong Game
Project Description:
The Pong Game project in PictoBlox recreates a simplified version of the classic arcade game
"Pong." Players control a paddle to bounce a ball back and forth, preventing it from touching the
edge. It helps students understand interactive game development, collision detection, motion
control, and scoring using block-based programming.
This project promotes quick thinking, reflex-based gameplay, and foundational programming
concepts.

Objective
• Move the paddle using arrow keys.
• Bounce the ball off the paddle and walls.
• End the game if the ball touches the bottom edge.
• Optionally, keep score for each successful bounce.

Sprites:
• Ball sprite (moves and bounces).
• Paddle sprite (controlled by player).
• Backdrop (can be a plain color or classic arcade design).

Game Algorithm:
1. Start Game:
o Set the ball and paddle to their initial positions.
o Point the ball in a random starting direction.
o Set the score to zero.
2. Paddle Control:
o Detect left and right arrow key presses.
o Move the paddle left or right accordingly.
3. Ball Movement and Bounce:
o Continuously move the ball in its current direction.
o Bounce off left, right, and top walls.
 o If the ball touches the paddle, bounce upward and increase score.
4. Game Over Condition:
o If the ball touches the bottom edge of the screen,
▪ Display "Game Over".
▪ Stop the game.
5. Score Tracking (Optional):
o Increase the score by 1 each time the ball hits the paddle.
o Display the score on screen throughout gameplay.

Lessons Learned:
• Motion and Control:
Moving objects based on key input and applying direction-based motion.
• Collision Detection:
Recognizing when sprites touch and responding (bounce or end game).
• Variable Usage:
Managing and displaying a live score counter.
• Game Flow Design:
Structuring start, ongoing interaction, and end conditions.

Final Outcome:
Students were able to:
• Develop a fully functional bouncing ball game.
• Control a paddle and manage interactions with a ball sprite.
• Display a score and recognize win/loss conditions.
• Understand and apply core programming logic in PictoBlox.
 Traffic Control City
Project Description:
The Traffic Control City project in PictoBlox simulates a smart city traffic system where traffic
lights and pedestrian signals manage vehicle and pedestrian movement at a crossroad. This
project integrates multiple sprites to replicate a real-life traffic intersection with cars, traffic
lights, and a pedestrian walking across when the signal allows.
It teaches students system coordination, automation, conditionals, broadcasting, and safety logic
using block-based programming.

Objective
• Simulate traffic light changes for vehicles.
• Stop vehicles at red and allow at green.
• Include a pedestrian who crosses only on a green walk signal.
• Synchronize traffic and pedestrian signals using broadcast messages.
• Reinforce understanding of safety and rules in a traffic system.

Sprites:
• Vehicle sprites (cars, buses, etc.)
• Traffic light sprites (with red, yellow, and green lights)
• Pedestrian sprite (e.g., a person walking)
• Pedestrian signal sprite (shows "Walk" and "Stop" symbols)
• Road/intersection backdrop (with zebra crossing)
• Optional: Buildings, trees, and background elements

Simulation Algorithm:
1. Initialize Scene:
o Set all traffic and pedestrian lights to red/stop.
o Place vehicles at starting points and the pedestrian at the sidewalk.
2. Traffic Light Sequence:
o Broadcast to turn one direction green and others red.
o Vehicles in the green-light direction start moving.
 o After a few seconds, switch lights and broadcast the next direction.
3. Pedestrian Signal Logic:
o When all vehicle lights are red, broadcast "pedestrian green."
o Show the "Walk" signal on the pedestrian light sprite.
o Animate the pedestrian crossing the zebra path.
o Once crossed, switch back to "Stop" and continue traffic light cycle.
4. Vehicle Movement Logic:
o If in front of red light, vehicles stop.
o If green, they move forward at a fixed speed.
5. Repeat the Cycle:
o Loop the traffic light and pedestrian logic to simulate an ongoing city system.

Lessons Learned:
• Automation of Real-World Systems:
Understanding traffic flow and pedestrian safety through code.
• Broadcasting and Timing:
Using broadcast messages to manage stage transitions.
• Conditional Movement:
Vehicles and pedestrian only move based on signal status.
• Coordination of Multiple Sprites:
Managing multiple moving objects and interactions in one system.
• Design Thinking:
Adding realistic urban elements and safety features like zebra crossings and stop signals.

Final Outcome:
Students were able to:
• Simulate a functioning city traffic and pedestrian control system.
• Coordinate sprite behaviors using logic, broadcasts, and timing.
• Understand the importance of traffic and pedestrian signals.
• Build a real-world-inspired animation using PictoBlox.