DEV Community: Victoria

🚀 Software Engineering Post-Mortem: Paragon Protectors 🏰🎯

Victoria — Sat, 28 Dec 2024 00:22:41 +0000

🎯 Project Overview

Paragon Protectors is a strategy-based tower defense game built for the One Game A Month #42 game jam using Unreal Engine 5.5. In this game, players must defend against 7 waves of relentless minions while protecting their 40 lives.

Key gameplay features include:

Elemental Upgrades: Towers gain experience and unlock powerful elemental damage as they level up. 🔥❄️⚡
Victory Conditions: Survive all waves to triumph—or lose if all lives are depleted. 🏆

Paragon Protectors delivers a blend of strategy, resource management, and skillful defense planning. 🛡️

🛠️ Initial Project Goals

The primary objectives were:

Remake the Protectors tower defense game series in Unreal Engine. 🏗️
Complete and submit the game for the One Game A Month #42 jam. 🕹️🎮

✅ How We Met Our Goals

Using Agile methodology, I:

Created actionable User Stories for the game’s features. 📝
Tracked progress with a Kanban Board in GitHub Projects. 📋

🎉 Result: The game was completed on time, with functioning towers, tracks, and wave systems.

✨ What Went Well

Level Design:
- Designed a visually clear and functional track for enemies and towers. 🗺️
Programming:
- Engineered tower mechanics, including targeting, attacking, and upgrading. 💻

⚠️ What Went Wrong

Track Visuals:
- Lacked distinct assets to differentiate the track from surrounding tiles. 🎨

🛠️ How Challenges Were Addressed

Track Assets:
- Used geometry brushes and starter content materials to create clear and distinguishable track visuals. 🛠️

💡 Lessons Learned

Level Design:
- Learned how to design effective tracks for a tower defense game. 🛤️
Programming:
- Gained experience in programming towers with mechanics like targeting and leveling up. 💡

🔮 Future Recommendations

Expand Tower Variety:
- Add more towers with unique abilities and effects, such as slowing, poisoning, or stunning enemies. ⚔️🧪
Enhanced Visuals:
- Invest in better assets or custom artwork to improve visual clarity and polish. 🎨✨

🏆 Conclusion

Paragon Protectors was a rewarding project for the One Game A Month #42 game jam. 🎉 It helped sharpen my skills in level design and tower defense programming. I’m looking forward to expanding on these mechanics and creating even more engaging experiences in future games! 🚀

🚀 Software Engineering Post-Mortem: Crown & Conquest 🏰⚔️

Victoria — Fri, 20 Dec 2024 19:05:50 +0000

🎯 Project Overview

Crown & Conquest is a 4X strategy game built with Unreal Engine 5.5 for the Yogscast Games - Jingle Game Jam. Players step into the role of a ruler, striving to conquer neighboring kingdoms by acquiring their crowns. The gameplay revolves around the four key pillars of 4X:

Explore: Navigate the fog of war to uncover new lands. 🗺️
Expand: Grow your empire by crowning neighboring kingdoms. 🌍
Exploit: Harness resources from conquered territories. ⚒️
Exterminate: Subdue hostile kingdoms and bring them under your rule. 🛡️

Crown & Conquest delivers a thrilling blend of strategy, resource management, and medieval conquest. 🏆

🛠️ Initial Project Goals

The primary objectives were:

Create a medieval 4X game using Unreal Engine. 🎯
Complete and submit the game for the Jingle Game Jam. 🎄

✅ How We Met Our Goals

Using Agile methodology, I:

Broke down features into User Stories. 📝
Tracked progress with a Kanban Board in GitHub Projects. 📋

🎉 Result: The game successfully incorporated all 4X elements, included two playable scenarios, and featured a tutorial for new players.

✨ What Went Well

Level Design:
- Designed two engaging scenarios for players to step into the shoes of an empire leader. 🗺️
Core Mechanics:
- Successfully implemented the key 4X elements (Explore, Expand, Exploit, Exterminate). ✅
Player Guidance:
- Created a tutorial—a much-needed addition from my previous 4X game—to help new players ease into the mechanics. 📖

⚠️ What Went Wrong

Art Style:
- Needed assets to capture a medieval atmosphere and immerse the player. 🖼️
Music:
- Lacked an original soundtrack to enhance the gameplay experience. 🎵

🛠️ How Challenges Were Addressed

Art Style:
- Purchased medieval-themed assets from the UE Fab Store, which added the visual flair I needed. 🏰
Music:
- Acquired a soundtrack from the UE Fab Store to enrich the player’s experience. 🎶

