Week 4 Status Report

Group Status Report:

  1. Summarize your overall status for the week
    1. Created and connected client and server (decoupled simulation and rendering, migrated simulation to the server)
    2. Finished “pickup” and “drop”
    3. Added toon shaders
    4. More assets added
    5. Working on UI
  2. Include both the week # and the date of the meeting
    1. Tuesday April 26th at 10AM, Week 4
  3. add a statement summarizing the group morale (feel free to be creative in expressing your morale)
    1. Feeling sad that Nick left us 🙁 But he’s with us remotely so not too sad
    2. Feeling happy that Nick’s gonna join us again in time for the next group meeting 😉 – Nick
  4. Screenshots

  1. Pickup, hold, and drop:



  2. Toon shaders, veggies, Gilman(the pig) and tree:



  3. Map:



  4. UI:


  5. More assets


  6. Potential title screen:

Individual status reports:

Cher:

  1. Concrete Goals:
    1. Working on getting the necessary visual components as soon as possible
  2. Accomplished Goals:
    1. Additional assets for the buying UI, icons for the scoreboard
    2. Created a title screen
  3. Goals Not Accomplished:
    1. Art never rests
  4. Goals For Next Week:
    1. Keep all the existing 2D assets as updated as possible, make more if/when needed
    2. Try to help out as much as possible in other areas
  5. What I’ve learned this week:
    1. Rebasing is very cool, very fresh
    2. Obsessively save your work in case your program is in a fit of crashes and the progress on the WIPs you worked on for the past hours vanishes
  6. Individual morale:
    1. Midterms and slight scheduling issues aren’t a very fun combination, but other than that it’s been ok 🙂

Cynthia:

  1. Concrete Goals:
    1. Get shadows working
    2. Implement shaders for characters
    3. Look into post-processing effects
  2. Accomplished Goals:
    1. Shadows working on the prior versions of our program. Though, we had to change when we call draw (our render function), so I have to readjust my code where I create the depth map based on that.
    2. Created a toon shader for our characters, along with a Blinn-Phong shader.
  3. Goals Not Accomplished:
    1. Shadows do not work with new code, I think this will be a quick fix though once I talk with the team.
    2. No implementation for post-processing
  4. Goals For Next Week:
    1. Once the seed models are done, I’m going to readjust our code such that it switches textures based on what vegetable the seed it (as opposed to loading multiples of the same mesh for each vegetable).
    1. Import the world model once it is done
    2. Fix the shadows with the new code
    3. Look into post-processing more.
  5. What I’ve learned this week:
    1. Depth maps are really cool! And very hard to debug (but still very cool)
    2. What frame buffers are, which I will be using for post-processing and used for shadowing
  6. Individual morale:
    1. very excited thumbs up ??

Danica:

  1. Concrete Goals:
    1. Finish “pickup” and “drop”
    2. Rig and animate plots
    3. Make map
    4. Make more vegetables/models
    5. Implement plot class
  2. Accomplished Goals:
    1. Finished “pickup” and “drop”
    2. Rigged and animated plots
    3. Made map
  3. Goals Not Accomplished:
    1. Implement plot class 🙁
  4. Goals For Next Week:
    1. Implement plot class
    2. Transition into a more development role once the majority of models are finished
    3. Finish remaining tool models, vegetable models, and whatever else is left
  5. What I’ve learned this week:
    1. Thank you Jakob for your rebasing lesson!
    2. Good map design is… hard
    3. Maya can import displacement (height) maps easily but exporting them is a whole other story..
  6. Individual morale:
    1. Still pumped for 125 but nervous for midterms

Jakob:

  1. Concrete Goals:
    1. get logic transfered to server
    2. get rendering solely on clientside
  2. Accomplished Goals:
    1. gamemanager class responsible for logic updates and game simulation is completely serverside
    2. packets containing input are sent from client to server to alter game state
    3. server updates game state and sends back an array of model enums and their positions to the client
  3. Goals Not Accomplished:
    1. animations are not completely reset up yet, but infrastructure is there to put it back in easily
  4. Goals For Next Week:
    1. get ui working and send ui data back and forth between server and client
    2. help get plots working and npc interactions working
  5. What I’ve learned this week:
    1. rebasing!
    2. Interpreting network packets
  6. Individual morale:
    1. hype

