Tag: python

– 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

Relates to #13 and #12

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!

– 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

Relates to #13 and #12

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!

– Use the CHANGE_POSITION message to determine if there are doors in the way of an object in order to hide it
– Use the same message to reset the other three positions
– Fix regression in python bindings introduced by new optional parameters in the addJobMessage function

Building on the previous commit this wires everything up to finally hide/show doors so that objects no longer go through visible doors in T-1000 fashion.
Check it out in the video! 🙂

– Add washing_hand animation to the human model
– Adapt sink model to not overlap with walls
– Add missing files from last commit

As mentioned in the previous commit, this commit is about the asset updates to complete the hygiene feature. The message itself is pretty self-explanatory. Check it out:

– Make more code generic in the job scripts
– Implement the hygiene logic on the Python end
– Add a new job: wash_hands
– Handle object categories better in some cases
– Handle containers with only one children more gracefully (improve padding calculation)

The theme here is the full implementation of the hygiene mechanics. The idea here is to slowly decrease the hygiene value (slower than hunger) and also let it negatively affect (once again, to a lesser degree) the overall health. In order to let the health recover both hunger and hygiene need to be above 0. That might be subject to change, let’s see what the future brings. 🙂
As often in these cases that means that some features are suddenly used in a way that has not happened before. This means that this commit also brought changes in the UI code (poor handling of padding calculation in containers with only one child element) as well as in the object selection code, which did not handle object types that have more than one category very well.
As already mentioned, the mechanic is complete for now, but is still missing a slightly improved model for the sink as well as a hand washing animation, so the next commit which will bring these asset updates will get a nice flashy screenshot or video. 🙂

Simplify the human object script code and fix the hunger/health mechanics (hygiene WiP)

This removes quite a bit of redundant (Python) code and makes it more re-usable, something that will be required as soon as more game play stats need to be manipulated. It simplifies the code in a few places that did essentially the same thing, ever so slightly differently:

– Add the concept of hygiene on the C++ side of things
– Refactor the python code for the human object a bit

This adds a “hygiene” property to the ControllableObject class and exposes it to the Python mappings. This has no meaning yet, but the current state which never changes is already shown in the bottom bar:

Fix crash by making sure to lock the UI before restting the context container

More mutex fun!

Make animations script controllable and add an eating animation

Exports the newly added functions that control the current animation to Python. Show the “eat” animation when a character is currently eating something.

– add new job messaging mechanism that allows the job to return messages to  the object manager
– add first message type that allows objects to transform themselves
– fix bug in the renderer that crashed when creating and removing the number of models resulting in the same number
– added more gameplay logic (starvation and death)

This is rather substantial as it adds the notion of “job messages”, that allows Python scripts to make changes asynchronously. The only message type currently supported is the “change object” message, which essentially transforms the object sending the message. This change needs to happen asynchronously for obvious reasons, as replacing the object requires a complete removal of the existing object, including the script instance, before it gets replaced by a completely new object in the same location.
On a more superficial levels, this adds a bit more game play, if you want to call it that. Yay!