Gothic AI devlog

The sword hits now, not a rule: the numbers

Mon, 02 Nov 2026 18:00:02 +0300

In a sword fight a hit used to be decided by a rule: the enemy is close and in front of you. Now the blade decides it: where it went, what it touched and at what angle. The short shows it in 50 seconds (a Russian voice with English captions); here are the formulas.

The rule it replaces

In OpenGothic as we started from it, a melee hit is one moment: at the hit frame of the animation the engine checks that the chosen target is within the weapon’s reach and within ±30° in front of the attacker. The weapon itself has no collision. On the test bench a swing at a bandit 215 cm away dealt 11 damage while the sword passed him by.

The blade

The blade is now a capsule of 2 cm radius from the hand to the end of the weapon’s real mesh (90 cm for the common sword). On every physics step, 60 a second, it sweeps from its last pose to the new one in turns of at most 5°, so a thin target between two poses is not skipped, and checks the bodies’ capsules (head, trunk, limbs) and the world. Humans hit this way now, the hero and NPCs; monsters still attack by the old rule.

Gothic’s own damage (the weapon, strength, the critical roll, the armour) is computed as before, and the blade multiplies it:

multiplier = clamp(speed × lever × edge, 0.5, 1.5) × 0.6ⁿ

speed: the touching point’s speed over a typical one for this swing (0.7 of the tip’s peak speed in this animation);
lever: 0.5 + 0.5 × the place on the blade, 0 at the hilt and 1 at the tip;
edge: 0.5 + 0.5 × sin of the angle, 0.5 with the flat and 1 with the edge;
n: how many bodies this swing has already hit.

From the short: the same 215 cm swing, with the blade deciding, touches the bandit’s trunk with the tip (lever 1) at 78° (edge 0.99) and 1920 cm/s against a typical 1177 (speed 1.63). That is 1.61, clamped to 1.5: Gothic’s 11 becomes 17.

What follows from it

A post stops the swing. A wall or a post stops a blade moving forward along the attacker’s look; the backswing and the follow-through pass, and the ground does not stop it. The swing ends with a hit effect and a return to the stance. Before, a two-handed axe went through a fence post.
Two targets in one swing. The blade checks every body on its way (an NPC’s blade passes through its allies). A two-handed swing hits a bandit (×0.94, −11), then a wolf’s foreleg almost flat, at 4° and slower: 0.30, raised to 0.5, then ×0.6, so −3.
The push. The impulse is the weapon’s mass (fist 1.5 kg, one-handed 2.5, two-handed 4) × the contact speed × the edge, at most 60 N·s, along the blade’s motion. The struck part of the body takes 15% of it, and its motors pull it back into the animation.
A miss by a centimetre. A swing at a bandit 264 cm away hits; at 266 cm it misses by under 2 cm. The old rule would have counted both.
The step-in. So at the start of a swing the attacker steps toward a target within ±60°: up to 120 cm forward or 40 back, at most 6 m/s, turning at most 30°, only until the predicted contact. The 215 cm swing took 24 cm, a forward swing at 275 cm took 80; both hit.

What we keep honest

The “before” shots are OpenGothic with blade physics off (melee_physics_hits=0), not the original Gothic II executable, which we did not check.
The targets are placed by the test bench. The slow motion is the game’s own frames with its time slowed, not interpolated. Every number on screen comes from the take’s log.
The voice is a person’s recording. The music is Gothic II’s (Kai Rosenkranz).

Balancing the whole fight (the blade, stamina, parries) is planned as one pass of its own, not step by step.

Not playable yet: it runs from source on macOS and needs your own copy of Gothic II: Night of the Raven. How it works now is in docs/physics.md (stage 7), the multiplier in damagecalculator.cpp, the push in meleeimpact.cpp. The short was filmed on the test bench and drawn with shorts/explain.

How the bow works now: the numbers

Tue, 13 Oct 2026 21:58:47 +0300

The last post showed the bow aimed by hand. This one is about the numbers behind it. If you aim the arrow yourself, what is left for the hero’s skill, dexterity and strength? Gothic is an RPG after all. The short answers that in 80 seconds (a Russian voice with English subtitles); here are the formulas.

The dice it replaces