Jennie:

  1. Concrete Goals:
    1. Integrate the UI code into the main loop
    2. Refactor the display of UI and position, taking input from the keyboard and change UI display accordingly.
    3. Connect UI input with the game logic
    4. fix the image loading error ( stbi png sig)
  2. Accomplished Goals:
    1. UI is integrated into the main loop and taking input from the keyboard and change accordingly ( but in an really dumb way, it is literally switching between image)
    2. the image loading error seems to be fixed, I think it is caused by the dynamic memory allocation. The error doesn’t show anymore after I switched from static vector to static array of struct so all the memory is allocated at the complied time.
  3. Goals Not Accomplished:
    1. Still need to working the connection between UI and game logic
    2. change the font size of UI
  4. Goals For Next Week:
    1. change the font size of UI and connect the UI with game logic
    2. Make UI dynamically change size according to the window size ( or we can just do fixed size window)
    3. Helping merging game logic into server side
  5. What I’ve learned this week:
    1. styling using imGui is super difficult, but it is still an good library for GUI
  6. Individual morale:
    1. Keep Working!! (and studying for the midterms)

Leon:

  1. Concrete Goals:
    1. Implement fully working interaction system
    2. Connect interaction working with plots
  2. Accomplished Goals:
    1. Finished interaction system for vegetables. I implemented logic for the player to detect any game entities within the sphere collider, and being able to interact with that game entity if they can interacted (which is checked in the Interactable class).
    2. Players has logic to pick up and drop vegetables now. This is done through references to a entity held and the entity chosen to picked up. If the player has a reference to the entity held, no other game entities can be picked up.
  3. Goals Not Accomplished:
    1. I started implementing the Plots and allowed players to interact with Plot objects if they are already holding a Vegetable (eventually will change to Seeds). Didn’t end up having time to finish up this feature since the the ‘hold-able’ object doesn’t do anything yet when interacting with the Plot.
  4. Goals For Next Week:
    1. Finish plot interaction with seeds
    2. Implement the Seed class and connect with Plot and Vegetable logic to “grow” into a Vegetable under the correct situations
  5. What I’ve learned this week:
    1. Rebasing can take a long time!
    2. Working with the network logic
  6. Individual morale:
    1. Excited!

Nicholas:

  1. Concrete Goals:
    1. Refactor code to introduce a clear client-server boundary
    2. Move part of the simulation server-side
    3. Help out with other parts of the gameplay logic
    4. Figure out the VS build target for the server
  2. Accomplished Goals:
    1. Full client-server integration has been done! All simulation now runs exclusively on the server side; the client now is just responsible for sending inputs to the server and drawing the models after the updates
    2. In the process of integrating the client with the server, I also refactored some of the gameplay logic. Previously, the Models were tightly coupled with the simulation classes (e.g. Player, Vegetable, etc). I pulled out the Model class outside and put them in the client without the containing simulation class, so the server now doesn’t contain any models
    3. I also had to change the network design to allow for sending multiple the models from the server to the client, especially since the number of models being sent can’t be determined during compile-time.
    4. I also designed the client-side model such that new models can be instantiated dynamically in the course of a game, instead of it having to be pre-determined prior to starting the game (as long as the server-side simulation supports adding new entities in the middle)
  3. Goals Not Accomplished:
    1. Jakob and I created a rudimentary build target system to run the server and the client in the same project. Ideally we would figure out how to create them on a separate main loop, but the current solution looks sufficient for the time being, and I don’t think is worth putting more time into. We will explore other solutions if combining both main methods into the same executable prove to have some performance penalties
    2. Other than that, pretty happy with this week’s progress
  4. Goals For Next Week:
    1. Add server capability to support multiple connections, in anticipation for multiple clients
    2. Allow clients to re-join in the middle if disconnected
    3. Possibly reduce the packet sizes
  5. What I’ve learned this week:
    1. Having the array’s length being embedded into the array itself is very nice. In the process of deserializing the server packet, the client has to dig through the number in the header, which involved a nested reinterpret_cast with static_cast, which is just cumbersome. I ended up writing a helper function that deserializes the packet into passed-in pointers (technically pointer to a pointer).
  6. Individual morale: really excited especially about the things I’m not working on, the map’s looking really good and the UI looks like it’s coming together really well! Props to the team

Danica

Leave a Reply

Your email address will not be published.