Hello there! First time following the jam around as a developer!

Among the various proto-projects, experiments and other programming tidbits I keep hopping between, I'd like to take advantage of Devtober's month-long jam to continue working on a prototype of a Tactics-ish game on Godot (3.5.x). So far, I got a basic prototype turn loop where a character can move then attack.

Lots of stuff must still go through the game design step but so far I'm happy to see that at least it already looks like a game, even if a *bit* empty.

(I'm trying to stick with either my own assets or free ones on Itch. The font is Somepx's Equipment Pro.)

The possible goals I have in mind (unsorted) for the following month:

•  Design a stat system
  • Work with stats and equipment
• Start working on AI logic
• Work on UI/UX (have actual menus with better graphics, etc etc)

I'm not sure where I'll be focusing on, I tend to switch between tasks to avoid getting bored, but I believe those are relatively feasible by themselves in the course of the month, or at least starting to work on.

Good luck to everyone participating and have a nice day!

Day 1

Busy day and getting into Devtober was a late night decision. Today's work was to get at least a first attack animation working. The test animation is mostly a scene I instantiate on the fly and it has a proxy target to let me add effects on the targeted entity wherever it might be. The timeline takes care of activating the particle systems when needed. The objective is to have the ability to tweak the whole animation, callbacks and timing directly into Godot without having to deal with extra tool development for now.

Future versions could also wait for the particle engines to be done or put them in another place to avoid having them cut off at the end of the animation. I also am thinking of using the proxy to project some modifiers to the target entities (like color effects or forcing specific animations, like an hurt one).

Day 2

Working on implementing the turn system, to queue and sort the entities into game turns. It required a little bit of reworking as current game states were hardcoded to work with the old free selection state but it was easy to do. I also started making a GUI to show the turn order. It's not yet fully working but at least it properly populates with the entities at the start of the game.

Day 3

Mostly worked on fixing the turn order indicator and making it cycle with the turn order, theming the buttons and adding a map focus indicator to show which entity is the current. I still have to plan the stat system and it still blocks me a bit.

Day 4

As I'm implementing a first draft of the stats, I also added a stat panel for the targeted entity so you can check their status before deciding on your actions.

I'm also in the process of exploring number crunching to see if I can have a first balance for the stats. I'm maybe switch to a simple ATK/DEF/SPD for now (with slightly changed names for an idea of theme that is budding)  with an ATK*(PWR/(DEF+PWR)) formula to have base power for actions so the ranged attacks will probably less effective than melee ones but you're trading that with less risks of getting hit.

So,  there might be less game screenshots for the next days until I got enough stuff written down to actually properly start the stat system, sorry!

Day 5

After working a little bit of the entity HUD, I tried to give Billy and Bobby vaguely valid stats to have a ~3 turn expected lifetime if they keep duking it out.

Also I'm starting to encapsulate the attacks' data into resource types so they can store their own info, like base power, range and a link to an animation scene so they can share or have their own animation. The entity code has been reflected to use those and not hardcoded values. Screenshots will come tomorrow, I think.

Day 6

Fresher than yesterday but still tired, I got to make a first version of detection of character K.O. to properly remove them from the game flow. It's a bit tricky because I chain an extra state after the attack one *if* it does happen that the target of the action gets K.O.-ed after and it makes the coupling between the entities' states and the orchestrator's own states a bit tedious, but so far, it's alright and I think I can eventually clean that up if I'm getting a fresher brain this weekend.

Memo for Day 7

•  Cleanup the action result's location
• Experiment with AI
  • Make teams
  • Map tile cost based on enemy abilities (alpha-beta?)
• Small animations for turn UI (low prio)
• There's still code cleanup and documenting (low prio but it should be higher)

Day 7

I added a new direction selection state right at the end of the turn to let the player select where the entity is going to face after the turn, like FFTA. Currently it offers no gameplay advantage, I'll see if I keep orientation around.

In other news, I'm starting to implement scene "score" evaluation to see if I can go somewhere looking like a game AI. In the following screenshot, the green numbers are the "attack score", which a sum of all the possible attacks' base power minus the movement cost. In red, the "danger score", a sum of all the potential attacks from the other entities where they focus attacking the entity at a specific tile.

I have no definitive clue where to continue, but I feel like this kind of analysis can help figure how an AI could weight a score over another (ex: retreat more than attack?)

Day 8 & 9

I was completely out of juice yesterday, I couldn't work on the jam at all, I even slept most of the day. Take some rest when you can, folks, no need to crash yourself down.

Anyway, I went and did extra work today to make up for yesterday. I rewired some of the GUI theming for more flexibility. Now I can implement teams and those will reflect in the GUI to let me know I didn't screw up. The background is updated on both the turn order GUI and the character panels. One step closer to a game.

