feat: raiders: the nearest barbarian camp raids every player village about once a day

A raid.planned event per village picks the nearest camp in range, announces a
band sized by the village's points hours before it marches, and plans the next
one. On arrival the band is as strong as its camp; a beaten camp's band scatters.
Loot goes back to the camp, a beaten band pays a bounty.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Fabian @ Blax Software 2026-10-29 16:07:54 +01:00
parent 71040bbef9
commit 1319276e2f
20 changed files with 669 additions and 4 deletions

View File

@ -2,6 +2,7 @@
namespace App\Actions;
use App\Engine\Raiders;
use App\Engine\VillageFactory;
use App\Game\GameRuleViolation;
use App\Game\Map\Frontier;
@ -38,6 +39,7 @@ final class JoinWorld
$levels = array_fill_keys($world->gameConfig()->get('world.village.start_buildings'), 1);
$village = $this->villages->create($world, $player, "{$user->name}'s village", $x, $y, $levels);
$this->barbarians->around($world, $village, $taken);
Raiders::of($village)->ensurePlanned(now()->toImmutable());
return $village;
});

View File

@ -3,6 +3,7 @@
namespace App\Actions;
use App\Engine\Barbarians;
use App\Engine\Raiders;
use App\Engine\VillageFactory;
use App\Game\Map\BarbarianGrowth;
use App\Game\Map\Frontier;
@ -108,6 +109,23 @@ final class SpawnBarbarians
return $changed;
}
/**
* Plan a raid for every player village without one, from now or the end of its
* owner's beginner protection. Safe to run on every deploy.
*/
public function scheduleRaids(World $world): void
{
$now = now()->toImmutable();
foreach ($world->villages()->whereNotNull('player_id')->pluck('id') as $id) {
DB::transaction(function () use ($id, $now) {
$village = Village::whereKey($id)->lockForUpdate()->first();
if ($village?->player_id !== null) {
Raiders::of($village)->ensurePlanned($now);
}
});
}
}
/** The first growth step lands 0.5–1.5 intervals out, so villages don't grow in step. */
private function scheduleFirstGrowth(World $world, Village $village): void
{

View File

@ -114,6 +114,7 @@ final class Engine
GameEvent::BUILD_ORDER_FINISHED => $this->finishBuildOrder($village, $event),
GameEvent::BARBARIAN_GROWS => $this->growBarbarian($village, $event),
GameEvent::BARBARIAN_REGROUPS => Barbarians::of($village)->regroup($event->fire_at),
GameEvent::RAID_PLANNED => Raiders::of($village)->plan($event),
GameEvent::RECRUIT_FINISHED => Military::of($village)->settle($event->fire_at),
GameEvent::LEVY_ENDS => Military::of($village)->endLevy($event->fire_at),
// The stock just hit 0; the sync() after every event starts the grace timer.

View File

@ -107,8 +107,11 @@ final class Nobility
}
$village->player_id = $playerId;
$village->setRelation('player', Player::find($playerId));
$village->loyalty = $this->rules->afterConquest();
$village->loyalty_at = $at;
// Raiders come for the new owner's village too.
Raiders::of($village)->ensurePlanned($at);
return array_values(array_unique($touched));
}

141
app/Engine/Raiders.php Normal file
View File

