Ramblings about hobbyist game development
– Properly set the post-exit angle when leaving an object
– Fix the logical dimensions of the bed object + adapt lying animation to match
– Fix some clang warnings
Hi! Once again, pretty self-explanatory items on the list, next up will probably be adding (and animating) the transition animations. I hope to be able to give some good news soon. 🙂
Do not “forget” the currently running job when exiting objects
What was rather frustrating to debug turned out to be essentially a one-liner, now one can properly queue up multiple jobs that involve entering/leaving other objects! 🙂
That is, if a certain ticket does not get in your way.
– Use the same implementation for the “lying down” mechanic as for the sitting one
– Adjust dimensions of the “bed” object to make it better fit the world dimensions
Not too much had to be done to make it happen, but now the “lying down” mechanic also works (with the same caveats as mentioned before), but it is pretty nice to see this object finally see some use as well besides just existing and looking nice. 🙂
Implement getting up from the “sitting” state (WiP)
Hi! As the message states, this is implementing the basics of the concept of “getting back up” – some quirks remain, like the missing rotation into the right direction depending on the exit point and jobs seems to lose some information when being started from a non-standing state.
Also, the same restrictions (no transition in terms of time or animation happen) as for sitting done apply.
However, besides that the core mechanics work and after leaving the container object the slots become available again. 🙂
– Expose PositionStatus to python with getters/setters
– Tweak the chair model to actually fit the dimensions of the human modelCloses #14
Quickly exposes more functionality to Python as well as adapting the chair model which now actually properly fits the rest of the assets 🙂
– Set the default idle animation depending on the current position status (standing, sitting, etc..)
– Add first iteration of sitting animation
– Add a few more helper functions to determine under what circumstances an object enters another
– First WiP approach for the sitting down mechanic (just switches immediately for now, no standing up either)
– Extend the Python bindings
More progress and getting closer to an actual object-in/on-object mechanic! It is now possible to let the controllable objects sit down on objects that support that – albeit immediately and without any animations. You also better not plan on them being able to get up again, unless of course you don’t mind simply deleting the object they are sitting on.
Needless to say, this is all very much work in progress and will continue to do so for quite some time, but it is definitely progress 🙂
This also brought up the rather unfortunate question of positioning of the model so that everything lines up in a generic way, it just happens to work very nicely for the couch model, not so much for the chair though.
Let’s see what the next few days will bring in that regard. 🙂
– Add more boilerplate code to start object-into-object transitions, just stubs for now
– Exposed more enums and functions to Python
– Add more comments to the Python classes (and wrapper interfaces)
– Fix configuration for the bed object to make it work with the changed entry point handling
– Fix regression that was introduced for enterable 1×1 objects (looking at you, chair)
– Fixed indentation in two C++ header files
The work ever goes on! Once again nothing much to write home about, but the commit message speaks for itself I hope, until next time!
– Add function that returns the calculated world coordinates of an object slot based on the world coordinates of an entry point
– Use the new function so that objects can properly turn to their final target upon arriving at the entry point
As mentioned in the previous post, the selected objects now actually rotate towards their final target. If the prospect of this hasn’t sitting you on the edge of your seat already, why don’t you check out this video showing what that looks like in action:
The next step after this is to actually let start the object-in-object mechanics, but before that it will be time for some more content (read: animation) creation – or maybe not and it is straight back to coding again, the next few days will tell which. 🙂
– Add a generic method to convert coordinates relative to an unrotated object to global world coordinates
– Make the action points use the same generic logic
– Change configuration for sink/fridge to use the new, more intuitive way to define the action points
Hello! The work goes on, now the controllable objects can successfully navigate to the correct “entry points” of a selected object, as the next step they will also face the correct slot position that they are currently targeting. After that the actual entering and object-in/on-object mechanics can be worked on. 🙂
– Dynamically generate “virtual” job types (sitting down/lying down) for objects that have the appropriate category
– Add these job types as supported actions to human.json to pass basic action support validation
– Add dummy jobs for these new actions (sitting down being the exception, which is at least partially implemented)
– Extend the Python interface a bit, so that an object’s “entry points” can be requested as well (not just the action points)
– Refactor the calculation of action points on the C++ side so that the entry point calculation will not duplicate code
Hi! Before getting started with the actual workings of entering/leaving an object I’ve decided to first get the mechanics going to actually get the object we wish to put into another into the right position.
While the rather verbose commit message more or less speaks for itself, there is actually a slight visual change to be seen this time:
..which shows how the dynamically generated jobs look when selecting an object in Sitting/Lying categories. With that working the next stop is to finish that navigation step before getting into the actual sitting/lying mechanics!