Forem: Liam D.

Project Spotlight: Building an OOP RPG Game Grid

Liam D. — Sat, 23 Nov 2024 03:55:20 +0000

Introduction

For my latest project, I wanted to challenge myself with something more ambitious: creating a grid-based RPG game that leverages object-oriented programming (OOP) principles. This project tested my ability to design, plan, and implement a modular and extensible system, showcasing not just technical skills but also the problem-solving process behind the scenes.

The Concept: Building an RPG Game Grid

The idea was to simulate a playable RPG game where players explore a dynamic grid, encounter enemies, collect items, and navigate toward a final goal. At its core, the grid is represented as a 2D array, but the functionality is driven by the interaction of OOP classes.

Every object in the game, whether a player, enemy, or item, is designed to work together seamlessly. I used inquirer to create an interactive CLI experience, giving the game a simple yet engaging interface.

Challenges and Breakthroughs

The journey from concept to implementation wasn’t straightforward, and most of the difficulty came from planning and structuring the system. Here are some of the challenges I faced and the solutions I discovered:

Planning and Class Structure

One of the key learning moments was designing classes that could extend functionality without redundancy. For instance, a base GridObject class provided shared methods, while PlayerObject, EnemyObject, and ItemObject extended and customized that functionality.

Grid Management

Instead of treating the grid as a standalone variable, I incorporated it as a property of the Grid class. This encapsulated logic like generating and updating the grid, keeping the structure clean and manageable.

Randomized Events

Designing random but balanced outcomes for player actions required careful consideration. I developed an eventSpawner method to control probabilities, ensuring the experience was unpredictable but fair.

Balancing Complexity

Building a turn-based combat system introduced a new layer of challenge, especially in balancing stats like attack, defense, and HP to make encounters engaging and strategic.

Key Features

Object-Oriented Design:
Classes allow the game to be modular and extensible. Adding new objects or mechanics can be done with minimal changes to the core structure.

Dynamic Gameplay:

Encounters, whether combat or item discovery, are randomized for replayability. Players can navigate the grid interactively via CLI, mimicking classic text-based games.

Scalability:

The modular design opens doors for future features, like obstacles, special tiles, or even expanding to a multi-layered grid using a 3D array.

Reflection: Lessons Learned

This project pushed me to think critically about how to translate abstract ideas into functional code. Much of the satisfaction came not just from solving technical problems but also from seeing the game take shape, step by step.

When approaching how to make the grid look a little... "pretty?" I opted for the choice of using emojis, however, found out that most don't even work for me on my terminal and would require me to download a terminal font. So... I said "nah, I'd win' and just used a few of the very limiting amount I can use. Unless something really forces me to use a different font, I prefer the default over the most popular ones.

One of the biggest lessons was the value of planning. Spending time upfront to map out the relationships between classes and methods paid off in the long run, making the implementation phase much smoother. This experience reinforced how much I’ve grown as a developer, especially in tackling complex problems independently.

Looking Ahead

As I move forward, I plan to revisit front-end development, particularly the DOM and React, to strengthen my skills in building interactive user interfaces. At the same time, I’m excited to continue exploring back-end development, especially API design and logic, which I find most rewarding.

Each project helps refine my understanding, not just of code, but of how to approach challenges creatively and methodically. I’m looking forward to building on these skills and seeing where they take me next.

You can find my project here
https://github.com/liamdewitt/adventure-rpg-game

Lessons from My First Project

Liam D. — Tue, 05 Nov 2024 15:17:11 +0000

Building a Pokémon Downloader CLI: Lessons from My First Projects

Transitioning from a Blackjack game to a Pokémon data downloader CLI has been a rewarding (and humbling) journey! Here’s what I learned, where I got stuck, and how each project helped me grow as a developer.

From Blackjack to Pokémon: Building on the Basics

When I worked on my Blackjack game, I got to grips with control flow, conditional logic, and managing user inputs. Blackjack was relatively self-contained, but it gave me confidence to handle project structure and to debug issues as they came up. These fundamentals became incredibly valuable in the Pokémon CLI project, where things were less about game rules and more about fetching and managing external data. Having that foundation helped me focus on the newer, more complex areas, like async functions and error handling.