💡 Lessons Learned

Level Design: Gained valuable experience in creating scenarios tailored for 4X gameplay.
Tutorial Design: Learned how to craft a player-friendly tutorial that simplifies complex mechanics. 🛠️

🔮 Future Recommendations

Combat Mechanics:
- Add deeper battle and combat mechanics to enhance the "Exterminate" phase of 4X gameplay. ⚔️
Dynamic Systems:
- Incorporate dynamic systems like diplomacy or trade to add more strategic depth. 🤝

🏆 Conclusion

Crown & Conquest was a rewarding project for the Yogscast Games - Jingle Game Jam. 🎉 It pushed my skills in 4X game development, from level design to tutorial creation, while challenging me to deliver a polished product under a deadline. I’m excited to evolve these mechanics and build even greater experiences in the future! 🚀

🚀Software Engineering Post-Mortem: Marble Escape 🎮🌀

Victoria — Sat, 14 Dec 2024 23:20:59 +0000

🎯 Project Overview

Marble Escape is a 3D puzzle game created with Unreal Engine 5.5 for the One Button Game Jam. The game challenges players to navigate a marble through a series of puzzles using just one input button—the Spacebar. 🕹️

Here’s the twist: every 5 seconds, the puzzle’s direction changes! Players must strategically time their moves to escape the level. Think fast, or the marble won’t make it out! 🪄

🛠️ Initial Project Goals

The main objective was to:

Develop a one-button mechanic game. 🎯
Complete and submit the game for the One Button Game Jam. ⏳

✅ How We Met Our Goals

Using Agile methodology, I:

Broke features into actionable User Stories. 📝
Tracked progress with a Kanban Board in GitHub Projects. 📋

🎉 Result: I successfully implemented the one-button mechanic and completed the game in time for the jam!

✨ What Went Well

Level Design: Crafted three unique and engaging 3D puzzles using geometry brushes in Unreal Engine. 🎨
Jam Requirements: Fulfilled the one-button input mechanic requirement for the game jam. ✅

⚠️ What Went Wrong

Art Style Consistency:
- Lacked a polished and cohesive art style. 🎨❌
Player Feedback:
- No clear indicator of the current direction, which could confuse players. 🤷‍♂️❓

🛠️ How Challenges Were Addressed

Art Style: Used starter content textures like grass and cobblestone to create a basic, visually cohesive look. 🪴🧱
Player Feedback: Created a HUD widget to display the current direction, dynamically binding it to the game state. 🧭

💡 Lessons Learned

Level Design: Gained hands-on experience creating 3D puzzles using Unreal Engine’s geometry brushes. 🛠️🎮
Player Feedback: Learned the importance of clear visual communication in enhancing the user experience. 👀

🔮 Future Recommendations

Art Style:
- Import high-quality assets to create a more polished and immersive visual style. 🖼️✨
Level Complexity:
- Design more intricate puzzles to increase the game’s challenge and replayability. 🧩

🏆 Conclusion

Marble Escape was a fun and educational project for the One Button Game Jam. 🎉 It helped me sharpen my skills in level design and UI integration while adhering to strict jam constraints. I’m excited to apply these lessons to future projects and create even better games! 🚀

🚀 Software Engineering Postmortem: Zombie Shootout 🧟‍♂️🎮

Victoria — Thu, 28 Nov 2024 18:40:02 +0000

🎯 Project Overview

Zombie Shootout is a 2D top-down shooter built with Unreal Engine 5.5. Players step into the boots of Tim, a truck stop worker armed with an AK-47, battling relentless zombie hordes to protect a critical bridge. Tim’s goal? Hold the line until reinforcements arrive. This project was created for the 2D Game Jam #2, with the challenge of crafting a complete game in a short timeframe. 🕹️🧱

🛠️ Initial Project Goals

Our goal was simple yet ambitious:

Build a 2D top-down shooter using Unreal Engine.
Complete the game in time for the 2D Game Jam #2. ⏳

✅ How We Met Our Goals

We utilized Agile development with:

User Stories for clear, actionable features. 📝
A Kanban Board in GitHub Projects for task tracking. 📋
Collaborative iterations to complete all the features.

🎉 Result: We delivered a polished, playable game within the deadline!

✨ What Went Well

Visual Cohesion: Seeing all the 2D assets, animations, and UI come together was incredibly rewarding. 🎨✨
Mechanics: All the game mechanics and core features worked flawlessly. No game-breaking bugs! 🛡️🕹️

⚠️ What Went Wrong

Level Design Challenge:
- We skipped using a tilemap or tileset for level creation in Unreal Engine. 🚧
- This added unnecessary complexity to the level design process.