The other big change is me finally starting to add an AI. I don't really know how I'll formalize the behaviors, but so far, I made Benjy walk on the safest tile where he can attack (but can't attack for now). In the following picture, I added a bias to the danger score where the distance from the enemies is substracted to the attack's power. Basically it means that if Benjy must take an attack, he'll try at least to move the furthest he can from the attacker.

I believe it's one of the first times I try to work on AI. I'll try to look around for documentation on the topic but I'm mostly shooting in the dark for this. Wish me luck!

Day 10

I finally got a first AI lookalike working! Benjy is either moving to a best-fit tile then attacks or directly attacks and ends the turn! There's no proper chaining of actions nor an evaluation of the best course yet but at least I can make the AI looks like it kinda work in some scenarios, which is already magnitudes better than having no AI.

I still have little less than 3 weeks to make it decent now.  Onwards!

Day 11

Trying to implement the concept of world analysis factor and composite filter. The experiment is to see if I can factorize basic AI behavior as a series of node filters based on simple selection filters. For instance Benjy could either (in order):

1. Move close up  safely to enemies to attack (score.attack != 0, score.danger <= 0 and select min(score.enemy_proximity)
2. Move close to enemies safely to keep the pressure on the adversary team (score.danger <= 0 and select min(score.enemy_proximity))
3. Move away from the enemies as fallback (select max(score.enemy_proximity)

The third item would work if there were no tiles around that wasn't in direct threat of being attack, it allows Benjy to move away if he cannot attack before.

I could do this kind of behavior filter to attack next and I'll have to find out how I'll implement action planning, which is the next step in decision making: should the AI move or attack first? What decides what is the best action to do?). I'm still trying to think and find a solution.

Anyway, here's also a better version of the ranged attack, the part of the animation that sticks to the target now has a burst of puff clouds to make it a bit more visual.

Day 12

More foundation work for AI. I renamed the composite filters as move or attack filters, as I'll probably gather them throuhg composite combiners (which combine a pair of action/move).

I did a first attack filter, which is aiming to deal damage to make the quickest K.O.s first so I could start to manually chain attack then moving until composite combiners are programmed. I still am trying to look for better ways to implement world evaluation and it brought me to create a light version of entity to represent them in decision tree map representation. Vaguely inspired from game tree solving algorithms, I'm trying to explore a tree of different action possibilites and extract the "best" course out of all possible combinations. For that I could check every pair of attack/move filters so I wouldn't have to deal with an overly complex tree (where I would evaluate among n variations of the same attack/move)

I could end up with a list of possible combinations looking like this

• AttackToKill(Billy, normal attack) then MoveAway(to_some_far_point)
• CloseUpForAttack(Bobby) then AttackToKill(Bobby, some_attack)
• CloseUpTo(Billy) then EndTurn [if still too far from entitites]
• ...

Deciding the final move from that list. would end up being another way to allow customization to have different bias weightings. A ranger attacker shouldn't act the same than a healing unit or a melee attacker. Having entity representation allows me to easily and freely alter their stats to represent the world after an attack or a move, with more or less entities, etc without having to deal with altering the actual entities in-game., therefore the need for splitting the entities from their representations.

I believe it's already quite complicated as-is but it sounds promising. Maybe I could also investigate Behavior trees or other decision structures in the future but I haven't figured out if is it possible for me to adapt my project into making them work, I lack the thinking framework to make them work yet.

In other news, I made the attack animations finally scaling up/down with the game's resolution so they will have a consistent size relative to the world. I also added a toggle for manual AI stepping to check stuff between an AI's actions, nothing fancy but still great to quickly debug stuff.

Day 13

Relax day.

I implemented Tyler Glaiel's AA neibour scaling shader and converted all the particle shaders to use it.

I also took some time to improve the melee animation, added a new particle texture for it so it's more varied. I also added a engine-only scale preview for attack animation editing so I can figure their proper scale.

And I implemented a new K.O. animation, just for the sake of it. I'll eventually record it and post it later.

Day 14

Sadly, nothing visual has been done today. I'm deep into implementing "World Simulation" (projecting the state of the game after actions). It kinda works and already shows me some result. Here's an example:

- Before -
[WorldSimulation : [[EntityRepresentation Billy @ (5, 3, -4) : 12/120], [EntityRepresentation Benjy @ (7, 3, -2) : 192/192], [EntityRepresentation Bobby @ (2, 2, -3) : 150/150]]]
- Move - 
 -> SKIP
- Attack -
 -> OK
[WorldSimulation : [[EntityRepresentation Billy @ (5, 3, -4) : 12/120], [EntityRepresentation Benjy @ (7, 3, -2) : 165/192], [EntityRepresentation Bobby @ (2, 2, -3) : 150/150]]]

Roughly here, a first version will take the first move and attack filter and will try to make to move an entity then make it attack. Here it failed to move to an enemy safely before casting the attack (probably because I didn't try that filter that tries to move out of attack range nor made an "attack from the safiest point even if you could take damage" filter)

Day 15

Almost an off day. I just made the World Simulation exhaust all possible combos rather than a hardcoded one. Here's how the log looks like.

Yeah, I spent 10 extra minutes half-asleep adding the tree structure for easier visual grepping the logs. I still beat around the bush when it comes to selecting the desired turn scenario. Maybe a sum of all the scores from the entity's team?

Day 16

Like a dwarf in the Moria mines, I dug too deep without thinking twice before. The current AI system is too convoluted to really work without strong planning and as I'm struggling over just to have something decent-ish, I keep falling into pits I put myself into.

• The Close up behaviors kept pushing the entities into not attacking because they had a hard limit on "danger" and I don't know how to mitigate that two tiles with the same danger value aren't always equals (wrong weighting on my side, I guess?)
• The code architecture is kinda convoluted and for stuff like biasing the AI towards constantly reducing the opponents' health, I don't know how to value an instant situation without keeping track of the original values and/or maybe the previous turns.
• The system is definitely too complex and "flexible".

I need to go back to the drawing boards. Let's see if I can just pull simplistic behaviors per "role" and roll with it instead.

Day 17 & 18

Day 17 was an off day for work reasons. Day 18 is mostly spent looking at lecture on the topic. The Game AI Pro's chapter on Utility Theory might have some clues. From what I read it sounds like it describes what I'm stuck on: figuring how from a field of values I can determine a strict evaluable single field. I still wonder how I can cut down the crust I built with the current AI experimentation and start from a saner base. What to keep, what to yield.
Edit: Let's be honest, I'm becoming frustrated with the way I'm stuck and this is chipping away my willingness to work into that task. I hope that browsing that book will rekindle my curiosity and make me want to give a shot to other stuff.

Day 19

I'm trying to conceptualize the trimmed down version of AI behaviors. For now I have a non working code stub that just determines manually the vague order of actions, I need to wire back the decision themselves to make an AI act again during its turn.

To avoid stalling while I'm trying to make up with smaller scoped behaviors, I also implemented a damage indicator. I'll probably set up a better version to allow having multiple indicators and the ability to pop them up during the attack animation, but for now that'll do it.

Day 20

Worked on little tasks to not lose too much steam. The end turn action is cancelable and the damage indicator is fixed (won't show 0 all the time anymore) and will happen during the animations instead of being queued after it.

Day 25

After a break, I'm trying to rewrite the action selection to browse instead the whole possibility tree, instead of using filters. I still need to wonder how to do an evaluation for an aggressive unit, but I think the accumulation of K.O.s and/or the best amount of damage during the whole turn might be a first lead. I'll see after that if I need to add other values back (like danger).

Here's for instance an excerpt of what could do Bobby from his starting point. The whole log is roughly three times as long as I check all doable actions (move, attack, skip turn*)

* This one might not even be needed, actually.

Day 26

I unplugged the old action decision and the current one seems to almost work. When re-implementing the tree navigation, I removed the log printing, I should plug it back, I'm getting still some crashes as I'm mishandling the turn action data, oops.

EDIT : One hour of sleep budget burning later, I got it working! Looks like the AI is already looking to go after my units while still trying to keep its distance to not be too vulnerable. I'll do some picture posting later.

Day 26 & 27

Day 26 I was sick and stuck to my bed. Day 27's timeslot was mostly spent trying to squash some bugs when the AI couldn't properly fill the blanks for skipping actions, causing some crashes in some scenarios, I think I'm going to refactor this into polymorphic code so there won't be less issues of data mismatch.

Another part of interest was the custom pathfinding code which was more expensive than planned. I wonder if I can use Godot's pathfinding server in a way that doesn't involve meshes but custom nodes.

Day 28

I rewrote most of the algorithm to improve the way it stores the turn's action sequence into Action Commands (because somehow I forgot that "turn actions" were a thing). Instead of storing values in different arrays that was more prone to bugs and mismatches than anything, I'll just stack an array of command objects that are called with the entity during the turn unroll. It makes the code less messy and I also took the time to trim some code made useless and redundant in the same way.

They say the best commits are the one which are removing more code than adding. I think I should wrap up the jam "demo"'s page tomorrow. Been a slow month as usual with my hobbies, but it's been mostly consistent. The game's just not that playable given that the month was more focused on prepping the code for doing AI experiments but it got its share of gamey bits over the month though.

Day 29

The prototype is live. I spent today's allocated time into making a quick intro screen, wiring its events and making a Windows export. If needed, I'll provide builds for other platforms if Godot allows that on Windows. I'll make a postmortem tomorrow.