Jianwen Ding

- Worked on C++ based game client for a large scale MMO.

- Debugged animation system of client.

= Patched transparency handling, removing crashes and animations spasms.

= Adjusted mousepicking to work with animated models.

= Implemented dirty flagging system for animating previously static objects.

- Patched SQLite save corruption bug and implemented save repair functionality.

- Added Lua functions exposing more parts of the client's graphics engine to scripters.

Trailer created by my teammate Micah Ballard

- In the IndieCade Summer Game Design Internship, students participated in the 2024 Indiecade Climate Jam.

- The internship also involved other tasks such as drafting plans on how to impact enviormental pursuits through the game.

- Within the Climate Jame, I formed a team of 8 to develop the conservation simulator game Frogology.

- The game was developed with Unity and C# by me and two other programmers.

- The main gameplay loop involved learning more about nearby animals while catching them.

Credits of Frogology

Demonstration of out of view animal AI

- I was in charge of was programming and designing the behavior of the animals.

- Animals in Frogology are able to traverse a large map, gathering in points of intrest.

- Animals dematerialize upon moving out of range and sight of player, allowing for animals to still traverse map without preforming physics calculations.

- Non-dematerialized animals generally go towards prey and away from predators.

- Animals are able to avoid collisions while moving.

- Animals can detect predator/prey that fall within a certain FOV or within a certain radius. This emulates the sight and hearing of animals.

Demonstration of non-dematerialized animal AI

Editor representation of overarching quest flow

- I worked on the overarching branching quest system of the game.

- I created a quest creation tool through the Unity Editor that displayed connections between quests and the contents of quests.

- An editor tool for branching dialogue based on the completed quests was also completed by me.

- I integrated the quest system into most if not all of the progression in the game.

- Abilities such as sleeping, going onto certain dialogue branches, and catching certain animals are locked behind quests.

- A save system for quest progress and species logging process was also implemented.

A page of the Speciespedia

A demonstration of a flight around a loaded map

- This program was made as a learning exercise into C++ and rendering as a whole.

- The programs allows for the loading of models along with the insertion of different types of lights.

- This project was made with Visual Studio, OpenGL, GLSL, and C++.

- Other libaries like SDL and Assimp were used.

- Multiple models were loaded into the program from "The Models Resource."

A overhead view of another section of the map I loaded

- I learned the basics of creating different vertex specification.

- Lights of different types and fields were implemented through GLSL.

- I used Assimp to process 3D models into valid vertices and textures to plug in.

- Allowed for loading of multiple textures onto meshes through Texture Arrays.

- Created cube map texture to put together a skybox.

- Applied Quaternions and Linear Algebra to apply transform matrices onto meshes.

A demonstration of multiple lights and models being loaded in my program

An example of multiple instances of the same map model created through the render manager system

- Created a overarching render manager that simplified the process of loading multiple instances of the same model and loading different types of lights.

- A uv system automatically generated custom UVs for textures within texture arrays to offset any padding required.

- A transform class was made that homogenized the process of moving, rotating, and scaling lights and models.

- Transform allows for parent transforms that set transformations relative to the parent transform.

- Specular maps can be plugged into models to create differing levels of specular reflection on objects at different points.

A clip of me playing Strand

- Strand was initially created as a club project of a game development club I founded.

- Initially, the project was worked on during club meeting hours by a group of about 9 people but I continued to work on it individually after my graduation.

- During this project's time as a club project, I was project lead and directed art and music.

- This project was made in C# Unity, with Github as the source control.

- The main gameplay loop of this game involves collecting scrap while fending off zombies.

- Most of my work in this game involves programming and art.

An example of a generated map

- I programmed the randomly generating map that Strand takes place in.

- The map is done in a room based system where each room in the map is assigned a difficulty number, function, and opening directions at the start.

- Resource rooms are distributed at certain "dead ends" to prevent aimless wandering.

- The map itself is simply a grid of connected rooms.

- I created a text proccessor that takes values from a .txt file and turns them into layouts.

- Rooms are randomly assigned a layout with corresponding to the opening, function, and difficulty values.

Some text from the custom grid editor

Display of all enemies within the game

- I handled enemy behavior design and development.

- All of the enemies have a shared base class, as most of them have finite hp, the ability to be grabbed, and a stun state.

- This collectively makes the process of creating unique enemies much simpler.

- 5 unique types of enemies were created by me.

- They all have unique movement patterns in trying to get to or damage the player.

- These behaviors range from walking to player to flying around player and shooting projectiles.