In Gothic II the bow aims itself and one roll decides the hit. The chance comes from the bow skill and the distance, as Gothic2.exe computes it. Up close it is 100%, falling to the skill at 15 m. Past 15 m it is H − H·d/45 m (H is the skill), so it drops at once to two thirds of the skill and reaches zero at 45 m. A bandit with 40% skill hits from 16 m a quarter of the time. That formula, taken from the executable, is the yardstick for everything below.

Damage

The arrow is a real projectile: it leaves along the line of the bow, drops over distance and hits what it touches, with zones fitted to each body’s mesh. The damage keeps Gothic’s own rule (the bow’s damage plus dexterity) and adds three factors:

damage = max(5, ((bow damage + dexterity) × draw − protection) × zone)

draw: 0.3 to 1; a shorter draw does not shoot;
protection: the target’s protection against arrows; it never takes the damage below 0;
zone: head 2, trunk 1, arms and legs 0.6. It applies after the armour, so a head shot always deals twice a body shot;
each step is rounded, and at least 5 is dealt, as in Gothic.

A master (a bow of 150, dexterity 150) at full draw against a paladin in plate (protection 100): 400 in the head, 200 in the trunk, 120 in a limb. The test bench measured the same.

What the stats do

From novice to master (skill 0 to 100%, dexterity 0 to 150):

Stat	What it changes
Bow skill	Accuracy: the sway at full draw 0.9° → 0.25°, the scatter on release 0.6° → 0.1°, the aim settles after a turn in 0.6 → 0.2 s, the breath holds 2 → 5 s. Training: Gothic’s trained archers’ animations are kept, so the reload animation takes 1.16 / 1.08 / 0.92 s on the three tiers
Dexterity	The damage (above) and the tempo: the draw 1.2 → 0.5 s, the reload’s pace ×0.85 → ×1.6
Strength	Holding a heavy bow: a bow needs 0.6 of its damage in strength, or its own requirement. Short of it, the bow sways more (×(1 + the shortfall)), draws slower and trembles sooner: it holds steady for 1.5 s at half the strength it needs and 6 s at twice. A crossbow cocks at ×0.75 → ×1.4 the pace

Against the dice

On the test bench: four tiers from novice to master, 30 shots per cell, no armour. Damage per second aiming by hand, divided by the dice’s at the same tier:

Tier (skill, bow, strength/dexterity)	10 m	20 m	30 m
novice (10%, Bow_L_01, 10/10)	0.86	4.0	4.1
apprentice (30%, Bow_L_03, 30/30)	0.79	1.65	1.57
middling (60%, Bow_M_01, 60/60)	0.79	1.16	1.25
master (100%, Bow_H_03, 150/150)	1.10	1.39	1.76

Close up, aiming by hand is a little slower than the dice: drawing takes time. Past 15 m it deals more, because the dice cuts the chance there in one step (a novice is left with a few percent) and physics does not. A master puts 17 of 30 arrows into a head at 20 m.

What we keep honest

Every number on screen is computed, not typed in: the chance and roll over the bandit are the ones the game threw in that take, the formula card works its example out the way the engine does, and the charts come from the bench’s log.
The bench’s bot aims with no human error, only the bow’s own sway. A person with a mouse will do worse; that is the margin we left.
The balance table was measured without armour; the paladin example is with it.
The scenes are staged: the bandit is held in place and cannot die. The arrow’s flight is slowed down.
The voice is a person’s recording, not a synthetic one. The music is Gothic II’s (Kai Rosenkranz); the game’s own sound is cut out of the inserts.

Plans: whether NPCs should aim at heads, and a balance check with a real player’s aim instead of the bot’s.

Not playable yet: it runs from source on macOS and needs your own copy of Gothic II: Night of the Raven. The engine is OpenGothic. The design and the measurements are in docs/manual-aim.md, the numbers in archery.cpp and damagecalculator.cpp. The short was filmed on the test bench and drawn with shorts/explain.

Aiming a bow by hand

Tue, 13 Oct 2026 09:26:58 +0300

In Gothic II the bow locks onto a target and a dice roll decides whether the arrow hits. Now you aim it yourself: hold the button to draw, let go to shoot, and the arrow goes where the bow points. In the short the same scenes are played twice: on top the bow as the game has it, below aimed by hand.