@ -0,0 +1,141 @@
<?php
namespace App\Engine;
use App\Game\Combat\Raids;
use App\Game\Travel\TravelTime;
use App\Models\GameEvent;
use App\Models\Movement;
use App\Models\Village;
use Carbon\CarbonImmutable;
/**
* Raids on one player village (architecture.md, "Raids"). A `raid.planned` event on the
* village picks the nearest barbarian camp and sends a band that gathers there first,
* so the village sees it coming hours ahead; the next raid is planned at once. Runs
* with the village locked; the camp is only read.
*/
final class Raiders
{
private Raids $raids;
private function __construct(private readonly Village $village, private readonly Simulation $sim)
{
$this->raids = new Raids($sim->config());
}
public static function of(Village $village, ?Simulation $sim = null): self
{
return new self($village, $sim ?? Simulation::of($village));
}
public function rules(): Raids
{
return $this->raids;
}
/** Make sure a raid is planned, no earlier than $earliest or the end of beginner protection. */
public function ensurePlanned(CarbonImmutable $earliest): void
{
if ($this->village->player_id === null || ! $this->raids->enabled()) {
return;
}
$waiting = GameEvent::where('type', GameEvent::RAID_PLANNED)->where('village_id', $this->village->id)->whereNull('processed_at')->exists();
if (! $waiting) {
$protected = Rally::of($this->village, $this->sim)->protectedUntil($this->village->player);
$this->schedule($protected->greaterThan($earliest) ? $protected : $earliest);
}
}
/** The `raid.planned` handler: send a band from the nearest camp and plan the next raid. */
public function plan(GameEvent $event): void
{
$at = $event->fire_at;
if ($this->village->player_id === null || ! $this->raids->enabled()) {
return;
}
$protected = Rally::of($this->village, $this->sim)->protectedUntil($this->village->player);
if ($protected->greaterThan($at)) {
$this->schedule($protected);
return;
}
// Seeded per event, so a replayed event draws the same interval.
mt_srand($event->id);
$interval = $this->raids->interval(mt_rand() / (mt_getrandmax() + 1));
$camp = $this->camp();
$wall = $this->village->buildings->firstWhere('type', 'wall')?->level ?? 0;
$units = $camp ? $this->raids->band(Barbarians::of($camp)->profile(), (int) $this->village->points, $wall) : [];
if (! $units) {
$this->schedule($at->addSeconds($interval));
return;
}
$travel = new TravelTime($this->sim->config());
$marches = $at->addSeconds($this->raids->gatherSeconds());
$arrives = $marches->addSeconds($travel->seconds($units, TravelTime::distance($camp->x, $camp->y, $this->village->x, $this->village->y), $this->raids->mode()));
$movement = Movement::create([
'world_id' => $this->village->world_id,
'player_id' => null,
'type' => Movement::ATTACK,
'mode' => $this->raids->mode(),
'origin_id' => $camp->id,
'target_id' => $this->village->id,
'units' => $units,
'rng_seed' => mt_rand(1, 2_000_000_000),
// It gathers until it marches, and is seen from the start.
'sent_at' => $marches,
'arrives_at' => $arrives,
'visible_at' => $at,
]);
GameEvent::create([
'world_id' => $this->village->world_id,
'village_id' => $this->village->id,
'type' => GameEvent::MOVEMENT_ARRIVES,
'subject_id' => $movement->id,
'fire_at' => $arrives,
]);
Push::queue($this->village->id);
$this->schedule($arrives->addSeconds($interval));
}
/**
* The band as it reaches the village: as strong as its camp is now. Empty when it
* scatters (the camp was beaten down or changed hands).
*
* @return array<string, int>
*/
public function muster(Movement $movement): array
{
$camp = Village::find($movement->origin_id);
if (! $camp || $camp->player_id !== null) {
return [];
}
return $this->raids->muster($movement->units, Barbarians::of($camp)->strength());
}
/** The nearest barbarian village in range. */
private function camp(): ?Village
{
$range = $this->raids->range();
$camps = Village::where('world_id', $this->village->world_id)->whereNull('player_id')
->whereBetween('x', [$this->village->x - $range, $this->village->x + $range])
->whereBetween('y', [$this->village->y - $range, $this->village->y + $range])
->get(['id', 'x', 'y']);
$id = $this->raids->nearest($camps->map(fn (Village $v) => ['id' => $v->id, 'x' => $v->x, 'y' => $v->y]), $this->village->x, $this->village->y);
return $id ? Village::find($id) : null;
}
private function schedule(CarbonImmutable $at): void
{
GameEvent::create([
'world_id' => $this->village->world_id,
'village_id' => $this->village->id,
'type' => GameEvent::RAID_PLANNED,
'fire_at' => $at,
]);
}
}

View File

