Individual Updates
Charles
Last Week’s Goals:
My goals from last week were to finish up networked scene management and to implement classes and player
interaction.
Completed Goals:
It took a lot of work, but I think finishing up the networked scene management system was a resounding success!
First, Jimmy and Hao worked out a skeleton for a multi-threaded approach to handling clients on the server, so I
took what they wrote, fixed it a little bit to work with our system, and integrated it. Next, I had to
completely restructure how data was sent from the server and received on the clients to fix an issue of multiple
server updates in one client update cycle that I had posted about on Piazza. While I was at it, I performed a
little bit of optimization by compressing all server updates within one client update into a single update
buffer that the client-side scene manager could read easier. Finally, I rewrote the client-side scene manager's
update to read the new update buffer. The result is a more robust (I hope) system that should be flexible enough
to handle varying update speeds and scene sizes. I also adjusted the server's tick rate to roughly match the
client's tick rate, but the exact number can be changed easily. I also got some implementation of player
interaction done.
Unmet Goals:
I worked with Kevin to expand the player's input options and wrote skeleton code on the server to accept the new
inputs and allow the player to spawn things and collect resources, but actually spawning things and collecting
resources can't be fully implemented until the game object classes are more finished.
Next Week’s Goals:
My goals for this next week are to work with Aditi on implementing the game object classes so that I can finish
up the player interaction systems. Managing player resources is going to take a bit of an expansion of the
server->client communication, but it should not require too much change. I'll also probably have to work with
Kevin on some object management changes in order to show the right animations at the right time.
What I Learned:
Implementing a flexible, robust (I hope) system takes a lot of work but is definitely worth the effort.
Asynchronous data and functions also change the game entirely. In a synchronous system that I'm used to, when I
push data, I know when it will get pulled, and I never have to worry about data being lost in between context
switches. However, in our system, I have none of those guarantees. When the server sends updated data to the
client, I don't know whether the client will receive that data this tick or the next. I also don't know whether
the client-handling thread will try to read the outbound buffer before the main thread gets to write to it,
resulting in the data not being sent until the next cycle of client-handling thread. The server and client don't
move at the same speed either, so I don't even know whether there will be data on the receive queue or not. But
if there is data on the receive queue, it can't stop reading that data until it is read in its entirety. This
meant I had to figure out which recv's had to be blocking vs nonblocking, and where mutexes had to be locked and
unlocked.
Individual Morale:
I'm feeling good this week. All the asynchronous, byte-reading, multi-threading work that makes my head spin is
done (I hope), and we're moving into much more familiar ground in object interaction and state management, so
I'm feeling positive about our upcoming week. Hopefully we can keep up this momentum.
Jimmy (Jiajian)
Last Week’s Goals:
Finish up multi-threading and network communication.
Completed Goals:
Networking is done
Unmet Goals:
None
Next Week’s Goals:
Next week I will work with Hao and Aditi on minion pathing logic.
What I Learned:
I learned to write multithreading code in c++.
Individual Morale:
I feel exciting about starting the new work.
Esther
Last Week’s Goals:
I planned to start designing the map layout and start modelling the map in Blender (ground texture and
surrounding buildings). I also planned to have idle and running animations for one of the player characters so
that Kevin can test animations on the client. I also wanted to get the build running on my computer so I can
test rendering myself.
Completed Goals:
I finished idle and walking animations for both of the female/male characters. I also finished the walking and
fighting animations for the basic and super minions. These are all the core animations we need for the MVP. I
sketched out a preliminary map layout with designated resource locations and tower building spots. I was also
able to build our project and run the client on my own machine. Kevin was able to test the minion animations and
confirmed that they render fine, with the exception that only one material would render with the animations.
Since the models I built had multiple materials (different colors) per mesh, we think we will have to use
texture mapping instead to add color to our models rather than using materials.
Unmet Goals:
I didn't get to start modelling the map since I had some road blocks. Took me awhile to learn animations, but
once I got the hang of using armatures and vertex grouping, animation is not too bad. The annoying part was that
my walking animations for the female/male characters suddenly just disappeared from my action editor (no idea
why) in Blender and I had to redo them because I did not back up my blender files.
Next Week’s Goals:
I plan to model the entire map by next week based on the preliminary sketch. I also plan to texture map all
animated objects to replace the use of multiple materials. Lastly I plan to learn how to modify the client code
to test render animations so I can stop bothering Kevin every time I have a new model/animation file to test.
Side goal: create animation for player characters when they are building towers.
What I Learned:
Learned how to do animations. Learned to save backup blender files in case things suddenly go wrong. I also
learned the animation export pipeline using scripts that Kevin provided to export animations to be used in our
client code. I also learned how to build our project and run the client.
Individual Morale:
I just realized it's week 7 already...I'm happy that animations worked out! I forsee this upcoming week to be
where the visual components + game logic finally come together. Up until now they have been pretty disjoint.
Kevin
Last Week’s Goals:
To integrate animated objects into the scene graph for instanced animated meshes, and create an animation
controller to manage animation state to allow multiple instances to animate independently. If time allows,
implement animation state machine with multiple clips, and possibly look into partial blending.
Completed Goals:
I was able to succefully instantiate many animated meshes of multiple types at different animation states. I was
also able to load multiple animation clips, and support a method to switch between them. In anticipation of
partial blending, I had this switch controlled by weighting animations (active animation has weight 1 on all
bones inactive have weight 0), but no actual control over partial blending yet.
Unmet Goals:
I wasn't able to work on an animation controller. I felt the current animation interface was intuitive enough,
that I probably won't need to apply it until we get into triggered animations or animation interpolation.
Next Week’s Goals:
Work out collision/proximity detection and start building a GUI.
What I Learned:
I was mostly thinking about collision detection, and I realized that it can be more complicated than I thought.
At first I thought it would be sufficient to do some sort of pairwise optimization, but I realized we will
likely need our collision detection system to be more generalized, detecting types of entities and such.
Individual Morale:
I'm feeling pretty good about graphics now that I know that the animation import pipeline seems to be working
for Esther. Now that it's week 7, I've started to realize that I might not be able to hit all the graphics goals
I set at the beginning (particle systems, bloom, and shadows), but I think graphics are in a pretty stable
state. I had a bit of a slowdown this weekend moving back down to San Diego, and setting up my PC down here (I'm
still getting the localhost issue on my new computer and I'm not sure why), but now that I'm on my usual coding
setup now, I think I'll be able to code more efficiently in these final weeks.
Aditi
Last Week’s Goals:
Finish implementing gameplay logic, including the claw machine tower and the super minion. This included adding
the mining of resources, updating and decrementing the health of bases, units, and towers, and spawning of these
units and towers.
Completed Goals:
The gameplay logic is wrapped up. There is support to do everything from gathering resources, spawning units and
towers, handling attacks on these towers and units, and constant checking on the status of the game.
Unmet Goals:
I wanted to get more work done on actually tying the player interactions to the UI, such as the mining of
resources, the spawning of units, etc. However, we seem to be really close to getting all of it functional. I
think it should be a matter of a day or two at the most.
Next Week’s Goals:
I have to insert some code into the server scene manager to allow the player to spawn minions and towers. Then,
Hao, Jimmy, and I will be working on pathing for the minions and towers. By next week, we hope to have the
pathing complete so the minions and towers will be able to attack the enemy base on their own without player
input and get the game moving.
What I Learned:
We had a group coding session this week through which I was able to get a very clear picture about all the
things that need to be done before we have a good version of the game up and running. We anticipated having our
MVP done sooner than this, but the version of the game we will have now will have more features than we expected
from our MVP. We will have the claw machine tower which can spawn units on its own, and the super minion which
has a better attack than the regular minion. These are both things we didn't expect to have done in the MVP, so
I think the longer timeline is still going to pay off for us.
Individual Morale:
I feel excited going into this next week. I feel like we are really close to getting everything functional and
go into the testing phase. I feel like we also have gotten our code to the point where adding new features won't
take a massive overhaul and only a few additions to existing code. I think structuring our code this way took
longer, but will allow us greater flexibility in the coming week. We're almost there! I think this is a home
stretch :)
Hao
Last Week’s Goals:
Testing the multithreading server code and wrap up with networking.
Completed Goals:
Networking is finally done :] yay
Unmet Goals:
None
Next Week’s Goals:
Starting from this week, I will shift to work on game logic. Specifically for next week, I will work with Aditi
and Jimmy to finish pathing. After next week, the minions should be able to navigate through the map to enemy's
tower.
What I Learned:
I learned more about static members of a C++ class while wrapping up while the networking code. Besides, from
that we had a group coding session this week through which I was able to get a very clear picture about the
overall structure of our existing code. I have a clearer picture of how data sent between the server and client
finally shows and reflects on the scene.
Individual Morale:
I feel exciting about switching to work on a different aspect of the game and I'm finally done with midterms
(it's already week 7 lol..) Overall, different components of the game are getting together and I feel we could
have the MVP done very soon!