🛠️ How We Addressed the Challenges

Instead of tilesets or tilemaps, we manually:

Placed individual sprites to construct the level directly in the Unreal Editor. 🧩
While this workaround worked, it wasn’t the most efficient method.

💡 Lessons Learned

Level Design Experience: I gained valuable hands-on experience with designing levels using 2D assets. 🎓
Planning Tools: Tilemaps/tilesets could have streamlined the process significantly and are worth the upfront investment. 🗺️

🔮 Future Recommendations

Spend more time on level design and planning, especially with:
- Exploring 2D asset workflows. 🛠️
- Investing in learning tilesets and tilemaps. 🎨

🏆 Conclusion

Zombie Shootout was a thrilling project and a successful submission to the 2D Game Jam #2. 🎉 This journey taught me a lot about game development, and I’m excited to apply these lessons to future projects. 🚀

🚀 Software Engineering Postmortem: Galactic Empire 🌌✨

Victoria — Wed, 20 Nov 2024 19:04:27 +0000

🌠 1. Project Overview
Galactic Empire is a 4X strategy game where players lead their own galactic empire in a quest to dominate the stars. The gameplay revolves around mastering the four pillars of 4X strategy:

Explore 🌍: Discover new planets.
Expand 🏗️: Grow your empire through negotiation or conquest.
Exploit ⚙️: Harness planetary resources to fuel your ambitions.
Exterminate 💥: Wipe out hostile forces to secure dominance. Players choose from three unique races—Humans, Aliens, and Androids—each with their own leaders and bonuses, creating a dynamic and strategic playstyle. This project was created for the Foundry Jam - Found Your Own Indie Studio! with collaboration from nathonkepley.

🎯 2. Initial Project Goals
The main goal was to build a working prototype of a 4X game that emphasizes resource management and showcases how gameplay progresses across the four phases of 4X strategy.

Our user stories were centered around:

Implementing the Explore, Expand, Exploit, and Exterminate phases 🌌.
Designing a resource manager to reflect actions taken in each phase 💾.
Providing a clear and engaging experience of a 4X game’s core mechanics 🛠️.

🛠️ 3. How Were the Goals Met?
We utilized the Agile development process to keep our project on track. Key methods included:

Breaking down the project into user stories ✅.
Organizing and tracking progress via a GitHub Kanban board 📋.
Completing all core features, ensuring a functional prototype of the game. 🎮

🌟 4. What Went Well

Gameplay Integration 🎮: The core phases—Explore, Expand, Exploit, Exterminate—worked cohesively, creating a seamless and enjoyable turn-based experience. Watching the empire grow and resources update dynamically was a major milestone.
Aesthetics 🎶🖼️: The combination of visuals and music created an immersive experience, enhancing the overall gameplay.

⚠️ 5. What Went Wrong

Asset Collection 🎨🚧: Finding assets that fit the space theme was difficult. This limitation forced us to use default or placeholder elements.
State Management 🧩❌: When designing the planetary phases, I mistakenly implemented separate singletons for each phase, leading to a bloated and inefficient system.

💡 6. How Were the Challenges Addressed?

UI/UX Assets 🖌️: I used Unreal Engine’s default UI components to create a clean and functional interface.
Refactoring State Management 🔄: While individual singletons were a temporary solution, I plan to consolidate them into a single unified singleton in the future for cleaner and more efficient code .

📚 7. Lessons Learned
This project provided valuable insights and skills:

UI/UX Design 🎨: Learned to use Unreal Motion Graphics (UMG) and Blueprint Visual Scripting to create interactive elements.
Agile Development 🚀: Effectively applied Agile principles, including user stories and Kanban boards, for project organization.
Code Optimization 🧑‍💻: Gained experience implementing and troubleshooting design patterns, particularly the Singleton Pattern.

🔮 8. Future Recommendations

Enhanced Assets 🌌🎨: Invest time in finding high-quality space-themed UI/UX assets or design a new 4X game that aligns with the available assets.
Code Refactoring 🔧: Refactor the game to use a single, unified singleton for better phase management and scalability.

✨ 9. Conclusion
Galactic Empire is a promising prototype that serves as the foundation for a larger, more polished project. Participating in the Foundry Jam provided an incredible opportunity to kickstart my dream of creating a full-fledged 4X strategy game.

This experience was invaluable, and I look forward to applying the lessons learned in future game development projects. 🚀 Thank you for joining me on this journey—let’s conquer the stars together! 🌠

🚀 Software Engineering Postmortem: The Last Petals of Spring 🌸

