Week 8: May 25, 2020
Overview
This week, we've been focusing on refining some of the more advanced features of our game. We have more robust
collision detection infrastructure, more data being sent between the server and client to get some UI
information populated, all of the game entity interactions are hashed out and complete, we had our map model go
into the game (which looks amazing!). With a little more work, we will be ready for our spec freeze! We are also
looking forward to getting our game set up on the demo machines and begin testing!
Group Morale
We are feeling pretty good. Of course, there is a little more pressure than usual, since all of the elements of
the game are getting to the point where they should be polished and ready for a demo. However, we feel like we
are in a good position and should be golden by the time demos roll around. We will need to schedule more time to
work as a group throughout the next week since all of the elements of the game are being pieced together more
than ever, and that should help us ease some of our nerves.
Showing Off Our Screen Shots!!
Blender: Map model (with 90% texturing)
Blender: Player's POV (updated)
Lasers!
Super Minion Death Animation
Individual Updates
Charles
Last Week’s Goals:
My goal for last week was to finish up gameplay object interaction and finish expanding the server->client
communication to include necessary game state information for animations and UI.
Completed Goals:
I managed to finish almost everything. I fixed and fleshed out the target acquisition logic for laser towers and
minions, so team-based, proximity-based target acquisition works. Entities die when they run out of health and
are properly deleted and removed from data structures. I expanded the internal variables in entities to include
the information Kevin needs to spawn particle systems and play the correct animations. I also did some
restructuring to make the server's communications to the client easier to read. Aditi, Jimmy, and Hao expanded
the node system for the map, so I fixed some memory errors and verified that entities are interacting with them
properly.
Unmet Goals:
As of writing, I didn't manage to finish player building things in designated spaces, but with the buildNodes
that Aditi, Jimmy, and Hao created, it shouldn't take too long. The bigger question is how do I handle
communicating to the player where and what they will be building. I'm thinking of spawning a hologram type
entity on type of the buildNode while the player is in building mode.
Next Week’s Goals:
Next week, I need to finish player building, and then I need to work with Aditi, Jimmy, and Hao on getting the
game state data that's now communicated to the client displayed in the UI. It would also be nice to get a lobby
system where players can pick their teams up, but it isn't absolutely necessary. Hopefully we can finish it all
by the spec freeze next week.
What I Learned:
It definitely pays to set up a flexible, robust system. Because of the multiple levels of abstraction with
layers of structs and wrappers, expanding server->client communication was really easy. Adding in more entity
data to be communicated was just a matter of adding it to the EntityData struct definition and to the functions
that read and write the struct. Adding state data to be communicated just meant defining a new struct and
putting it in front of the scene data structs.
Individual Morale:
I'm still cautiously feeling pretty good. We've got most of the core gameplay functionality done, which I think
is a good sign. However, we've still got the UI to do, and we've barely touched it so it could either go really
smoothly or really poorly. I think between the 6 of us we should be able to do it, so I'm hopeful that we'll be
able to get everything done by the spec freeze
Esther
Last Week’s Goals:
To finish texture mapping the game map and to texture the animations characters and minions. If time allowed, I
wanted to also add additional animations, such as when players build towers and interact with resources.
Completed Goals:
I finished texture mapping the game map woohoo, and it renders fine on the client. At first I couldn't load the
map because the texture images were too large and took too much memory. Downsizing the texture images resolved
this issue. I also made death animations for the small minion and super minion. Texture mapped the animated
objects and each team's assets will be color coordinated (Red vs Blue team). Now the animated objects render
with the appropriate colors on the client instead of just one overall color. Lastly, I sketched out the UI
design so that Aditi, Hao, and Jimmy can get the UI code going. I also created the some of the UI's image
overlays.
Unmet Goals:
Harvesting and building animations.
Next Week’s Goals:
I need to model the team bases and map surroundings so that the edge of the map isn't noticeable (this will be
pretty easy and quick to do). Also want to make the map a bit more detailed so that the buildings faces are
entirely flat. Make more animations for resource harvesting. Readjust scale of players and map so its
proportional. Finish up UI image overlays and make sure positioning of UI components are displayed correctly on
the demo machines.
What I Learned:
I learned why my previous animations weren't being saved... It had to do with a very unintuitive feature on
Blender 😠 I learned that I hate Blender sometimes. But it's still cool.
Individual Morale:
I think I made a lot of progress on my goals this past week. We haven't started any play testing yet so hope we
are able to get to that this week, especially after testing the demo machines.
Kevin
Last Week’s Goals:
Finish up particle systems, integrate them into a scene graph, interface them with the communication protocol,
and complete the GUI framework.
Completed Goals:
I was able to complete all of last weeks goals. I got particle systems working, triggered on a message from the
server. I also set up a GUI framework.
Unmet Goals:
I met all the goals I set last week, but I probably could have worked more on setting up the client scene
manager
Next Week’s Goals:
Finish fixing all graphics related issues.
What I Learned:
Technical debt is a big issue. I found myself allocating a lot of memory in bad ways early on, and those are
starting to manifest as bugs now. Hopefully I'm able to refactor the code that causes the minor bugs so that the
client can run smoothly on the demo.
Individual Morale:
One week left. A bit in a panic, especially because work from other class is stacking up.
Aditi
Last Week’s Goals:
Work with Jimmy and Hao on implementing some more node classes to support spawn sites and collision detection.
Also get the necessary UI
elements functioning (resource counts should be displayed, player should be able to see what type of unit they
are spawning, etc).
Completed Goals:
We finished amending and creating all of the additional node classes. We also got placeholder images and texts
up on the UI, and now we just need to hook them up to our game's update functions.
Unmet Goals:
Didn't get the UI completely hooked up. We should have that done between tonight/tomorrow.
Next Week’s Goals:
Wrap up any remaining work on the UI. Test the game out on the demo machines, and polish/debug any problems that
arise.
What I Learned:
I finally got to interact with the UI of the game! It was nice to see how everything was set up and was being
rendered. I also became more familiar with the client side code as I was mostly working with server side code
the entire quarter.
Individual Morale:
I feel pretty good with where everything is. I think the spawning of entities is the only real functionality
that still has to be polished and once that is done, we should be primarily testing and debugging. I do wish we
would already be at the point where we could spec freeze and just test having multiple clients interacting with
the server, but we shouldn't be too far off of that milestone.
Hao
Last Week’s Goals:
Last Week’s Goals: Finish up with pathing, and work on game UI.
Completed Goals:
We wrapped up with the pathing stuff on Friday. We added more mapNode which will lead the minions from the spawn
location to the enemy’s base. We also added WallNode and SpawnNode which will be used later. As for UI, we are
able to get some placeholder images and text rendered, but we haven't hook it up with the backend server.
Unmet Goals:
UI display is not completed yet.
Next Week’s Goals:
Get game lobby and UI done!
What I Learned:
I read through the infrastructure code for UI. I got a better understanding about the offset/scale/priority of
the UI components while putting the placeholders. Still need to learn more about how to update the UI when the
game updates.
Individual Morale:
I felt the time pressure when we realized that we have a week and a half until the final demo.🙀 No more animal
crossing for the next two weeks. 😹
Jimmy (Jiajian)
Last Week’s Goals:
Work with Aditi and Hao to work on more pathing, minion spawn locations logic. We also worked a little bit on
the UI.
Completed Goals:
We finished creating sets of path nodes, wall nodes and spawn locations. Also, we started to work on UI.
Unmet Goals:
None
Next Week’s Goals:
Finish up the UI design.
What I Learned:
I learned something when implementing the UI.
Individual Morale:
I feel we got a lot done this week, and we are close to have a completed game.