Project Blog-1

Reflections on My Project Journey

As I near the completion of my capstone project, I’ve had the opportunity to reflect on the challenges, successes, and lessons learned throughout the development process. This journey has been both demanding and rewarding, pushing me to expand my technical skills, problem-solving abilities, and teamwork strategies.

The Most Difficult Challenge and How I Solved It

One of the biggest challenges I faced was implementing a functional turn-based system and game logic for our GameForge-Gameplay project. Designing a system that could handle player turns, dice rolls, and movement mechanics while maintaining synchronization in a multiplayer environment required a well-thought-out approach. Initially, I struggled with ensuring smooth transitions between player turns without introducing delays or conflicts. To solve this, I broke the system into modular components, focusing on a structured state-driven approach in JavaScript. I leveraged event-driven programming and WebSockets to ensure real-time updates and communication between players. Debugging multiplayer interactions was a time-consuming process, but methodically testing different scenarios helped me refine the logic.

Why I Chose This Project and Has It Met My Expectations?

I chose this project because I have always been passionate about board games and game development. The idea of creating a digital platform where players could design and play their own board games fascinated me. So far, the project has met my expectations in terms of technical challenges and creative fulfillment. However, I underestimated the complexity of integrating real-time interactions and UI/UX considerations. Still, seeing our game system come together has been incredibly satisfying.

What Would I Do Differently?

If I could start over, I would spend more time planning the architecture and setting up clear milestones. Early on, we spent a lot of time experimenting with different frameworks before finalizing our approach. A more structured development plan would have saved us time and reduced unnecessary refactoring. Additionally, I would establish clearer communication protocols within the team to streamline collaboration.

Project Management: Well or Poorly Managed?

I believe our project was managed fairly well, but there was definitely room for improvement. Early in the project, we did not set clear deadlines for certain features, which led to some delays. Once we implemented a structured task management system using Trello and held regular check-ins, productivity improved significantly. In hindsight, adopting these strategies earlier would have helped maintain a smoother workflow.

Doubts and Confidence Over Time

At the start, I had doubts about whether we could implement all the features we envisioned. The scope of the project was ambitious, and balancing it with other coursework was a challenge. However, as we made progress and solved problems one by one, my confidence grew. Now, I feel much more assured in my ability to complete the project successfully.

Who Will Use This Project and How Will It Benefit Them?

Our project is designed for tabletop gaming enthusiasts who want a digital platform to create, share, and play board games. It benefits users by providing a customizable experience, enabling them to craft unique gameplay mechanics without needing advanced programming knowledge. The platform also promotes social interaction through multiplayer functionality, allowing players to engage in turn-based games with friends remotely.

Five Key Takeaways from This Project

1. Planning is crucial – A well-defined roadmap prevents unnecessary rework.
2. Break problems into smaller tasks – Tackling one challenge at a time keeps development manageable.
3. Communication matters – Regular check-ins ensure team alignment and efficiency.
4. Debugging in multiplayer environments is complex – Extensive testing is needed to maintain consistency.
5. Adaptability is key – Being open to pivoting strategies leads to better solutions.

Lessons on Teamwork

Working in a team reinforced the importance of clear communication, division of responsibilities, and trust. We encountered moments of misalignment, but by discussing issues openly and adjusting our workflow, we improved our collaboration. Learning to navigate different working styles was a valuable experience.

Handling ‘Stuck’ Moments

Whenever I got stuck, I followed a few key strategies:

• Step away and revisit later – A fresh perspective often leads to solutions.
• Seek help from teammates – Explaining the issue to someone else can bring clarity.

Life Hacks for Managing School and Projects

Balancing school, work, and projects is challenging, but a few habits have helped me stay on top of things:

• Use a planner – Tracking deadlines and tasks prevents last-minute panic.
• Time blocking – Setting dedicated time slots for coursework ensures steady progress.
• Stay organized with version control – GitHub and commit logs help track changes and avoid major setbacks.
• Prioritize self-care – Taking breaks and getting enough rest prevents burnout.

Final Thoughts

This project has been a major learning experience, challenging me to apply both technical and soft skills. While there were obstacles along the way, the progress we’ve made is incredibly rewarding. As we finalize the last steps, I’m excited to see the finished product and how it can be further developed in the future.

Looking back, I’ve grown significantly as a developer, and this experience has reinforced my passion for game development. I’m grateful for the opportunity to work on such a unique and ambitious project, and I look forward to applying these lessons in my future career.

MERN Chat App

For my team’s test app, we created the MERN Chat App, which gave me a hands-on experience with several technologies. My favorite part of the process was working with React. Its component-based architecture and state management made building the UI seamless and reusable. For instance, implementing AuthContext simplified user authentication and ensured consistency across the app.