Victoria — Fri, 08 Nov 2024 07:56:43 +0000

Project Overview 🌷
The Last Petals of Spring is an immersive Yuri visual novel developed using Unreal Engine 5.5. The game follows Aya, a young protagonist, as she navigates heartwarming choices among her close friends. Most of the gameplay unfolds in Aya's room, where players guide her through various dates and interactions that deepen her connections. Each playthrough offers a unique story, showcasing different emotions and bonds. Players can explore all three romantic paths once a route is completed, providing rich replayability. 🎮✨

Initial Project Goals 🎯
The main goals for this project revolved around implementing the following user stories:

Narrative Progression System 📝
Contextual Dialogue System 💬
Adaptive Audio System 🎵

These goals were visualized and managed via a Kanban Board to keep track of progress and ensure an efficient development workflow. 📋

How the Goals Were Met ✅
Adopting an Agile development approach, I outlined user stories and iterated over them with strategic planning. Using a Kanban board allowed me to maintain a clear visual on progress and deadlines. Thanks to this approach, I successfully completed Milestone Version 1.0, ensuring the core systems were in place and functioning as intended. 🚀

What Went Well 🌟

Completion of Milestone Version 1.0 was a significant achievement. 🏆
All primary user stories were implemented effectively, allowing the game to reach a playable state with all planned features.
The narrative and dialogues were well-received during initial testing for their emotional depth and fluidity. 🌈

What Went Wrong 🐞

I encountered visual bugs with the Visibility attribute of certain components, particularly in Unreal Motion Graphics (UMG) and Blueprint Scripting. This bug occasionally caused UI elements to disappear or render improperly, impacting the player experience. 😅

How the Challenges Were Addressed 🛠️
To tackle the visual bug issues, I turned to ChatGPT's Code Copilot. This tool provided me with invaluable assistance by suggesting Blueprint scripting solutions that helped me debug and resolve the component visibility issues efficiently. 💡🔧

Lessons Learned 📚
Throughout the project, I deepened my knowledge of Unreal Engine's Unreal Motion Graphics (UMG) tool, which is pivotal for creating user widget blueprints. Understanding this tool has greatly improved my ability to design dynamic and interactive UI elements. 🌐✨

Future Recommendations 🔮
Looking ahead, I'm keen on integrating cinematics into the visual novel. I believe this addition would elevate the storytelling experience by adding more visual engagement and emotional weight to pivotal scenes. 🎬🌟

Conclusion 🎉
In conclusion, The Last Petals of Spring has successfully reached Milestone Version 1.0, fulfilling the primary project goals and packaging the game for initial feedback. While challenges like visual bugs posed hurdles, the solutions and lessons gained have equipped me for future improvements. I’m excited for the next chapter of development and potential cinematic enhancements! 🌻👩‍💻

🎮 Software Engineering Postmortem: Project Shooter

Victoria — Mon, 28 Oct 2024 05:28:50 +0000

Project Overview

Project Shooter is a first-person shooter (FPS) game created as an extension of the First Person Template in Unreal Engine 5 (UE5). Built entirely using Blueprints Visual Scripting, the project delivers an immersive FPS experience where players engage in endless rounds of combat. As players progress, the difficulty increases with each level, challenging them to eliminate more enemies. The goal of the project was to enhance the player experience by introducing new gameplay mechanics and improving the core functionality of UE5's template through the integration of a custom tutorial system and various user interface (UI) elements.

Initial Project Goals

The project was heavily inspired by the lessons learned from a technical guide, and the primary goal was to build upon the foundational material provided in the book. The main objectives of Project Shooter were:

Create an engaging tutorial that guides new players through the original mechanics of the First Person Template, while also introducing new features.
Develop a custom HUD (Heads-Up Display) to track important in-game information such as health, ammo, and progress, binding variables to update dynamically.
Enhance level design by incrementally increasing difficulty, ensuring players face a progressively harder set of enemies with each round.

How Goals Were Met

The initial project goals were achieved through:

Blueprint Programming: Leveraging UE5’s Blueprints system, I extended the game by adding a fully functional tutorial. I used the level blueprint to control the flow of the game and duplicated UI widgets to display tutorial messages dynamically during gameplay.
HUD Development: Binding variables in the HUD allowed for real-time updates of player statistics, which significantly improved the user experience by offering clear and timely information on the game state.

What Went Well

One of the key successes of the project was the integration of the tutorial system. I was able to identify and resolve input-related bugs caused by incorrectly used blueprint nodes. By troubleshooting and refining the tutorial, I ensured smooth user interaction and a more polished player onboarding experience.