@ -5,6 +5,7 @@ namespace App\Engine;
use App\Game\Combat\Battle;
use App\Game\Combat\CombatResolver;
use App\Game\Combat\LootCalculator;
use App\Game\Combat\Raids;
use App\Game\GameRuleViolation;
use App\Game\Travel\TravelTime;
use App\Models\Building;
@ -252,6 +253,17 @@ final class Rally
private function battle(Movement $movement, CarbonImmutable $at): void
{
$config = $this->sim->config();
// Raiders are as strong as their camp is when they arrive; a beaten camp's band scatters.
$raid = $movement->player_id === null;
if ($raid) {
$units = Raiders::of($this->village, $this->sim)->muster($movement);
if (! $units) {
$this->scatter($movement, $at);
return;
}
$movement->units = $units;
}
$combat = new CombatResolver($config);
$stacks = $this->village->troops->filter(fn (UnitStack $s) => $s->count > 0);
$defense = [];
@ -359,6 +371,12 @@ final class Rally
if ($damaged) {
$this->village->points = $this->sim->points();
}
// A beaten band leaves its bounty behind.
$bounty = null;
if ($raid && $battle && ! $battle->attackerWon) {
$bounty = (new Raids($config))->bounty($army);
$this->sim->refund($bounty);
}
$origin = Village::with('player')->find($movement->origin_id);
$scouted = $through && $scoutsLost < array_sum($scouts);
@ -374,6 +392,8 @@ final class Rally
'loot' => $loot,
'capacity' => $capacity,
'loyalty' => $loyalty,
'raid' => $raid,
'bounty' => $bounty,
// What scouts that got through saw, after the battle.
'scouting' => $scouts ? [
'sent' => array_sum($scouts),
@ -408,6 +428,19 @@ final class Rally
$survivors ? $this->turnBack($movement, $survivors, $loot, $at) : $movement->delete();
}
/** A band whose camp was beaten down never arrives; the village hears of it. */
private function scatter(Movement $movement, CarbonImmutable $at): void
{
$origin = Village::with('player')->find($movement->origin_id);
Report::write($this->village->player_id, Report::DEFENSE, [
'raid' => true,
'scattered' => true,
'attacker' => ['village' => $origin ? self::summary($origin) : null, 'units' => null, 'lost' => null],
'defender' => ['village' => self::summary($this->village), 'units' => null, 'lost' => null],
], $at);
$movement->delete();
}
/**
* The attacker takes the village: one nobleman settles, the other survivors stay as
* support from the village they came from.

147
app/Game/Combat/Raids.php Normal file
View File

@ -0,0 +1,147 @@
<?php
namespace App\Game\Combat;
use App\Game\Map\BarbarianGarrison;
use App\Game\Travel\TravelTime;
use App\Game\WorldConfig;
/**
* Raiders from barbarian camps (config/game/raids.php, architecture.md "Raids"): how
* big a band is, how often it comes, how its camp's strength shrinks it on arrival,
* and what a beaten band leaves behind.
*/
final class Raids
{
public const RESOURCES = ['wood', 'clay', 'iron'];
private BarbarianGarrison $garrison;
public function __construct(private readonly WorldConfig $config)
{
$this->garrison = new BarbarianGarrison($config);
}
public function enabled(): bool
{
return (bool) $this->config->get('raids.enabled', false);
}
/** Attack strength of a band against a village with these points. */
public function attack(int $points): float
{
$attack = $this->config->get('raids.attack');
return $attack['base'] + $attack['per_point'] * max(0, $points);
}
/**
* The band a camp sends: heads in the camp's profile until they reach the attack
* strength, plus rams against the wall once the village is big enough.
*
* @return array<string, int>
*/
public function band(?string $profile, int $points, int $wall): array
{
if ($profile === null) {
return [];
}
$shares = $this->garrison->shares($profile);
$total = array_sum($shares);
$perHead = $total > 0 ? array_sum(array_map(fn (string $u, float $s) => $s / $total * $this->unitAttack($u), array_keys($shares), $shares)) : 0;
if ($perHead <= 0) {
return [];
}
$units = BarbarianGarrison::split((int) ceil($this->attack($points) / $perHead), $shares);
$rams = $this->config->get('raids.rams');
if ($points >= $rams['from_points'] && $wall > 0 && $this->config->get('units.ram')) {
$count = (int) round($wall * $rams['per_wall_level']);
if ($count > 0) {
$units['ram'] = $count;
}
}
return $units;
}
/**
* The band as it arrives, as strong as its camp is now (share of full strength).
* Below scatter_below nothing is left of it.
*
* @param array<string, int> $units
* @return array<string, int>
*/
public function muster(array $units, float $strength): array
{
if ($strength < (float) $this->config->get('raids.scatter_below', 0)) {
return [];
}
return array_filter(array_map(fn (int $n) => (int) round($n * min(1.0, $strength)), $units));
}
/**
* What a beaten band leaves: bounty × its attack strength, a third each of wood,
* clay and iron.
*
* @param array<string, int> $units
* @return array{wood: int, clay: int, iron: int}
*/
public function bounty(array $units): array
{
$strength = array_sum(array_map(fn (string $u, int $n) => $n * $this->unitAttack($u), array_keys($units), $units));
$each = (int) floor($this->config->get('raids.bounty', 0) * $strength / count(self::RESOURCES));
return array_fill_keys(self::RESOURCES, $each);
}
/** Seconds until the next raid, at world speed, from a roll in [0, 1). */
public function interval(float $roll): int
{
[$min, $max] = $this->config->get('raids.every_hours');
return max(1, (int) round(($min + ($max - $min) * $roll) * 3600 / $this->config->speed()));
}
/** How long a band gathers at its camp before it marches, at world speed. */
public function gatherSeconds(): int
{
return (int) round($this->config->get('raids.gather_hours', 0) * 3600 / $this->config->speed());
}
public function mode(): string
{
return (string) $this->config->get('raids.mode', 'normal');
}
/**
* The nearest camp within range of x|y, the lower id on a tie.
*
* @param iterable<array{id: int, x: int, y: int}> $camps
*/
public function nearest(iterable $camps, int $x, int $y): ?int
{
$range = (float) $this->config->get('raids.range', 0);
$best = null;
$bestDistance = INF;
foreach ($camps as $camp) {
$distance = TravelTime::distance($x, $y, $camp['x'], $camp['y']);
if ($distance <= $range && ($distance < $bestDistance || ($distance === $bestDistance && $camp['id'] < $best))) {
$best = $camp['id'];
$bestDistance = $distance;
}
}
return $best;
}
public function range(): int
{
return (int) ceil($this->config->get('raids.range', 0));
}
private function unitAttack(string $unit): float
{
return (float) $this->config->get("units.$unit.attack", 0);
}
}

View File

@ -26,6 +26,7 @@ final class ConfigLint
...self::timersRun($config),
...self::questsReachable($config, $rules),
...self::garrisonsRegroup($config),
...self::raidsPause($config),
];
}
@ -104,6 +105,34 @@ final class ConfigLint
return $problems;
}
/**
* Raids come apart in time, with a warning, from camps in range, in a travel mode
* that exists, and a camp beaten down to nothing sends no band.
*/
private static function raidsPause(WorldConfig $config): array
{
if (! $config->get('raids.enabled', false)) {
return [];
}
$problems = [];
[$min, $max] = $config->get('raids.every_hours', [0, 0]) + [0, 0];
if ($min <= 0 || $max < $min) {
$problems[] = '[raids.every_hours] must be two hours above 0, the smaller first, so a village gets time between raids.';
}
if ($config->get('raids.gather_hours', 0) < 0 || $config->get('raids.range', 0) <= 0) {
$problems[] = '[raids.gather_hours] cannot be negative and [raids.range] must be above 0.';
}
$scatter = $config->get('raids.scatter_below', 0);
if ($scatter <= 0 || $scatter > 1) {
$problems[] = '[raids.scatter_below] must be above 0 and at most 1, or beating the camp would not stop its raid.';
}
if (! $config->get('movement.modes.'.$config->get('raids.mode', 'normal'))) {
$problems[] = '[raids.mode] is not a travel mode.';
}
return $problems;
}
/** A levy has to end and desertion waves have to come apart in time, or the village stays stuck. */
private static function timersRun(WorldConfig $config): array
{

View File

@ -14,7 +14,7 @@ final class WorldConfig
private function __construct(private readonly array $values) {}
/**
* @param array<string, mixed> $defaults keyed by file: world, economy, buildings
* @param array<string, mixed> $defaults keyed by file: world, economy, buildings, ...
* @param array<string, mixed> $overrides the same shape, e.g. ['world' => ['speed' => 100]]
*/
public static function make(array $defaults, array $overrides = []): self

View File

@ -15,6 +15,9 @@ class GameEvent extends Model
// A barbarian garrison gets part of its full strength back.
public const BARBARIAN_REGROUPS = 'barbarian.regroups';
// Raiders from the nearest barbarian camp gather against this village; plans the next raid too.
public const RAID_PLANNED = 'raid.planned';
public const RECRUIT_FINISHED = 'recruit.finished';
public const LEVY_ENDS = 'levy.ends';

View File

@ -29,6 +29,7 @@ class World extends Model
'units' => config('game.units'),
'combat' => config('game.combat'),
'movement' => config('game.movement'),
'raids' => config('game.raids'),
'quests' => config('game.quests'),
], $this->config ?? []);
}