The most challenging technology we used was MongoDB. Setting up both a local environment and MongoDB Atlas required a lot of trial and error, particularly when managing connection strings and .env files. However, overcoming these challenges helped me appreciate MongoDB’s flexibility with schema-less data.

One key takeaway from this test app is what I’d do differently for our board game project. I’d love to explore Socket.IO for real-time updates, as it’s far more efficient than HTTP polling and would enhance the user experience by providing instant feedback during gameplay.

Clean Code Practices

One area I want to improve in is using meaningful names for variables and functions. From Robert C. Martin’s Clean Code, I learned that clear, names make code easier to read and maintain. Martin writes, “You should name a variable using the same care with which you name a firstborn child,” emphasizing the importance of thoughtful naming.
Bad Example: def c(a, b):
return a * b

Good Example: def calculate_area(width, height):
return width * height

Naming things well eliminates confusion and helps other developers understand the purpose of the code at a glance.

A practice that I will be trying to avoid in the future is redundant comments. Comments should explain the “why” behind the code, not restate the obvious. As Martin notes, “Comments are always failures. We must have them because we cannot always figure out how to make our code expressive enough,” reinforcing that comments should supplement, not substitute for, clarity in code. The following code is a good example of code that shouldn’t have a comment added to it, since it is self-explanatory.

def calculate_area(width, height):
return width * height

By focusing on meaningful naming and avoiding redundant comments, I aim to write cleaner, more professional code, These small changes will help my work’s readability and maintainability in the future.

Source:

Martin, Robert C. Clean Code: A Handbook of Agile Software Craftsmanship. 1st edition, Pearson, 2008, Chapter 1.

Expanding My Skills Over Winter Break

As I continue to work on the project “Create and Play Board Game”, I’m diving deeper into learning the tools and concepts that will bring this project to life. One of my main focuses right now is improving my knowledge of C# for scripting in Unity. While I’ve worked with other programming languages before, C# has its own quirks and best practices, especially when it comes to game development. Learning to write efficient, clean, and reusable code is critical for managing the complex game mechanics.

In addition to C#, I’m also learning how to use Unity itself. Unity is a powerful game development platform, but it has a steep learning curve for beginners. Understanding how to navigate the editor, utilize its many features, and integrate them with my code is a challenge I’m excited to tackle. From setting up the game environment to managing assets and animations, there’s so much to explore.

Most of this learning will take place over winter break. I plan to dedicate time to learning more about these tools, while also studying concepts like resource management for our board game. Resource management is a core mechanic in many board games, and understanding how to balance and implement it effectively will be essential to our project’s success.

This winter break will be a busy but rewarding time as I work to sharpen my skills and bring the project closer to completion. I’m looking forward to sharing my progress in future posts!

Learning Turn-Based Logic

A lot has happened since I first joined the senior capstone project team. Our project, Create and Play Board Games, is a digital platform that combines elements of Euro-style and Dungeon-Crawler games to create an immersive experience for the player. My primary responsibility for this assignment is to implement the turn-based system. This controls how players and AI interact and take actions within each round. To achieve this we’ve decided to leverage Unity’s Turn-Based Toolkit, along with some C# scripting, to implement game logic.

The challenges I have faced with this is mostly about learning how to implement turn-based logic. Here are some of the challenges I’m going to face in the future of this project: Unity’s Turn-Based Toolkit, C# Scripting for Game Logic, GameState Management and Action Economy, Unity’s Event-Driven System, Synchronization in Multiplayer Mode, Debugging and Testing Complex Game Logic, Player Feedback and User Interface Design, and much more. Hopefully in my next post, I’ll be able to share more about the progress I’ve made and some of the specific challenges I’ve encountered while learning these new skills. Developing this board game been a learning experience, and I’m excited to see how it all comes together.

About Me

I live in Houston, Texas, and spend most of my time in the central time zone. Currently for work I am a manager at a Target. I bought my first house with my wife and cat, Leo. In my spare time I enjoy gaming and hanging out with friends and family, which keeps me balanced between school, work, and fun. 

I’ve been interested in computers for as long as I can remember. It all started when I was a kid and got into gaming on my parents laptop. My fascination with games soon expanded into wanting to understand how software works, which eventually led me to pursue computer science at OSU.
At this point, I’m working on sharpening my skills and preparing for future opportunities, possibly an internship in the tech field. My favorite technologies revolve around web development, but I want to start learning more of the software engineering side. 

Although I don’t have my career plans set in stone, I’m excited to keep learning and see where my experiences take me. This project is another stepping stone that will help me define my path.