Async Functions & Error Handling: From Theory to Practice

In the Pokémon CLI, one of the biggest leaps was learning to work with async functions and error handling in a real-world way. Exercises were helpful, but using async/await in this project solidified how to handle API requests, ensuring my program didn’t crash if things went wrong. Each time I handled errors, I learned to expect them as part of the process rather than feeling defeated by them. I’d log out values to narrow down issues, especially when the error seemed to point somewhere unexpected. For example, I got a reference error that seemed unrelated to my changes, only to realize I’d missed updating a reference in another file. I found that console logging was a game-changer in tracking issues back to their source.

Reading Documentation: A Whole New Challenge

One of my toughest challenges was learning to read documentation for packages like inquirer and path. It felt like I was told to find a mythical creature in a forest without knowing what it looked like. Inquirer was manageable after some experimenting, especially when it came to validation options. But path was a different story—I had no idea how to approach it at first. I ended up looking for more introductory resources to get a sense of what path even does and why I’d want to use it.

This process taught me that sometimes it’s okay to step away from the official documentation when it feels overwhelming. I started looking for tutorials and examples to understand the purpose of each package before diving back into the docs for specific features.

Wrapping Up: Takeaways & Next Steps

This Pokémon CLI project felt like a step up in complexity from my Blackjack game, pushing me to grow in error handling, async functions, and reading documentation. I also learned about ArrayBuffer and handling binary data, which I used to store images locally instead of just fetching URLs. While I don’t fully understand all the mechanics of ArrayBuffer, I understand enough to use it effectively in this project.

Looking back, each project builds on the last. While there’s still plenty to learn, it’s encouraging to see these skills evolve. I’m excited to tackle my next project with even more confidence (and maybe a few less mythical creatures to track down in the docs)!

You can find the project on my github!
https://github.com/liamdewitt/pokemon-downloader-cli

Humble beginnings

Liam D. — Sun, 27 Oct 2024 22:04:22 +0000

My name is Liam and I'm 27 years old.

My entire life I've struggled to find a passion or a drive to push me to want to be something and do something.

Honestly I struggled a lot in school. I procrastinated all the time, but afraid of failure, so I would do well enough out of fear, but couldn't focus on the right things in life. This left me feel stunted, confused, and lost in life. I thought everyone felt like this and I was just lagging behind.

Like many in this industry, I played a lot of video games, my pc is my entertainment system, and I always thought computers were cool. Though I have a low self-esteem when it came to what I thought I was capable of, after taking C++ and C# in community college, I thought it wasn't for me. I had a lot of fun, but struggled a lot thinking I wasn't good or smart enough. I eventually opted to go for nursing and that ended up just as well you you'd think. I have nothing but an associates degree to my name. This led me to feel like I had exhausted funds, would have to go back and do other classes if I wanted to steer into something else, I felt defeated and lost.

I was only recently diagnosed with ADHD almost a year ago, now medicated, and a lot of my questions were answered on how and why I struggled so much in school and tasks in general. I wonder the man I could have been by now if I were diagnosed and didn't have this confusing hurdle in my life. I started to self-learn coding after college and found it difficult to stick to it. My ADHD made it crippling to do things I wanted to do, knew was good for me, but couldn't get myself to do it. This led to a inconsistent back and fourth of coding.

However, coming back, feeling like I have more control in my life, I picked it back up, with a new attitude on life. I went back to the basics again with JavaScript and trying to build a sense of confidence and competence in my abilities before I go back to React and building more grandiose projects. It's scary to feel like you have no path in life and so you try to move so fast to catch up, you end up feeling like a fraud. Coming back to the basics and really getting to understand the fundamentals has been a big help in my coding anxiety.

What is my goal? My ultimate goal is to be able to work remotely, ideally, and move to Canada. Or be able to move to Canada and offer my skills!

Here's to learning new things, enjoying that fun, and making something of yourself!

The last project I made was a little blackjack game that is played strict just through node with no real interaction(https://github.com/liamdewitt/blackjack-game), but serves to exercise what I knew at the time. Since then, I've been learning more and plan for a new project soon and looking forward to the struggle and learning pains that follow :)!