How it plays

The draw. Holding the left button draws the string, letting go shoots, the right button lowers the bow without a shot, and Shift holds your breath for a few seconds. A drawn bow sways; held too long, the arms start to tremble and finally give up. A small crosshair sits where you aim, and its brackets open as far as the arrow may stray.

The arrow is real. It drops over distance, so at 30 m you aim higher. It hits what it touches: zones fitted to each body’s mesh, the head for double damage, the limbs for 0.6. The zone multiplies what got through the armour.

Skill shows. The draw time, the sway, the arrow’s speed and the spread on release come from the bow skill, strength and dexterity, and the trained tiers keep the game’s own animations. A crossbow reloads by strength.

Stance. With the bow up, the sneak key crouches (steadier hands), the side steps lean you out of cover, the mouse wheel cants the bow for a quicker, looser shot, and forward and back step slowly with the bow still drawn.

NPC archers aim too. The fight AI decides when to shoot; the archer draws, holds until the aim settles and lets go, at the chest, over it for the drop and ahead of a runner. How far it misses comes from the original dice: the chance at that distance becomes a spread around the chest, so archers hit about as often per minute as before. Against a runner the difference shows: in this take the paladins’ bolts by the dice missed 16 of 16, aimed by hand they hit 5 of 8.

Where the dice remains (with manual aim switched off in Gothic.ini), it now rolls exactly as Gothic2.exe does. OpenGothic’s formula was kinder past 15 m: a bandit archer 16 m away hit 41% of the time instead of the original 25%.

Balance

We compared it with the dice on the test bench: four tiers from novice to master, 30 arrows each at 10, 20 and 30 m. Close up, aiming by hand deals about as much damage per second as the dice or a little less, since drawing takes time; past 15 m it deals more, where the original dice falls off sharply. A master puts 17 of 30 arrows into a head at 20 m. The bench’s aim has no human error, only the bow’s sway, so a person with a mouse will do worse: that is the margin we left.

What we keep honest

Both halves are the same scenario on the same build, played twice: on top with manual aim off, which is OpenGothic with the auto aim and the original dice, not the original executable. The test bench’s bot aims, not a person. The scenes are staged: the bandit is held in place and cannot die, the hero cannot be hurt, the hero keeps the untrained animations, and the head shots use a master’s stats, the other scenes a middling archer’s. The game’s sound comes from the lower take; the picture is a little brighter for phone screens.

Plans: a reaction to an arrow that only just misses, archers that do not shoot through their allies, whether NPCs should aim at heads, and a balance check with a real player’s aim.

Not playable yet: it runs from source on macOS and needs your own copy of Gothic II: Night of the Raven. The engine is OpenGothic; the design and the numbers are in docs/manual-aim.md, and the short was filmed with shorts/compare on the test bench.

What happens if you insult Xardas

Tue, 13 Oct 2026 07:47:25 +0300

You can say anything to Xardas now, rudeness included. In the short the hero gets ruder line by line. First he asks whether Xardas is too old for all this magic, then he calls him a half-baked necromancer, then he brings up his mother. Xardas answers each line live, and after the third he decides he has had enough. The game plays the rest: a spell, the hero falls, Xardas raises him as a skeleton, and the game ends on a picture.

It is a joke ending, not part of the main game: the AI server turns it on only with a flag of its own.

How it works

Xardas decides whether he is offended. The language model behind Xardas answers each line in character. When it takes the words as an insult, it marks how bad they were: 1 for rudeness, 2 for an insult, 3 for a grave one. The code keeps the count. Xardas puts up with 5 points. He sees how much patience he has left, and near the end he is warned. One thing he forgives nobody: an insult to his mother tips the scales at once.

The last word. When the scales tip, the model is told that this is the end and says one more line knowing it. In this take it was “You will serve me in silence.”

The game plays the ending. Xardas finishes speaking, readies a death spell and casts it at the hero until he falls. Two seconds later he readies a summoning, its light rises from the body, and the hero gets up as a skeleton. It works like the game’s shape change spell, so from then on the player is the skeleton. Then the screen goes black and the end card comes up; a key takes you to the main menu. The game’s interface is hidden for the whole scene, and the conversation’s subtitles go once the hero falls.

