Collateral Damage Title, artwork by Ian Elquiero

Game Synopsis

In the year 4025, large mechs are built by cities to protect themselves from other neighboring cities. These “Guardians,” equipped with the latest technologies, are extremely powerful, easily capable of clearing acres of land. After Central District's Guardian passed away, tensions grew among its four neighboring cities.

Each city decided that the best way to decide the land's new owner was by Guardian combat. The mech that destroys the most may rebuild the central land in their own image. The rest - is Collateral Damage.



More Info

Platform: PC
Development Engine: Core by Manticore Games
Language: Lua
Source Control: Git
Development Window: January 2020 - May 2020 (Spring Semester of 2020)
Group: The Game Analysis and Development Interest Group (GADIG)


What I programmed and implemented

- Game State Manager
- In-Game UI
- Costume Interface
- Costume Implementation

Other Notes

I learned both Lua and Core within a small amount of time to be able to pass on my knowledge to fellow programmers so we could all be on the same page. My learning process can be found in my project, Bleak.

Due to Covid-19, Collateral Damage was the first project I worked on remotely. We communicated through Discord and like previous projects, used Git for version control. Interactions between Git and Core made development especially tricky. Due to all of this, Collateral Damage was one of the most complex projects I have worked on in terms of team coordination.

Collateral Damage Animated Title
My Thought Processes
Learning a New Language and Engine

Collateral Damage is GADIG's first time working on an entirely new game engine and language outside of Unity and C++ respectively. The primary difficulty I ran into was having to both learn a new language and engine, and be able to simultaneously teach them to fellow programmers that may not be as experienced as myself.

So for me, Collateral Damage really started in December, well before we started development. By the time GADIG started working on Collateral Damage, I was able to comfortably teach and walk programmers through some tutorials on both Core and Lua.

Working in Core, I was both the student and the teacher, constantly learning the ins and outs of Core while also doing what I could to pass that knowledge to others. I also started streaming myself working on my own project in Core through Discord as a means to teach my teammates. That project, Bleak, can be found here.

Collateral Damage HUD

In-Game UI

For Core, creating and implementing the in-game UI was much more fidgety then other programs that allow you to create UI such as Unity, Adobe XD, etc.

Like my previous projects in Necronomicon and Lullaby Heist, I planned to work with GADIG's Art Team to figure out what the HUD should look like. Since all GADIG members were tasked with working in-engine (unlike previous projects), I was instead given assets to implement and program. My job then became to adjust the artwork so that it would properly display in-game information.

The HUD's design displays a strong focus on providing the player with as much information as possible with as little visual noise as possible, in line with the last first person game I programmed for, Necronomicon.

Equippable Costume
Costume Implementation

GADIG's Art Team was created many robotic armor costumes for the player. Instead of fine tuning each individual costume piece to properly fit onto the player, I created a work around. I knew that all of our members were working in engine, so I made an easy to understand tutorial for them to do it themselves.

From there, I was able to put them into a build of the game. This was done by placing Art Team's assets into an object with a script that will constantly spawn an object in a space if there isn't one already. That way, the player will be able to choose from the various costumes before a match begins.

Equippable Costume
Game State Manager

While making Collateral Damage, Core did not have a proper way to transition from one game state to another. So, my goal in Collateral Damage was to have a preparation room for players to equip different costumes before a match starts and teleport them to the start of the game once they were ready.

I programmed a way for players to teleport between the ready room and the game's stage and fleshed out the current game state timers to allow our Design Team to more easily customize the length of a round and amount of time before said round.

Game State Code
What I learned

Making a game in Core can be summed up as drawing from a hodgepodge of systems resulting in an odd amalgamation that's supposed to be a game. Sometimes it works out well; other times you end up with something you were not expecting.

That aside, I was able to quickly pick up an entirely new engine and programming language and be able to teach others how to use them from scratch.

Closing Thoughts

This was the most ambitious project I have worked on thus far. Persevering through the difficulties that 2020 brought along with working in a new engine and an unfamiliar programming language was difficult in its own right.

While I was able to complete my tasks, I cannot say the same thing about everyone. The transition to working solely online while also having to keep up with our studies as students became highly discouraging to many. Many of our members left GADIG for the semester, leaving the rest of us to do what we could and pick up where they left off.

We were not able to finish the game based off of our original designs, such as creating a map with a destructive environment without negatively impacting the computer's performance and implementing working powerups.

If we were given another chance to start from scratch, I believe we could confidently develop Collateral Damage by streamlining our workflow and task distribution.

See an alpha build of the game here