View File

@ -44,6 +44,9 @@ final class RallyPresenter
'cargo' => $mine ? $m->cargo : null,
'sent_at' => $mine ? self::iso($m->sent_at) : null,
'arrives_at' => self::iso($m->arrives_at),
// Raiders from a barbarian camp, gathering there until marches_at.
'raid' => $m->player_id === null,
'marches_at' => $m->player_id === null && $m->sent_at->greaterThan($now) ? self::iso($m->sent_at) : null,
'cancel_until' => $mine && ! $incoming && $m->type !== Movement::RETURN && $cancelUntil->greaterThan($now) ? self::iso($cancelUntil) : null,
];
})->values()->all();

35
config/game/raids.php Normal file
View File

@ -0,0 +1,35 @@
<?php
// Raiders (architecture.md, "Raids"): the nearest barbarian camp sends a band at every
// player village now and then, announced while it gathers. Hours are at world speed 1.
return [
'enabled' => true,
// Hours between two raids on one village, drawn evenly between the two. The first
// comes when beginner protection ends.
'every_hours' => [18, 30],
// The band gathers this long at its camp before it marches; the village sees it
// coming from the start, so this is the least warning it gets.
'gather_hours' => 3,
// Only barbarian villages this many fields away or closer raid a village; the nearest one does.
'range' => 15,
// Attack strength of a band: base + per_point × the village's points, in its camp's profile.
'attack' => ['base' => 50, 'per_point' => 1.5],
// From this many village points on, rams come along: per_wall_level for each wall level.
'rams' => ['from_points' => 300, 'per_wall_level' => 1.0],
// On arrival the band is as strong as its camp's garrison is (share of full strength);
// below scatter_below it scatters, so hitting the camp first breaks the raid.
'scatter_below' => 0.25,
// A beaten band leaves bounty × its attack strength in resources, a third each of
// wood, clay and iron, up to what the storage holds.
'bounty' => 0.5,
'mode' => 'normal',
];