Does it really tip

We checked it with the live model on the game, not only with a scripted one:

three plain insults in a row, his mother left out: he ended it on the third;
his mother: at once;
the question about his age he did not take as an insult and answered calmly.

In one of eleven live runs the model answered angrily but did not mark the insult, so nothing happened. After that we made the rule clearer in what Xardas sees about his patience, and the three takes that followed all ended the way they should.

What we keep honest

Xardas’s answers are not scripted and not edited: he hears the hero’s voice through speech recognition and answers with a language model. Whether he is offended is his model’s call too. Only the pauses while the model thinks are cut. The hero’s lines are ours, written for the scene and said by a voice designed from a description; nobody’s voice is cloned. The scene is set up for the camera: the hero stands on the pentagram, and the cuts of the ending follow its stages. The skeleton, the spell and the summoning are the game’s own. The end card is a generated picture. Its line is in Russian in our game, so the English short translates it above the picture.

These are plans: playing on as the skeleton (the player already is one), and tempers for other characters, since for now only Xardas has one.

Not playable yet: it runs from source on macOS and needs your own copy of Gothic II: Night of the Raven. How it is built: docs/xardas-wrath.md, the scales in wrath.py, the ending in necromancy.cpp. The engine is OpenGothic; Gothic II is Piranha Bytes’ and THQ Nordic’s.

Bodies that react

Mon, 12 Oct 2026 23:10:00 +0300

Characters that talk back need bodies that react too. Over the last days the people and creatures of Gothic II learned to stand on uneven ground, to notice you, to lean when they run and to give way when they are hit. The short shows the same scenes twice: on top OpenGothic as it is, below with our animation work switched on.

What changed

Feet stand on the ground. On a slope or a stair both feet touch it: a knee bends, the hips go down. Wolves and molerats stand on all four paws, and their bodies tilt and roll with the ground.

They notice you. In a conversation a character turns to whom it talks to: the head first, the chest and the waist for larger turns. Outside a conversation it notices the hero coming within a few metres, a drawn weapon, a fight nearby. It looks for a few seconds, loses interest, and looks again when you have moved on.

Runners lean. Into a turn by how fast they run and how sharply they turn (up to 14 degrees), forward up a slope and a little back down one.

Blows throw the body. Every hit bends the upper body away from where it came from: a sword swung from the side pushes along the blade, an arrow along its flight, a hit off the middle twists the trunk, and the head lags behind and swings back. It is as strong as the blow hurt, on top of the game’s own stumble, and it also comes where the game plays no reaction at all. On top of the stumble it is subtle, which is why the short does not show it.

Smoother switches between animations. When a run stops or a walk turns into a run, the new animation now plays at once and the difference to the old pose fades out instead of a frozen first frame or a jump: the largest jump of a joint when a run stops went from 70 cm to 20.

All of it runs on top of the animations of the game, as passes over the skeleton the engine has already posed; nothing in the game’s files is changed.

How it was tested

Each of these was tuned on the test bench: it plays a scenario inside the game, records video and per-frame metrics, and reports suspicious frames, a foot sinking into a step, a head jerking, a flinch that does not come back. The bench also found a freeze in the engine itself: under load the renderer could wait forever for a thread that had missed its signal; it is fixed now.

What we keep honest

Both halves of every scene are the same scripted run on the same build of the engine, played twice: once with our animation switched off, once with it on. The top is OpenGothic, not the original game’s executable. The scenes are set up for the camera: the hero cannot be hurt, the farmer is held in place so that his routine does not take him away. The game’s own sound is from the run below; the picture is a little brighter than the game for phone screens.

Feet that stay on the ground during sword swings on a slope, and the upper body turning to an enemy above or below in melee.

The project is not playable yet: it runs from source on macOS and needs your own copy of Gothic II: Night of the Raven. The engine is OpenGothic; the tools that filmed this are in the repository: shorts/compare and the test bench.

The shorts film themselves

Mon, 12 Oct 2026 20:00:00 +0300

To show what the characters can do we need videos, and recording them by hand is slow: every answer is different, so a good moment takes several tries. So the coding agent that works on the project now films the shorts itself, with nobody at the keyboard.