Additionally, the HUD implementation was a success, as it allowed players to easily track important stats like health and ammo, providing an intuitive interface for in-game information.

What Went Wrong

However, not everything went according to plan. There were two notable challenges:

User Input Bugs: After some tutorial messages failed to display correctly, user input was disabled unexpectedly. This was due to conflicting input modes between the game UI and player controls.
Level Design Flaws: Certain aspects of the level design did not perform as expected. For instance, targets that were not meant to be shot at were accidentally included in the shooting range, which disrupted the intended game flow.

How Challenges Were Addressed

To tackle these challenges:

I utilized ChatGPT to analyze and troubleshoot the user input issue. The problem was traced back to the input mode being set to "UI Only" during the tutorial, which conflicted with the game's InputAction states. After diagnosing the issue, I was able to switch the input mode back to "Game and UI," resolving the bug and restoring player controls.
Regarding level design, I revisited and restructured the environment, ensuring that only the appropriate targets were interactive during combat sequences. This adjustment enhanced the overall player experience and restored the intended gameplay dynamics.

Lessons Learned

During the development of Project Shooter, I learned several important technical skills that will benefit future projects:

Macro Functions in Blueprints: I discovered the importance of using macro functions to encapsulate specific code within individual blueprints. This approach adheres to the Single Responsibility Principle by ensuring each blueprint only handles its relevant tasks. This makes the project more modular and maintainable, which is crucial in professional game development.
SaveGame Class: The SaveGame class in Unreal Engine became a pivotal part of data persistence. By implementing the SaveGame functionality, I ensured that player progress, such as completed levels and earned upgrades, could be saved and retrieved across different gaming sessions. This is critical for maintaining player progression and enhancing replayability.
Artificial Intelligence (AI) Implementation: Although AI wasn’t a primary focus of this project, I began exploring UE5’s AI system, including behavior trees and AI controllers. Mastering AI in Unreal Engine will be essential for creating dynamic enemy behavior and interactive NPCs in future projects, allowing for more engaging gameplay.

Future Recommendations

Looking forward, I recommend continuing to use Kanban boards and Agile iteration planning for organizing tasks and tracking progress. Even though Project Shooter was built on top of lessons from a technical guide, following Agile methodologies ensures structured development and the ability to quickly adapt to changing priorities or challenges.

Conclusion

In conclusion, Project Shooter is a successful extension of Unreal Engine 5’s First Person Template. The project was guided by lessons from a technical guide, and I was able to implement key features such as a custom tutorial system, level design progression, and player stat tracking through a custom HUD. Additionally, I resolved challenges related to user input and level design with the help of debugging tools and problem-solving approaches.

The experience gained from building Project Shooter has deepened my understanding of Blueprints Visual Scripting, UI implementation, and game state persistence using the SaveGame class. These skills will be invaluable in future game development projects as I continue to refine my technical expertise and broaden my knowledge of Unreal Engine.

Blueprint Visual Scripting for Unreal Engine 5 (Third Edition) - A Technical Analysis

Victoria — Mon, 28 Oct 2024 04:27:26 +0000

Introduction
The book Blueprint Visual Scripting for Unreal Engine 5 (Third Edition) by Marcos Romero and Brenden Sewell, with a foreword by Luis Cataldi, Lead Evangelist at Quixel/Epic Games, serves as an essential resource for game developers looking to master the Blueprint Visual Scripting system in Unreal Engine. As a visual scripting system, Blueprints allow developers to create complex game logic without writing traditional code, making it accessible to non-programmers while still offering robust functionality. In this analysis, I will dive into some key concepts from the book, their practical applications, and the strengths and weaknesses of the guide.

Key Concepts Covered
The book tackles several vital concepts in Unreal Engine 5, with three major highlights:

Macro Functions: A pivotal feature in Unreal Engine's visual scripting is the use of macro functions. These macros encapsulate code that is specific to individual blueprints, thereby adhering to the Single Responsibility Principle, a core concept in software engineering. By using macros, developers can ensure that each blueprint only handles the code relevant to its specific function, enhancing both modularity and maintainability. This concept is crucial in professional game development, where efficient code management can drastically reduce development time and minimize errors.
SaveGame Class: Another significant topic discussed is the SaveGame class, which is critical for data persistence in games. This class allows developers to save player progress, ensuring that data such as levels, quests, or inventory can be retrieved across different game sessions. The SaveGame class is particularly important in the context of Agile software development, where features like Persistence and Player Progression are key user stories. By using the SaveGame class, developers can easily implement save/load mechanics and fulfill user stories that enhance the player experience over multiple sessions.
AI in Unreal Engine: Understanding how Artificial Intelligence (AI) is structured and implemented within Unreal Engine is vital for any modern game development, as it affects both single-player and multiplayer experiences. The book covers behavior trees, blackboards, and AI controllers, providing readers with the tools they need to implement challenging and dynamic gameplay. Whether creating enemy behavior or NPC interactions, mastering Unreal Engine’s AI system allows developers to craft more interactive and engaging gaming experiences.