View File

@ -0,0 +1,23 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
// Raiders from barbarian camps march without a player.
return new class extends Migration
{
public function up(): void
{
Schema::table('movements', function (Blueprint $table) {
$table->unsignedBigInteger('player_id')->nullable()->change();
});
}
public function down(): void
{
Schema::table('movements', function (Blueprint $table) {
$table->unsignedBigInteger('player_id')->nullable(false)->change();
});
}
};

View File

@ -22,10 +22,12 @@ class WorldSeeder extends Seeder
'started_at' => now(),
]),
];
// Barbarian villages that lost their growth event get it back, and their garrison.
// Barbarian villages that lost their growth event get it back, and their garrison;
// player villages get a raid planned.
foreach ($worlds as $world) {
app(SpawnBarbarians::class)->scheduleGrowth($world);
app(SpawnBarbarians::class)->scheduleGarrisons($world);
app(SpawnBarbarians::class)->scheduleRaids($world);
}
}
}

View File

@ -124,6 +124,7 @@ A village may fail through war or bad play, but it must never get stuck. Every l
| Levy never returns | Militia return automatically on a timer. |
| All merchants killed | Merchants are trained at the market like units, so dead merchants can always be replaced. |
| Player loses every village | The player can restart on the same world with a fresh village. |
| Raids bleed a village dry | Raids come `every_hours` apart, after beginner protection, and loot only what the hiding places don't cover; rams never take a wall below 1, and no band takes a village. Beating the camp down scatters its next band. Lint: intervals above 0, `scatter_below` above 0. |
## Config
@ -232,6 +233,16 @@ The visibility radius decides two things:
Tribes arrive in M6, with ally, NAP (non-aggression pact), and enemy states between them. Until then, every other player is hostile. Hostility is checked at encounter time, not at send time.
## Raids
Barbarian camps raid the player villages around them (`config/game/raids.php`, rules in `Raids`, rows in `Raiders`), so a village has something to defend against even on a quiet world.
- Every player village has one `raid.planned` event waiting. The first fires when the owner's beginner protection ends (`world.join`, a conquest, or the seeder on deploy for villages from before raids). It picks the nearest barbarian village within `range` (15) fields and sends a band at the village, then plans the next raid `every_hours` (18 to 30, drawn per event) after this one arrives. With no camp in range it tries again after that interval.
- The band attacks with `attack.base + attack.per_point × village points` (50 + 1.5 × points) in its camp's garrison profile, plus `rams.per_wall_level` rams per wall level once the village has `rams.from_points` (300) points. It is an attack movement without a player (`player_id` null): it gathers at the camp for `gather_hours` (3) and then marches (`sent_at`), and the village sees it from the moment it is planned (`visible_at`). The payload marks it `raid` with `marches_at` while it gathers.
- On arrival it is as strong as its camp is then: each unit × the camp garrison's share of full strength. Below `scatter_below` (25%), or when the camp changed hands, it scatters and the village gets a report saying so. So striking the camp in the hours before a raid weakens or stops it. A conquered camp's raids are deleted with its other commands.
- The battle is an ordinary one at full morale. A won raid loots and returns to its camp, which keeps the loot (stock to raid back) and takes the survivors in as far as its garrison has room. A beaten band leaves `bounty` × its attack strength (0.5), a third each of wood, clay and iron, in the village. Reports carry `raid` and `bounty`.
- Feature tests run with raids off (`tests/Pest.php`), like barbarian spawns; `RaidTest` turns them on.
## Conquest
Villages change hands the Die Stämme way (`combat.conquest`, rules in `Conquest`, rows in `Nobility`):