How a short is made

A script. A short is a small file: the hook, the hero’s lines, where the camera stands. For the first one the hero tries to fool Xardas: “Lee sent me. He said you’d give me your staff.”
The hero’s voice. The lines are voiced once by text-to-speech with a voice designed from a description. Nobody’s voice is cloned.
The take. The game runs on the test bench. The bench holds the talk key while the recording plays; the AI server hears it through the same speech recognition as a player’s microphone, and Xardas answers with the language model, in his voice. The bench films it, together with the game’s own sound.
Several takes. The answers differ every time, so the agent films a few, reads what was said in each, and picks the one that carries the idea.
The cut. The pauses while the model thinks are cut down to a beat, the hero’s voice is mixed in, subtitles go on, and out comes a 1080×1920 short in Russian or English.

In the take we kept, Xardas refuses twice and then sees through it:

And stop hiding every request behind Lee’s name.

Nobody wrote that line.

What we keep honest

The answers are not edited and not picked line by line: a take is used whole or not at all. Only the silence while the model thinks is shortened, and the description of every short says so. The hero’s voice is synthetic and says exactly the script; what the characters heard is in the take’s transcript, mistakes of the speech recognition included.

What it took

The bench records the game’s sound by mixing it into the recording frame by frame instead of playing it, so the video and the sound never drift apart. The game has to keep to real time while it films, because the AI server lives in real time; drawing only the recorded frame and encoding on the GPU got it to 96-99% of real time at 972×1728. One of the first takes lost an answer to an overloaded language model; the summary of every take shows that, and the take is filmed again.

The tool is in the repository, in shorts/.

Three days in: characters that talk back

Mon, 12 Oct 2026 12:00:00 +0300

Gothic AI started on October 10 with a question: what if the people of Gothic II could actually hear you? Three days and about eighty commits later, they can.

The game is the original Gothic II: Night of the Raven, running on the open-source OpenGothic engine. Inside the engine sits a thin bridge; everything clever runs in a separate AI server next to the game.

What works

You talk with your voice. There is no chat window: you hold T, walk up to someone and speak. Speech recognition (Voxtral) turns it into text while you are still talking, and the server works out whom you addressed, from where you look and what you say.

They answer with voices of their own. Each character gets a voice designed from a description of it, not cloned from the original actors. The voice starts while the answer is still being generated, so the first words come quickly.

They act, not only talk. Characters follow you, give you items, draw weapons, fight or run away. A conversation can end in a deal, or in a fight.

They remember. Conversations are remembered per save game: load an older save and the characters forget what happened after it. Bystanders overhear what you say to someone else, which matters, because lying is meant to be part of the game.

Two minds per character. A small model, fine-tuned on scenes from Gothic, runs the body: the daily routine, reactions to a drawn sword, fleeing or fighting, in a fraction of a second. The large language model does the talking and sets intentions. The body reacts first, the words follow.

Feet on the ground. Not AI, but you notice it at once: with foot IK people stand on slopes and stairs with both feet, and wolves and molerats with all four paws, instead of hovering above the ground.

The tooling around it

A launcher starts the game and all the services with one button. A test bench plays scenarios inside the game on its own and records video, metrics and a report of suspicious frames, which is how the foot IK was tuned without anyone watching the screen.

The story layer. We are lifting the dialogues of the original scripts into a graph that an AI director can edit, to build quests on top of the original story rather than instead of it, and to make lies to the characters work and have consequences.

The project is not playable yet: it runs from source on macOS and needs your own copy of the game.

Gothic AI devlog

The sword hits now, not a rule: the numbers

The rule it replaces

The blade

What follows from it

What we keep honest

Next

How the bow works now: the numbers

The dice it replaces

Damage

What the stats do

Against the dice

What we keep honest

Next

Aiming a bow by hand

How it plays

Balance

What we keep honest

Next

What happens if you insult Xardas

How it works

Does it really tip

What we keep honest

Next

Bodies that react

What changed

How it was tested

What we keep honest

Next

The shorts film themselves

How a short is made

What we keep honest

What it took

Three days in: characters that talk back

What works

The tooling around it

Next