Practical Application
Reading this book has significantly impacted how I approach Unreal Engine 5 development. Here's how the key concepts have influenced my work:

Macros in Blueprint Visual Scripting: Before reading the book, I relied heavily on functions for code encapsulation, which sometimes led to issues such as unintentionally calling functions across unrelated blueprints. For example, in my project Zombie Rampage, I mistakenly called a function from my HUD class instead of triggering an event. Learning about macros allowed me to better encapsulate code, ensuring that each blueprint only exposes the necessary functionality. This dramatically improved my project structure and helped prevent accidental misuse of functions across blueprints.
SaveGame Class Implementation: I was previously unfamiliar with the SaveGame class, but the book provided me with a clear understanding of its importance. Now, I plan to incorporate SaveGame logic into my project Zombie Rampage, allowing players to retain quest completion data across sessions. This will enhance the user experience by ensuring players can pick up where they left off, and it ties directly into my planning process in Kanban, as I now know how to structure the data flow within my game.
AI Implementation with Behavior Trees: The book’s explanation of AI systems helped me build sophisticated behavior trees and blackboards for my zombies in Zombie Rampage. By breaking down the decision-making process of AI into manageable tasks and goals, I was able to fulfill user stories that required AI behaviors, such as chasing players, avoiding obstacles, and forming dynamic group attacks. This knowledge will be crucial as I continue to refine the AI systems in future projects.

Strengths and Weaknesses
The book has many strengths that make it a valuable resource for both novice and experienced developers:

Strengths:

Clear Structure: The guide excels in its organization, with each chapter building logically on the previous one. Quizzes at the end of each chapter help reinforce learning and allow readers to revisit concepts they may not have fully understood on the first pass.
Practical Examples: Rather than overwhelming readers by requiring them to build a game from scratch, the book uses Unreal Engine’s First Person Template, enabling the focus to remain on learning key concepts without getting distracted by level design or other non-essential tasks. This is a smart approach, as it ensures that the readers remain engaged with Blueprint Visual Scripting rather than getting sidetracked by ancillary tasks.
Software Extension Focus: The guide does an excellent job of illustrating how to extend and build on existing templates, a crucial skill for new developers entering the game industry, where adaptability and the ability to extend pre-existing systems is highly valued.

Weaknesses:

Outdated Content: One drawback of the book is that some sections, particularly those covering input mappings and actions, are outdated. Unreal Engine 5 now uses the EnhancedInputSystem, which replaced the older input mapping methods covered in the book. While this is a minor inconvenience, it does mean that readers will need to seek supplemental materials to stay up-to-date with the latest Unreal Engine features.

Conclusion
Overall, Blueprint Visual Scripting for Unreal Engine 5 (Third Edition) is a comprehensive and insightful guide for anyone looking to master Unreal Engine’s visual scripting tools. The book’s clear explanations of key concepts such as macros, SaveGame class, and AI systems have had a direct impact on my projects, making me a more efficient and knowledgeable developer. While there are some outdated sections, the strengths of this guide far outweigh the weaknesses. I highly recommend this book to anyone interested in Unreal Engine 5 development, whether you’re a beginner or looking to deepen your understanding of visual scripting.

🧟‍♂️ Software Engineering Postmortem: Zombie Rampage

Victoria — Wed, 23 Oct 2024 05:17:15 +0000

Project Overview
Project Name: Zombie Rampage
Project Date: 10/22/24
Project Duration: 2 weeks
Team Members: Victoria Uriostegui Jr

Zombie Rampage is a first-person shooter where players are tasked with completing quests that fall into three categories: Defend, Eliminate, and Search. Players must fend off waves of zombies, with mutations introduced as the game progresses. By accumulating in-game currency (EXP) from killing zombies, players can purchase perks to aid in their survival.

🗺 Initial Project Goals
The project followed an agile methodology, using a Kanban board in GitHub Projects to track progress. The goals were divided into loose tasks and user stories:

Loose Tasks:

Construct the main menu.
Create playtesting assets.

User Stories:

Player Safe Haven (spawn and rest area).
First-Person Shooter Experience.
Player Progression (ability to upgrade using in-game currency).
Replayability & Persistence (tracking player progress across sessions).