148
tests/Feature/RaidTest.php Normal file
View File

@ -0,0 +1,148 @@
<?php
use App\Engine\Barbarians;
use App\Engine\VillageFactory;
use App\Models\GameEvent;
use App\Models\Movement;
use App\Models\Report;
use App\Models\Village;
use Carbon\CarbonImmutable;
use Database\Seeders\WorldSeeder;
beforeEach(function () {
$this->travelTo(CarbonImmutable::parse('2026-10-29 12:00:00'));
config([
'game.raids.enabled' => true,
// One profile, so the band is known: 0.7 × 10 + 0.3 × 25 = 14.5 attack a head.
'game.world.map.barbarians.garrison.profiles' => ['spearmen' => ['spear' => 0.7, 'sword' => 0.3]],
]);
});
/** A barbarian camp at full strength 3 fields east of the village. */
function raidCamp(Village $near, int $dx = 3): Village
{
$types = ['headquarters', 'storage', 'farm', 'timber_camp', 'clay_pit', 'iron_mine'];
$camp = app(VillageFactory::class)->create($near->world, null, 'Barbarian village', $near->x + $dx, $near->y, array_fill_keys($types, 8));
Barbarians::of($camp)->fill();
return $camp->fresh();
}
function pendingRaid(Village $village): ?CarbonImmutable
{
return GameEvent::where('type', GameEvent::RAID_PLANNED)->where('village_id', $village->id)->whereNull('processed_at')->value('fire_at');
}
/** Past beginner protection, with the band announced. */
function announced(Village $village): Movement
{
test()->travel(3)->days();
test()->artisan('game:events --once')->assertSuccessful();
return Movement::where('target_id', $village->id)->sole();
}
function arrive(Movement $movement): void
{
test()->travelTo($movement->arrives_at);
test()->artisan('game:events --once')->assertSuccessful();
}
it('plans the first raid for when beginner protection ends', function () {
$village = startVillage();
expect(pendingRaid($village)->toDateTimeString())->toBe('2026-11-01 12:00:00');
});
it('announces a band from the nearest camp hours before it arrives, and plans the next raid', function () {
$village = startVillage();
raidCamp($village, 6);
$camp = raidCamp($village);
$movement = announced($village);
// 50 + 1.5 × 21 points = 81.5 attack: 6 heads. They gather 3 h, then march 3 fields at 22 min.
expect($movement->origin_id)->toBe($camp->id)
->and($movement->player_id)->toBeNull()
->and($movement->units)->toBe(['spear' => 4, 'sword' => 2])
->and($movement->arrives_at->toDateTimeString())->toBe('2026-11-01 16:06:00');
$incoming = shown($village)['movements'][0];
expect($incoming)->toMatchArray(['type' => 'attack', 'direction' => 'in', 'raid' => true, 'marches_at' => '2026-11-01T15:00:00.000Z', 'arrives_at' => '2026-11-01T16:06:00.000Z'])
->and($incoming['units'])->toBeNull();
$next = pendingRaid($village);
expect($next->greaterThanOrEqualTo($movement->arrives_at->addHours(18)))->toBeTrue()
->and($next->lessThanOrEqualTo($movement->arrives_at->addHours(30)))->toBeTrue();
});
it('loots an undefended village and carries the loot back to its camp', function () {
$village = startVillage();
$camp = raidCamp($village);
$movement = announced($village);
$campWood = $camp->fresh()->wood;
arrive($movement);
$report = Report::where('player_id', $village->player_id)->sole();
// 4 spears and 2 swords carry 4 × 25 + 2 × 15 = 130.
expect($report->type)->toBe('defense')
->and($report->payload['won'])->toBeTrue()
->and($report->payload['raid'])->toBeTrue()
->and(array_sum($report->payload['loot']))->toBe(130);
$home = $movement->fresh();
expect($home->type)->toBe('return')->and($home->target_id)->toBe($camp->id);
arrive($home);
expect($camp->fresh()->wood)->toBeGreaterThan($campWood)
->and(Barbarians::of($camp->fresh())->current())->toEqual(Barbarians::of($camp->fresh())->full());
});
it('pays a bounty when the village beats the band', function () {
$village = startVillage();
raidCamp($village);
$village->troops()->create(['home_village_id' => $village->id, 'unit' => 'sword', 'count' => 20]);
$movement = announced($village);
$wood = shown($village)['resources']['wood'];
arrive($movement);
$report = Report::where('player_id', $village->player_id)->sole();
// 4 × 10 + 2 × 25 = 90 attack → 45, a third each.
expect($report->payload['won'])->toBeFalse()
->and($report->payload['bounty'])->toBe(['wood' => 15, 'clay' => 15, 'iron' => 15])
->and($report->payload['attacker']['lost'])->toBe(['spear' => 4, 'sword' => 2])
->and(Movement::count())->toBe(0)
->and(shown($village)['resources']['wood'])->toBeGreaterThan($wood + 14);
});
it('sends a weaker band from a weakened camp, and none from a beaten one', function () {
$village = startVillage();
$camp = raidCamp($village);
$movement = announced($village);
$camp->troops()->update(['count' => 0]);
$camp->troops()->where('unit', 'spear')->update(['count' => 6]);
arrive($movement);
// 6 of 10 spears and no swords: 6 of 10 food → the band at 60%.
$report = Report::where('player_id', $village->player_id)->sole();
expect($report->payload['attacker']['units'])->toBe(['spear' => 2, 'sword' => 1]);
// Once the band is back, the camp is beaten down to nothing.
arrive($movement->fresh());
$camp->troops()->delete();
$this->travelTo(pendingRaid($village));
$this->artisan('game:events --once')->assertSuccessful();
arrive(Movement::where('target_id', $village->id)->where('type', 'attack')->sole());
$scattered = Report::where('player_id', $village->player_id)->latest('id')->first();
expect($scattered->payload)->toMatchArray(['raid' => true, 'scattered' => true])
->and(Movement::where('target_id', $village->id)->where('type', 'attack')->exists())->toBeFalse();
});
it('plans raids for villages from before raids on deploy', function () {
$village = startVillage();
GameEvent::where('type', GameEvent::RAID_PLANNED)->delete();
(new WorldSeeder)->run();
expect(pendingRaid($village)->toDateTimeString())->toBe('2026-11-01 12:00:00');
(new WorldSeeder)->run();
expect(GameEvent::where('type', GameEvent::RAID_PLANNED)->count())->toBe(1);
});