Display of all weapons within the game

- I created programmed weapons into the game.

- Weapons in the game are divided into golden scrap and normal scrap.

- Golden scrap have unusual properties like allowing for telportation or shooting projectiles.

- Base scrap resuse the same code but with modified values *e.g. one basic weapon stuns a bit longer while another does more damage*.

- I made a sizeable chunk of the art in this game us the pixel editor Piskel.

- My work included menu's, half the of enemy animations, and tile sprites.

A short example video of me playing Head Hunters

- Headhunter's is a personal project I started and finished in highschool.

- The game was made in Unity and C# with Github as the source control.

- Headhunter's is a strategy game where the player controls three characters to fight against bosses.

- A total of 6 bosses were created for this game.

- The player can command each character to either shoot, use a special move, or move to an adjacent tile.

- Opposing bosses can do all of the same actions as players can.

- A turn system was created that allowed for a que of events and actions to be inserted.

- This allowed players and enemies to perform their actions, allowed for queing status effects, and allowed for the displaying of special messages.

- Both enemies and players have access to special moves.

- These special moves range from reducing the speed of enemies to rigging another character to explode in a set amount of turns.

- When the player first selects any special move, tiles that these special moves can be cast on and can affect are highlighted.

The move selection screen

These enemies moves and attacks exactly like a knight in chess

- The enemies in this game have all of the same abilities that a player character so a common behvaior system is needed.

- Actions are chosen based on which has the most priority points given to it.

- Priority is affected by the type of action and the path taken before preforming the action.

- Enemies are able to consider movement properties and offensive range of special moves while traversing the battlefield.

- Special moves can be adjusted to give more priority in unique scenarios.

- Changing values on priority calculations creates new behaviors without changing code.

Enemy boss escaping by using movement ability

- All of the animations were done by me by plugging in illustrations from google draw through Unity's animation system.

- The music was done through Musescore and leaned very heavily into funk and rock music.

- The game itself has multiple elements inspired from music from those generes too.

- The name of the game itself is taken from the album "Head Hunters" by Herbie Hancock.

- Many bosses were themed after albums or musical artists I liked at the time.

- This game was made in Unity and with C#.

- The main gameplay loop is that the player dodges bullets while shooting and meleeing enemies.

The hookshot is simply a tag that pulls the players towards it.

- A total of 11 levels were made and designed along with three enemy types.

- Enemies attack by shooting at the player while offsetting the angle by a random amount.

- A save system for level progression and collectible coins was created for this game.

- Riptide Gardens was originally made for the "Spring 2D Jam '24" but ended up requiring more than the three days provided.

- The game was made with Unity and C# with Github as the source control.

- The premise of the game is to escape starvation by planting a garden on an ever-shifting island.

- 10 different plants were created all with different properties.

- Plants range from basic food producers to plants that help or sabotage nearby plants

- All plants have the same base properties including producing food at set times and not being able to be placed in water.

- This game was made for the 2024 Husky Jam and made with the theme "Lighthouse.

- The game was made with me and two other programmers through Unity and C# with Github as the source control.

- I created the ship, sea monster, and ghost ship AI, along with the overall level system of the game.

- Ships move toward lighthouse beams.

- Sea monsters wreck lighthouses and are repulsed by light.

- Ghost ships act like normal ships until they are revealed by being shone on and subsequently attempt to invade the lighthouse.

- This was made for Ludum Dare 54 and made to comply to the theme "Limited Space".

- The game was made with Unity and C# with Github as the source control.

- The game has the player decide to either admit, waitlist, or reject a que of patients.

- I worked with patient data made by a teammate to create a patient generator that produces patients with randomized attributes.

- I created the room vacancy and waitlist system that determines if a patient is able to be admitted.

- I polished up a notification system made by another programmer.

- This game was made for Ludum Dare 46 and adhered to the theme "Keep it Alive".

- The game was made with Unity and C# with Github as the source control.

- Combo Infinity is a fighting game based on keeping a combo alive until a set amount of hits are reached.

- Six different levels were designed and implemented around this concept of perpetuating a combo while avoiding moving hazards.

- This was made for the "GMTK 2021" game jam and complies with the theme "Joined Together".

- The game was made with Unity and C# with Github as the source control.

- In this game, the player controls a spider with the abilities to smash other bugs together and throw those bugs at enemies as a ball while surviving as long as possible.

- Six unique types of enemies and a progressive difficulty system was implemented for this game.

- A webbing system that checks if the player is between two webbed enemies was established.