Written by: Rémy CHARLES
Created on: 2024-09-23
Last updated: 2024-10-04
Reviewed by: Camille GAYAT
- I. Introduction
- II. Game Design
- III. Non-Functional Requirements
- IV. Development Plan
- V. Risk Management
- V. Compliance and Standards
- VI. Future Enhancements
- VII. Conclusion
| Term | Definition |
|---|---|
| Frogger | Frogger is a classic arcade game developed by Konami and released in 1981. The game involves guiding a frog across a busy road and river, avoiding obstacles and hazards along the way. |
| FPGA (Field-Programmable Gate Array) | A semiconductor device that can be configured after manufacturing by a customer or a designer using specialized software and a hardware description language (HDL). It is made up of a matrix of configurable logic blocks (CLBs) connected via programmable interconnects. |
| HDL (Hardware Description Language) | A specialized computer language used to describe the structure and behavior of electronic circuits, and commonly used in the design and development of digital logic in FPGAs. |
| Verilog | A hardware description language (HDL) used to model electronic systems. It is most commonly used in the design and verification of digital circuits at the register-transfer level (RTL) of abstraction. |
| VGA (Video Graphics Array) | A standard for video display controller first introduced with the IBM PS/2 line of computers in 1987. It is widely used for displaying graphics on computer monitors and other display devices. |
| Sprite | A two-dimensional image or animation that is integrated into a larger scene or game. Sprites are commonly used in video games to represent characters, objects, and other elements of the game world. |
| Frame Rate | The rate at which consecutive images (frames) are displayed in a video game or animation. A higher frame rate results in smoother motion and more fluid animations. |
| Input Lag | The delay between the player inputting a command and the game responding to that input. Input lag can affect the responsiveness and playability of a game. |
This project aims to recreate the classic arcade game "Frogger" on an FPGA platform.
The vision of this project is to provide an interactive and engaging gaming experience that pays homage to the classic arcade game Frogger. By leveraging the capabilities of FPGA technology, we aim to create a faithful recreation of the original game with enhanced graphics.
This game will be designed to appeal to both nostalgic players who remember the original Frogger and new players who are looking for a remastered version of a classic game.
- Technology: Implement the game logic and graphics using Verilog HDL on an FPGA platform.
- Gameplay: Recreate the classic Frogger gameplay with enhanced graphics.
This project will be developped on a "Go-Board" FPGA platform. Using Verilog HDL, we will implement the game logic, graphics, and user interface elements required to recreate the classic Frogger game.
The target audience for this game includes players who enjoy classic arcade games, retro gaming enthusiasts, and fans of the original Frogger game. The game is designed to appeal to a wide range of players, from casual gamers looking for a fun and challenging experience to hardcore gamers seeking to test their skills and reflexes.
Sam, the Retro Gamer
- Age: 35
- Occupation: Web Developer
- Gaming Preferences: Prefers nostalgic, retro-style video games from the 80s and 90s.
- Goals: To relive childhood gaming experiences through a modern rendition of classic games.
- Challenges: Often disappointed by modern games that fail to capture the essence of retro gameplay.
- Motivations: Seeks games that offer a genuine retro feel with updated performance and graphics.
- Tech Savviness: High—familiar with both classic and current gaming platforms.
- Gameplay Expectations: Prefers simple, intuitive controls and pixelated graphics reminiscent of early gaming consoles.
Jordan, the Competitive Player
- Age: 28
- Occupation: Financial Analyst
- Gaming Preferences: Favors games that require quick reflexes, strategic thinking, and feature competitive leaderboards.
- Goals: To master each level and top the global leaderboards.
- Challenges: Experiences frustration with games that have unpredictable controls or poor response times.
- Motivations: Driven by a competitive spirit to excel and achieve recognition in the gaming community.
- Tech Savviness: Moderate—primarily interested in gaming performance, not the underlying technology.
- Gameplay Expectations: Expects smooth, responsive gameplay and well-designed levels that challenge skills.
Casey, the Casual Gamer
- Age: 24
- Occupation: Graduate Student
- Gaming Preferences: Looks for fun, stress-relieving games that are easy to pick up and play in short bursts.
- Goals: To find games that are entertaining and relaxing, without a steep learning curve.
- Challenges: Has limited time for gaming due to a busy schedule.
- Motivations: To unwind and have fun without the commitment required by more complex games.
- Tech Savviness: Low—more interested in the game's content than its technical aspects.
- Gameplay Expectations: Prefers games with simple mechanics, straightforward objectives, and the ability to save progress easily.
The main deliverables are the source code of the game, supported by multiple versions of this game and mockups of the design.
Other deliverables include:
- Functional Specification Document
- Technical Specification Document
- User Manual
- Test Plan and Test Cases
- Management Plan & Weekly reports
| Name | Role | Contact (Click) |
|---|---|---|
| Alexis LASSELIN | Project Manager |   |
| Rémy CHARLES | Program Manager | |
| Michel RIFF | Tech Lead | |
| Mathias GAGNEPAIN | Software Engineer | |
| Camille GAYAT | Quality Assurance | |
| Salaheddine NAMIR | Technical Writer | |
| Name | Role |
|---|---|
| Franck JEANNIN (ALGOSUP) | School Director |
| Role | Description |
|---|---|
| Project Manager | Responsible for overall project planning, coordination, and communication. |
| Program Manager | Responsible of deadlines and deliverables. Design of the project is under his direction. Should deliver the functional specification |
| Tech Lead | Responsible for technical design and implementation of the project. |
| Software Engineer | Responsible for developing and testing the game logic and graphics. |
| Quality Assurance | Responsible for testing the game and ensuring that it meets the specified requirements. |
| Technical Writer | Responsible for documenting the project and creating user manuals. |
Storyline
Frogger is a frog aiming to return home safely after a day’s wandering. The journey home is fraught with dangers: busy highways and treacherous rivers filled with obstacles. Help Frogger navigate these perils to reach the safety of his lily pad on the other side of the road and river.
Theme
The theme of "Frogger” centers on the quest for safety and the inherent dangers of an everyday journey in a perilous environment. This theme embodies the universal struggle against obstacles, both in the natural world and human-created challenges, reflecting on the risk and vigilance needed in daily survival.
The main objective of the game is to guide Frogger safely across the road and river to reach the other side of the road and river. For that, the player must:
- Avoid getting hit by cars on the road.
- Cross the river by jumping on logs and avoiding sinking into the water.
- Reach the lily pad on the other side of the river 5 times to complete the level.
The player’s goal is to successfully guide Frogger across the road and river to reach the other side of the road and river. The player must navigate through multiple levels, each with increasing difficulty and obstacles, to complete the game.
Player Movement
- Controls: Players use directional inputs to move Frogger up, down, left, and right across the screen. The goal is to navigate from the bottom of the screen to the safe zones located at the top.
- Movement dynamics: Each press of a control results in Frogger hopping one grid space in the chosen direction. The frog cannot move diagonally and cannot move outside the boundaries of the game screen.
Level Progression
- Multiple levels: The game consists of multiple levels, each with a different layout of obstacles and challenges.
- Increasing difficulty: Each level increases in difficulty, with faster-moving cars, more obstacles in the river, and other challenges to overcome.
Challenges
- Road hazards: Cars and trucks move across the road at varying speeds. Frogger must avoid getting hit by these vehicles to stay alive.
- River obstacles: Logs and turtles move across the river, providing platforms for Frogger to jump on. Frogger must avoid falling into the water to survive.
Scoring Mechanism
- Reaching the other shore: Each time Frogger successfully reaches the other shore, player access to another level.
- Time Bonus: Players receive additional points based on the amount of time left on the timer after reaching the shore.
Road
- Cars: Red cars move from left to right, blue cars move from right to left, and racing cars move in both directions at high speeds.
- Trucks: Trucks move across the road at a slower speed than cars.
River
- Logs: Logs move across the river at varying speeds, providing platforms for Frogger to jump on.
- Turtles: Turtles move across the river, allowing Frogger to jump on them. Some turtles submerge underwater, making them unsafe to jump on.
Difficulty Curve
- Increasing Difficulty: Each level increases in difficulty, with faster-moving vehicles, more obstacles in the river, and other challenges to overcome.
- Progression: Reaching the other shore resets the level with increased difficulty, including faster-moving vehicles and more erratic river obstacles.
Death
- Collision: If Frogger collides with a vehicle on the road or falls into the water, the player loses a life.
- Lives: Player has only 1 life to complete the level. If Frogger die, the game is over.
Victory
- Completing Levels: Players must guide Frogger safely across the road and river to reach the other shore and complete the level.
- Progression: Completing all levels in the game results in victory.
Frogger
Static Frogger
By default, Frogger is displayed in a static position facing up, down, left, or right.
Jumping Frogger
When Frogger moves in a direction, an animation shows the frog jumping in that direction.
Death
When Frogger collides with a vehicle or falls into the water, a death animation is displayed.
Cars
Red Cars
Blue Cars
Racing Cars
Different types of cars move across the road at varying speeds.
Trucks
Trucks move across the road at a slower speed than cars.
Logs
Logs move across the river, providing platforms for Frogger to jump on.
Turtles
Swimming Turtles
Allowing Frogger to jump on them, turtles move across the river.
Submerged Turtles
When submerged, turtles do not provide a platform for Frogger to jump on.
Background
Spawn Land
Road
Middle Land
River
End Land
Main Menu
- Title: The game title is displayed prominently at the top of the screen.
- Start Button: Players can start the game by pressing on a button.
Game Screen
- Frogger: The player’s frog character is displayed at the bottom of the screen.
- Road: The road with moving vehicles is located in the middle of the screen.
- River: The river with moving logs and turtles is located at the top of the screen.
- Timer: A timer counts down the remaining time for the player to complete the level.
Game Over Screen
- Game Over Message: A message is displayed to inform the player that the game is over.
- Restart Button: Players can restart the game by pressing on a button.
Controls
- Up ↑: Move Frogger up one grid space.
- Down ↓: Move Frogger down one grid space.
- Left ←: Move Frogger left one grid space.
- Right →: Move Frogger right one grid space.
Visual Feedback
- Movement: Frogger hops in the direction chosen by the player, providing visual feedback on the player’s input.
- Collision: When Frogger collides with a vehicle or falls into the water, a visual indicator shows the collision.
Frogger Colors
#16fa00#e4ff34#2c6d1e#ffffff#000000
Death Colors
#822fa1#fbf236#d51c1c
Red Cars Colors
#ff0404#e00000#fffcb5#fbf236#ff8704#ffffff#e5e5e5#5fcde4#6abacb#9badb7#85949c
Blue Cars Colors
#0f0092#000078#fffcb5#fbf236#ff8704#ffffff#e5e5e5#5fcde4#6abacb#9badb7#85949c
Racing Cars Colors
#db0000#a70000#ffffff#fbf236#9badb7#242424#222034#847e87#9c9c9c#696a6a
Trucks Colors
#121b49#ff2121#fbf236#eecd9a#0000ff#ffffff#222034#8cb7c1#bcf3ff
Moving to the left: 
#ff0000
Moving to the right: 
#fba6ff
Logs Colors
#d55c31#b16f4f#dbdbdb
Turtles Colors
#ff0b00#31ff1e#ffffff
Spawn Land Colors
#222034#1c7233#99e550#fbf236#ac3232#639bff#df7126#ffffff
Road Colors
#3c3858#d5d5d5#ffffff
Middle Land Colors
#222034#1c7233#99e550#2061b6
River Colors
#2061b6#2777e0
End Land Colors
#2061b6#d77bba#76428a#99e550#1c7233
Animated Sprites
Swimming Turtles Animation
Submerged Turtles Animation
Jumping Frogger Animation
Death Animation
The game should respond to player inputs without noticeable lag. The movement of Frogger should be smooth and responsive to the player’s commands.
The game should run at a consistent frame rate to provide a smooth and enjoyable gaming experience. The frame rate should be optimized to ensure that animations and movements are displayed without stuttering or lag.
The game should be optimized to use FPGA resources efficiently. This includes minimizing the use of logic elements, memory blocks, and other resources to ensure that the game runs smoothly on the FPGA platform.
The game should be designed to minimize power consumption on the FPGA platform. This includes optimizing the design to reduce power usage and heat generation during gameplay.
The game will be developed using Verilog HDL on an FPGA platform. Verilog allows for the design and implementation of digital circuits, making it well-suited for creating the game logic and graphics required for Frogger.
Why Verilog?
- Hardware Description: Verilog is a hardware description language that allows for the modeling of digital circuits at a low level.
- FPGA Compatibility: Verilog is commonly used in FPGA development, making it a suitable choice for implementing the game on an FPGA platform.
- Performance: Verilog allows for efficient design and optimization of digital circuits, ensuring that the game runs smoothly on the FPGA.
- Platform: FPGA (Field-Programmable Gate Array)
- Language: Verilog HDL
- Resolution: VGA (Video Graphics Array)
Inputs Specifications
There are 4 Switches to control the frog movement also for the start and reset of the game.
When you are in the Main Menu, you can start the game by pressing one of the switches.
When you are in game you can move the frog with the switches 1, 2, 3 and 4:
- Switch 1: Move the frog up.
- Switch 2: Move the frog left.
- Switch 3: Move the frog right.
- Switch 4: Move the frog down.
And when you are in the Game Over Screen, you can restart the game by pressing one of the switches.
All those inputs will send a binary signal (1 or 0) to the FPGA.
Outputs Specifications
The VGA screen will display the game screen, including the frog, cars, logs, turtles, etc. The 7-segment display will show the current level of the game.
- Switches: Input from the player using directional switches to control Frogger’s movement.
- VGA Display: Output to the player using a VGA display to show the game screen and graphics.
- 7-Segment Display: Output to display the current level of the game.
- Logic Elements: Limited number of logic elements available on the FPGA platform.
- Memory Blocks: Limited memory blocks available for storing game data and graphics.
- Clock Speed: Maximum clock speed supported by the FPGA platform.
graph TD;
A[Player] -->|Controls| B[Frog]
B -->|Moves| C[Game Map]
C -->|Contains| D[Lanes]
C -->|Contains| E[River]
C -->|Contains| F[End Land]
D -->|Has| G[Cars]
E -->|Has| H[Logs]
E -->|Has| I[Turtles]
F -->|Goal| J[Scoring]
J --> K[Level Up Conditions]
K -->|Check| B
Phase 1: Planning and Design:
- Define game concept, gameplay mechanics, and visual elements. Develop graphics, sprites, and animations for the game.
- Finalize game design documents and obtain approval.
Phase 2: Development and Implementation:
- Implement game logic, player movement, and level design. Integrate game elements, controls, and feedback mechanisms.
Phase 3: Testing and Deployment:
- Conduct unit tests, integration tests, and system tests. Address bugs, optimize performance, and finalize game features. Prepare user manual, documentation, and deployment plan. Final review, presentation, and project submission.
Week 1-2: Planning and Design:
- Week 1: Project kickoff, team formation, and planning. Start writing the functional specification, technical design, and game concept development.
- Week 2: User interface design, visual elements, and color palette selection. Finalize design documents, review, and approval. Deliver the functional specification.
Week 3-4: Development and Implementation:
- Week 3: Implement game logic, player movement, and level design. Integrate game elements, controls, and feedback mechanisms. Develop graphics, sprites, and animations for the game.
- Week 4: Test game functionality, performance, and resource utilization. Conduct unit tests, integration tests, and system tests. Prepare user manual, documentation, and deployment plan.
Week 5: Review and Presentation:
- Week 5: Final review, presentation, and project submission.
The budget for this project includes the cost of the FPGA platform, development tools, and other resources required for game development. The budget will be allocated based on the cost of hardware, software, and other expenses associated with the project.
- Hardware Compatibility: Ensuring that the game is compatible with the FPGA platform and can run smoothly without performance issues.
- Software Development: Developing the game logic, graphics, and animations using Verilog HDL may pose challenges due to the complexity of game development.
- Time Constraints: Meeting project deadlines, milestones, and deliverables may be challenging due to the complexity of game development.
- Scope Creep: Expanding the scope of the project beyond the defined requirements may impact project timelines and deliverables.
- Hardware Availability: Availability of FPGA platform, development tools, and other resources may impact project development and testing.
- Team Collaboration: Ensuring effective communication, coordination, and collaboration among team members may pose challenges.
- Hardware Compatibility: Conduct thorough testing and optimization to ensure that the game runs smoothly on the FPGA platform.
- Software Development: Break down the game development process into manageable tasks, conduct code reviews, and seek assistance when needed.
- Time Constraints: Develop a detailed project plan, set realistic milestones, and monitor progress to ensure timely completion of deliverables.
- Scope Creep: Define project scope, requirements, and deliverables clearly to prevent scope creep and maintain focus on project goals.
- Hardware Availability: Ensure that all required hardware, software, and resources are available before starting the project. Plan for contingencies in case of resource unavailability.
- Team Collaboration: Establish clear communication channels, assign roles and responsibilities, and conduct regular team meetings to ensure effective collaboration.
- Hardware Compatibility: Identify alternative hardware platforms or development tools that can be used as backups in case of compatibility issues.
- Software Development: Seek assistance from mentors, instructors, or online resources to address complex software development challenges.
- Time Constraints: Allocate buffer time in the project schedule to account for unexpected delays or challenges. Prioritize critical tasks to ensure that essential deliverables are completed on time.
- Scope Creep: Conduct regular reviews of project scope, requirements, and deliverables to prevent scope creep. Seek approval for any changes to the project scope.
- Hardware Availability: Maintain a list of alternative resources or platforms that can be used in case of unavailability. Plan for resource constraints and adjust project timelines accordingly.
- Team Collaboration: Establish clear communication protocols, assign backup roles, and conduct regular team meetings to ensure that team members are aligned and working effectively.
IEEE Standards:
- IEEE 1364: Adhering to robust standards for Verilog hardware descriptions, ensuring compatibility and reliability.
- IEEE 1076: Following IEEE standards for VHDL design, ensuring consistency and quality in the development process.
Documentation Standards:
- ISO/IEC/IEEE 26515: This standard guides our agile documentation strategy, ensuring user manuals and project documentation are continuously updated to reflect current project statuses and changes.
- New Challenges: Introduce new obstacles and challenges in each level to keep the gameplay fresh and engaging.
- Boss Levels: Include boss levels with unique challenges and enemies for players to overcome.
- Speed Boost: Allow Frogger to move faster for a limited time.
- Shield: Provide temporary invincibility to Frogger against collisions.
- Character Skins: Allow players to customize Frogger with different skins and colors.
- Vehicle Skins: Customize the appearance of cars, trucks, and other obstacles in the game.
The development of “Frogger” aims to recreate the iconic arcade game in a digital format using Verilog HDL on an FPGA platform. The game concept, gameplay mechanics, visual elements, and user interface have been designed to provide an engaging and challenging gaming experience for players. By following the project plan, managing risks, and adhering to technical requirements, the team aims to deliver a high-quality game that meets the specified objectives and requirements. The future enhancements and feature roadmap provide a vision for expanding the game with additional levels, power-ups, and customization options to enhance the player experience. With a focus on performance, responsiveness, and resource utilization, the team is committed to delivering a successful and enjoyable game that captures the spirit of the classic Frogger arcade game.