View File

@ -13,9 +13,9 @@ use Database\Seeders\WorldSeeder;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
// Feature tests start without barbarians unless a test asks for them, so tests can place their own.
// Feature tests start without barbarians and raids unless a test asks for them, so tests can place their own.
pest()->extend(TestCase::class)->use(RefreshDatabase::class)
->beforeEach(fn () => config(['game.world.map.barbarians.per_join' => 0]))
->beforeEach(fn () => config(['game.world.map.barbarians.per_join' => 0, 'game.raids.enabled' => false]))
->in('Feature');
/** The default game config without booting Laravel, so unit tests stay pure. */
@ -30,6 +30,7 @@ function gameConfig(array $overrides = []): WorldConfig
'units' => require "$dir/units.php",
'combat' => require "$dir/combat.php",
'movement' => require "$dir/movement.php",
'raids' => require "$dir/raids.php",
'quests' => require "$dir/quests.php",
], $overrides);
}

View File

@ -74,3 +74,11 @@ it('reports garrisons that would starve their village or never regroup', functio
->toContain('Barbarian garrisons must regroup: [regroup.every_hours] and [regroup.share] above 0.')
->toContain('[garrison.max_food_share] must stay below [economy.villager_share], or a garrison starves its village.');
});
it('reports raids that never pause or that a beaten camp still sends', function () {
$config = gameConfig(['raids' => ['every_hours' => [0, 5], 'scatter_below' => 0, 'mode' => 'teleport']]);
expect(ConfigLint::check($config))
->toContain('[raids.every_hours] must be two hours above 0, the smaller first, so a village gets time between raids.')
->toContain('[raids.scatter_below] must be above 0 and at most 1, or beating the camp would not stop its raid.')
->toContain('[raids.mode] is not a travel mode.');
});