✅ How the Goals Were Met
All the loose tasks and user stories were completed except Replayability & Persistence, which couldn't be implemented within the project's time constraints. The agile methodology helped prioritize tasks, though the velocity and estimated time for each story could have been better managed.

Key tools and processes:

Agile milestone iterations for planning.
GitHub Projects for tracking milestones and user stories.

🎯 Key Achievements & Milestones
Several important milestones were accomplished throughout the development of Zombie Rampage:

First-Person Shooter Character: A blueprint for a first-person shooter character was implemented, including animations and field of view (FOV) setup.
Animation Blueprint: Created an animation blueprint with state machines for smooth FPS animation blending.
UActorComponents: Configured components like cameras to fit into the FPS skeletal structure, enhancing player immersion.
Skeletal Mesh Integration: All animations and skeletal meshes worked seamlessly with a unified skeleton.
Blueprint Scripting: Over 50+ UObject blueprints were created, including six for UI (UUserWidgets).
Data Table Population: Populated four data tables to organize in-game data for easy reference.
Questing System: Integrated the quest system for the three core quest types (Defend, Eliminate, Search).

😓 What Went Wrong
While there were many successes, some challenges arose during the project:

Agile Planning: The iteration planning didn’t account for velocity or accurate time estimates for each user story, leading to some goals being pushed beyond the deadline.
UI Design Flaws: The UI wasn’t optimized, resulting in redundant code that violated the DRY (Don’t Repeat Yourself) principle. This increased complexity and decreased efficiency.

🛠 Addressing the Challenges

Time Management: I accepted the limitations of the 2-week deadline and trimmed any uncompleted features, focusing on refining the core gameplay experience.
UI Code Optimization: To eliminate code redundancy, I used the map data structure to connect gun purchase buttons to the corresponding data in the Data Tables. This approach streamlined the UI code and reduced duplication.

🎓 Lessons Learned
This project provided many valuable lessons that I will take forward into future endeavors:

Animation Blueprints: I learned how to create complex animation blueprints with multiple state machines that can blend animations, especially useful for characters with intricate skeletons.
Data Table Management: I now have a solid grasp of how to organize game data within Data Tables, making my blueprint scripting more organized and maintainable.
Hit Detection: I implemented hit detection for a first-person shooter, and this experience will help when creating similar or more advanced systems like melee attacks or area-of-effect damage.

🔮 Applying These Lessons to Future Projects
The lessons I’ve learned from developing Zombie Rampage will be invaluable for future projects:

Complex Animations: In future projects, I’ll be better equipped to handle animation blueprints for characters with a high number of bones or complex movements.
Efficient Blueprint-Data Table Planning: I will plan blueprints and data tables together from the start, ensuring that they work harmoniously to avoid inefficiencies.
Advanced Hit Detection: I’m now ready to tackle more advanced hit detection mechanisms, including melee attacks and area-of-effect damage systems.

💬 Conclusion
Developing Zombie Rampage over the course of two weeks was both challenging and rewarding. Despite a few setbacks, the core goals were accomplished, and I gained invaluable experience with animation blueprints, data tables, and optimizing UI code. These lessons will shape my approach to future game development projects, ensuring that each iteration is more efficient and polished than the last.

Software Engineering Postmortem: Real-time Chat Microservice

Victoria — Fri, 18 Oct 2024 04:58:25 +0000

The Real-time Chat Microservice project was a full-stack web application developed using the Firebase ecosystem, React.js, Express.js, and Node.js. The goal was to create a real-time chat experience where users could create an account, log in, and send and receive messages in real time. The messages were saved in Firebase's Firestore Database, and users could view their chat history in an organized manner. This project was completed as part of a Women in Computer Science event, with a tight timeline of just 1.5 hours.

The project followed a tight schedule, with only a day to complete the implementation. The core functionality revolved around:

User authentication via Firebase's Authentication service.
User login and listing all registered users from Firebase Firestore.
Real-time messaging, where users could initiate a chat and have live conversations.
Message history display, where all chat data was saved in Firestore and retrieved for both users in the conversation.

The Firebase ecosystem was utilized heavily for backend services, while React.js powered the frontend interface. This combination allowed rapid development and deployment.

Despite the limited timeframe, the project achieved several key objectives:

User registration and authentication: Users could successfully create accounts using email and password, and this was verified via the Firebase Console.
Login functionality: Users could log in without issues, and the authentication state was managed using Firebase’s onAuthStateChanged method.
Retrieving user data: All user profiles were pulled from Firestore and displayed in a user list for easy selection.
Real-time chat functionality: The app successfully established a real-time chat service. Users could open a conversation, send messages, and receive them in real time, with updates happening instantly.
Message persistence: All messages were saved and displayed correctly, maintaining the order in which they were sent. Firestore's real-time update capabilities ensured smooth message syncing.

There were a few challenges encountered during the development process:

Message collection structure: Defining the correct fields for the message collection in Firestore was initially tricky. Deciding how to structure the documents and ensure efficient retrieval took some time to resolve.
Sorting messages: Incorrect query parameters were initially used to retrieve messages in the correct order. This required careful tuning of the Firestore queries to ensure messages were displayed chronologically within each conversation.
Both issues were eventually resolved, allowing the app to work as intended, but they posed significant hurdles in the short time frame.

Throughout this project, several key lessons were learned:

Query parameters in Firestore: I gained a deep understanding of how to properly use query parameters to filter and sort documents when retrieving data from Firestore collections.
Firestore structure: Working with Firestore was an insightful experience, particularly recognizing its similarities to MongoDB as a document-based NoSQL database.

Overall, the experience was positive, and the project did not require major improvements, given the successful outcomes.

Looking ahead, there are some features that could enhance the real-time chat microservice:

Sending attachments: It would be valuable for users to send files or images as attachments in their chats.
Group chat functionality: Expanding from one-on-one messaging to group chat conversations would significantly increase the app's functionality and use cases.

These features could provide more flexibility and better user engagement in future iterations of the application.

Working on the Real-time Chat Microservice at the Women in Computer Science event was a rewarding experience. Despite the short timeline, the project was a success, delivering a fully functional real-time chat microservice that met all of the original goals. The application effectively handled user authentication, real-time communication, and message persistence using Firebase services.

Overall, the experience was both educational and enjoyable, particularly as it involved working in a collaborative environment with fellow students.

The project was a great success!

Intro To Unity + GitHub

Victoria — Thu, 10 Oct 2024 06:43:28 +0000

On October 7, 2024 I attended the Video Game Development Club's Intro Unity + GitHub workshop. I went into the workshop with some experience with Unity mainly from CSE 165 3-D User Interaction where I explored using Unity's XR & AR toolkits with Meta's Oculus Quest 2.

The workshop started with installing GitHub Desktop in order to clone the repository needed for the workshop. The repository consisted of 2D game assets. We started with designing the level by utilizing sprites & the Sprite Renderer component to visual game objects. Next, we added a Rigidbody2D component to add physics & BoxCollider2D component to detect collisions on the game objects. Furthermore, we created a C# script & went over the Start() & Update() methods. Inside the Update() method I learned how to use Keycodes to read input from the user. As a result one of the C# script's functionality is to detect Keycodes to move the player's sprite. Also, we learned how to apply tags to game objects. As a result the C# script's other functionality is to detect collision & read tags to apply the appropriate game logic to the player's sprite. We ended with pushing and saving the project using GitHub Desktop.

In conclusion, I had no experience working with 2D games going into the workshop. However, I was able to learn how to use Unity to create a 2D platformer. My next steps after this is to make a 2D platformer with Unreal Engine.

WiC Firebase Authentication Workshop

Victoria — Sun, 06 Oct 2024 08:43:18 +0000

On October 3rd, 2024 I attended an event hosted by Women in Computer Science at UCSD. The event was a technical workshop called "Firebase Authentication Workshop." The goal of the workshop is to learn how to implement authentication signup/login system using Firebase. This was achieved through the workshop leader leading us through the Firebase Authentication SDK documentation & implementing it using a provided template repository via GitHub.

After the event I decided to do more research on Firebase & reflect on my code. My findings proved to be really interesting. For starters I wanted to make a connection to microservices because the first time I heard the term was from a Udemy course called "React Front to Back" by Brad Traversy. After discussing with ChatGPT 40 I was able to confirm that the Firebase Authentication Software Developer Kit is a microservice. This sparked me to grasp for a deeper understanding of the relationship between the Firebase Authentication SDK & Firebase. As a result, I learned that Firebase is an ecosystem that provides, manages, & integrates microservices.

Furthermore, while I was reflecting & commenting my code I was curious about getAuth() & the Auth object from the Firebase Authentication SDK. What I discovered was that the auth object is a singleton as part of the Singleton Pattern used by the Firebase Authentication & it's job is to represent the current authentication state and provide API methods to use the Firebase Authentication microservice.

In conclusion, I was able to learn how to use the Firebase Authentication SDK to implement an authentication signup/login system.