View File

@ -0,0 +1,56 @@
<?php
use App\Game\Combat\Raids;
it('sizes a band by the village points in its camp profile', function () {
$raids = new Raids(gameConfig());
// 50 + 1.5 × 300 = 500 attack; a spearmen head hits 0.7 × 10 + 0.3 × 25 = 14.5, so 35 heads.
expect($raids->attack(300))->toBe(500.0)
->and($raids->band('spearmen', 300, 0))->toBe(['spear' => 25, 'sword' => 10])
// Riders: 0.5 × 130 + 0.5 × 10 = 70 a head, 155 / 70 → 3 heads.
->and($raids->band('riders', 70, 0))->toBe(['light_cavalry' => 2, 'spear' => 1])
->and($raids->band(null, 300, 0))->toBe([]);
});
it('brings rams against the wall of a big enough village', function () {
$raids = new Raids(gameConfig());
expect($raids->band('swordsmen', 300, 5))->toHaveKey('ram', 5)
->and($raids->band('swordsmen', 299, 5))->not->toHaveKey('ram')
->and($raids->band('swordsmen', 300, 0))->not->toHaveKey('ram');
});
it('shrinks the band with its camp and scatters it below a quarter', function () {
$raids = new Raids(gameConfig());
$band = ['spear' => 25, 'sword' => 10];
expect($raids->muster($band, 1.0))->toBe($band)
->and($raids->muster($band, 0.5))->toBe(['spear' => 13, 'sword' => 5])
->and($raids->muster($band, 0.25))->toBe(['spear' => 6, 'sword' => 3])
->and($raids->muster($band, 0.24))->toBe([]);
});
it('leaves half its attack strength as bounty when beaten', function () {
// 25 × 10 + 10 × 25 = 500 attack → 250, a third each.
expect((new Raids(gameConfig()))->bounty(['spear' => 25, 'sword' => 10]))->toBe(['wood' => 83, 'clay' => 83, 'iron' => 83]);
});
it('comes every 18 to 30 hours at world speed, after a few hours of warning', function () {
$raids = new Raids(gameConfig());
$fast = new Raids(gameConfig(['world' => ['speed' => 100]]));
expect($raids->interval(0.0))->toBe(18 * 3600)
->and($raids->interval(0.5))->toBe(24 * 3600)
->and($fast->interval(0.5))->toBe(864)
->and($raids->gatherSeconds())->toBe(3 * 3600)
->and($fast->gatherSeconds())->toBe(108);
});
it('picks the nearest camp in range', function () {
$raids = new Raids(gameConfig());
$camps = [['id' => 7, 'x' => 10, 'y' => 0], ['id' => 3, 'x' => 0, 'y' => 4], ['id' => 2, 'x' => 4, 'y' => 0], ['id' => 9, 'x' => 16, 'y' => 0]];
expect($raids->nearest($camps, 0, 0))->toBe(2)
->and($raids->nearest([['id' => 9, 'x' => 16, 'y' => 0]], 0, 0))->toBeNull();
});