458 lines
18 KiB
PHP
458 lines
18 KiB
PHP
<?php
|
|
|
|
namespace App\Engine;
|
|
|
|
use App\Game\GameRuleViolation;
|
|
use App\Game\Trade\TradeRules;
|
|
use App\Game\Travel\TravelTime;
|
|
use App\Models\Building;
|
|
use App\Models\GameEvent;
|
|
use App\Models\Movement;
|
|
use App\Models\Report;
|
|
use App\Models\TradeOffer;
|
|
use App\Models\TradeRoute;
|
|
use App\Models\Village;
|
|
use Carbon\CarbonImmutable;
|
|
|
|
/**
|
|
* The market of one village (architecture.md, "Market"). Merchants under way are
|
|
* movements of type trade (with cargo) and trade_return (empty, going home); they arrive
|
|
* by the target's movement.arrives event like troops, so an arrival runs with the target
|
|
* locked. Sending, offers and routes run with this village locked.
|
|
*/
|
|
final class Market
|
|
{
|
|
private TradeRules $rules;
|
|
|
|
private function __construct(private readonly Village $village, private readonly Simulation $sim)
|
|
{
|
|
$this->rules = new TradeRules($sim->config());
|
|
}
|
|
|
|
public static function of(Village $village, ?Simulation $sim = null): self
|
|
{
|
|
return new self($village, $sim ?? Simulation::of($village));
|
|
}
|
|
|
|
public function rules(): TradeRules
|
|
{
|
|
return $this->rules;
|
|
}
|
|
|
|
public function building(): ?Building
|
|
{
|
|
return $this->village->buildings->firstWhere('type', TradeRules::BUILDING);
|
|
}
|
|
|
|
/** Merchants the market's level gives, 0 without a market. */
|
|
public function merchants(): int
|
|
{
|
|
return $this->rules->merchants($this->building()?->level ?? 0);
|
|
}
|
|
|
|
/** Merchants on this village's trades, out and back, and reserved by its open offers. */
|
|
public function busy(): int
|
|
{
|
|
$id = $this->village->id;
|
|
$moving = (int) Movement::where(fn ($q) => $q
|
|
->where(fn ($q) => $q->where('origin_id', $id)->where('type', Movement::TRADE))
|
|
->orWhere(fn ($q) => $q->where('target_id', $id)->where('type', Movement::TRADE_RETURN)))
|
|
->sum('merchants');
|
|
$reserved = TradeOffer::where('village_id', $id)->get(['count', 'merchants'])->sum(fn (TradeOffer $o) => $o->count * $o->merchants);
|
|
|
|
return $moving + $reserved;
|
|
}
|
|
|
|
public function free(): int
|
|
{
|
|
return TradeRules::free($this->merchants(), $this->busy());
|
|
}
|
|
|
|
public function requireMarket(): void
|
|
{
|
|
if (! $this->building()) {
|
|
throw new GameRuleViolation('no_market', 'Build a market first.');
|
|
}
|
|
}
|
|
|
|
/** Merchants go to another player village of the same world. */
|
|
public function checkTarget(Village $target): void
|
|
{
|
|
if ($target->id === $this->village->id || $target->world_id !== $this->village->world_id) {
|
|
throw new GameRuleViolation('same_village', 'Pick another village.');
|
|
}
|
|
if ($target->player_id === null) {
|
|
throw new GameRuleViolation('barbarian', 'Barbarian villages don\'t trade.');
|
|
}
|
|
}
|
|
|
|
/** @return array{distance: float, seconds: int, arrives_at: CarbonImmutable} */
|
|
public function plan(Village $target, CarbonImmutable $now): array
|
|
{
|
|
$distance = TravelTime::distance($this->village->x, $this->village->y, $target->x, $target->y);
|
|
$seconds = $this->rules->seconds($distance);
|
|
|
|
return ['distance' => $distance, 'seconds' => $seconds, 'arrives_at' => $now->addSeconds($seconds)];
|
|
}
|
|
|
|
/**
|
|
* Send resources from the stock to $target; the merchants leave at once.
|
|
*
|
|
* @param array<string, mixed> $amounts
|
|
*/
|
|
public function send(Village $target, array $amounts, CarbonImmutable $now): Movement
|
|
{
|
|
$this->requireMarket();
|
|
$this->checkTarget($target);
|
|
$cargo = $this->rules->cargo($amounts);
|
|
if (array_sum($cargo) <= 0) {
|
|
throw new GameRuleViolation('nothing', 'Send at least one resource.');
|
|
}
|
|
if (! $this->sim->canPay($cargo)) {
|
|
throw new GameRuleViolation('resources', 'Not enough resources.');
|
|
}
|
|
$merchants = $this->rules->needed(array_sum($cargo));
|
|
if ($merchants > $this->free()) {
|
|
throw new GameRuleViolation('merchants', 'Not enough free merchants.');
|
|
}
|
|
$this->sim->pay($cargo);
|
|
|
|
return $this->dispatch($this->village, $target, $cargo, $merchants, $now);
|
|
}
|
|
|
|
// Offers
|
|
|
|
/** Offer count times giveAmount of one resource for wantAmount of another; the goods and merchants are reserved. */
|
|
public function offer(string $give, int $giveAmount, string $want, int $wantAmount, int $count): TradeOffer
|
|
{
|
|
$this->requireMarket();
|
|
$this->rules->checkOffer($give, $giveAmount, $want, $wantAmount, $count);
|
|
$reserve = $this->rules->cargo([$give => $giveAmount * $count]);
|
|
if (! $this->sim->canPay($reserve)) {
|
|
throw new GameRuleViolation('resources', 'Not enough resources.');
|
|
}
|
|
$merchants = $this->rules->needed($giveAmount);
|
|
if ($merchants * $count > $this->free()) {
|
|
throw new GameRuleViolation('merchants', 'Not enough free merchants.');
|
|
}
|
|
$this->sim->pay($reserve);
|
|
|
|
return TradeOffer::create([
|
|
'world_id' => $this->village->world_id,
|
|
'village_id' => $this->village->id,
|
|
'give_resource' => $give,
|
|
'give_amount' => $giveAmount,
|
|
'want_resource' => $want,
|
|
'want_amount' => $wantAmount,
|
|
'count' => $count,
|
|
'merchants' => $merchants,
|
|
]);
|
|
}
|
|
|
|
/** Take an own offer back: the goods of the open count return as far as the storage holds them. */
|
|
public function cancelOffer(int $offerId): void
|
|
{
|
|
$offer = TradeOffer::whereKey($offerId)->lockForUpdate()->first();
|
|
if (! $offer || $offer->village_id !== $this->village->id) {
|
|
throw new GameRuleViolation('not_found', 'No such offer.');
|
|
}
|
|
$this->sim->refund([$offer->give_resource => $offer->give_amount * $offer->count]);
|
|
$offer->delete();
|
|
}
|
|
|
|
/**
|
|
* Take $count of another player's offer: this village's merchants carry what it asks
|
|
* for, the offer's reserved merchants carry what it gives, and both leave at once.
|
|
* The offer row stays locked, so two buyers can't take the same count.
|
|
*/
|
|
public function accept(int $offerId, int $count, CarbonImmutable $now): void
|
|
{
|
|
$this->requireMarket();
|
|
$offer = TradeOffer::whereKey($offerId)->lockForUpdate()->first();
|
|
$seller = $offer ? Village::with('player')->find($offer->village_id) : null;
|
|
if (! $offer || ! $seller || $offer->world_id !== $this->village->world_id || $offer->count < 1) {
|
|
throw new GameRuleViolation('not_found', 'That offer is gone.');
|
|
}
|
|
if ($seller->player_id === $this->village->player_id) {
|
|
throw new GameRuleViolation('own_offer', 'That is your own offer.');
|
|
}
|
|
if ($count < 1 || $count > $offer->count) {
|
|
throw new GameRuleViolation('count', 'Not that many of this offer are open.');
|
|
}
|
|
$pay = $this->rules->cargo([$offer->want_resource => $offer->want_amount * $count]);
|
|
if (! $this->sim->canPay($pay)) {
|
|
throw new GameRuleViolation('resources', 'Not enough resources.');
|
|
}
|
|
$merchants = $this->rules->needed(array_sum($pay));
|
|
if ($merchants > $this->free()) {
|
|
throw new GameRuleViolation('merchants', 'Not enough free merchants.');
|
|
}
|
|
$this->sim->pay($pay);
|
|
$this->dispatch($this->village, $seller, $pay, $merchants, $now, null, true);
|
|
$goods = $this->rules->cargo([$offer->give_resource => $offer->give_amount * $count]);
|
|
$this->dispatch($seller, $this->village, $goods, $offer->merchants * $count, $now, null, true);
|
|
|
|
$offer->count -= $count;
|
|
$offer->count > 0 ? $offer->save() : $offer->delete();
|
|
Push::queue($seller->id, $this->village->id);
|
|
}
|
|
|
|
// Arrivals
|
|
|
|
/**
|
|
* Merchants reach this village (the caller settled it). With cargo they unload into
|
|
* the storage, where what doesn't fit is lost, and turn round, taking as long home as
|
|
* they took here. Empty ones are home and free again.
|
|
*/
|
|
public function arrive(Movement $movement, CarbonImmutable $at): void
|
|
{
|
|
if ($movement->type === Movement::TRADE_RETURN) {
|
|
$movement->delete();
|
|
Push::queue($this->village->id);
|
|
|
|
return;
|
|
}
|
|
$this->sim->refund($movement->cargo ?? []);
|
|
$this->report($movement, $at);
|
|
|
|
$took = $movement->arrives_at->getTimestampMs() - $movement->sent_at->getTimestampMs();
|
|
$home = $movement->origin_id;
|
|
$movement->update([
|
|
'type' => Movement::TRADE_RETURN,
|
|
'origin_id' => $this->village->id,
|
|
'target_id' => $home,
|
|
'cargo' => null,
|
|
'sent_at' => $at,
|
|
'arrives_at' => $at->addMilliseconds($took),
|
|
'visible_at' => $at,
|
|
]);
|
|
$this->schedule($movement, $home, $movement->arrives_at);
|
|
Push::queue($this->village->id, $home);
|
|
}
|
|
|
|
/** Both players hear of a delivery between them; one player's own villages write nothing. */
|
|
private function report(Movement $movement, CarbonImmutable $at): void
|
|
{
|
|
if ($this->village->player_id === $movement->player_id) {
|
|
return;
|
|
}
|
|
$origin = Village::with('player')->find($movement->origin_id);
|
|
$payload = [
|
|
'from' => Rally::summary($origin),
|
|
'to' => Rally::summary($this->village),
|
|
'cargo' => $movement->cargo,
|
|
'offer' => $movement->offer,
|
|
];
|
|
Report::write($this->village->player_id, Report::TRADE, $payload, $at);
|
|
Report::write($movement->player_id, Report::TRADE, $payload, $at);
|
|
}
|
|
|
|
// Trade routes
|
|
|
|
/**
|
|
* A shipment repeated every $every real seconds, the first $every from now.
|
|
*
|
|
* @param array<string, mixed> $amounts
|
|
*/
|
|
public function createRoute(Village $target, array $amounts, int $every, CarbonImmutable $now): TradeRoute
|
|
{
|
|
$this->requireMarket();
|
|
$this->checkTarget($target);
|
|
$cargo = $this->rules->cargo($amounts);
|
|
if (array_sum($cargo) <= 0) {
|
|
throw new GameRuleViolation('nothing', 'Send at least one resource.');
|
|
}
|
|
$this->rules->checkEvery($every);
|
|
if (TradeRoute::where('village_id', $this->village->id)->count() >= $this->rules->maxRoutes()) {
|
|
throw new GameRuleViolation('max_routes', 'This village runs as many routes as it can.');
|
|
}
|
|
$route = TradeRoute::create([
|
|
'village_id' => $this->village->id,
|
|
'target_id' => $target->id,
|
|
'target_player_id' => $target->player_id,
|
|
...$cargo,
|
|
'every' => $every,
|
|
'next_at' => $now->addSeconds($every),
|
|
]);
|
|
$this->planRoute($route);
|
|
|
|
return $route;
|
|
}
|
|
|
|
/**
|
|
* Change a route's amounts, interval or pause. A new interval or a resume plans the
|
|
* next run that far from now; resuming accepts the target's owner as it is now.
|
|
*
|
|
* @param array{wood?: int|null, clay?: int|null, iron?: int|null, every?: int|null, paused?: bool|null} $changes
|
|
*/
|
|
public function updateRoute(int $routeId, array $changes, CarbonImmutable $now): void
|
|
{
|
|
$route = $this->route($routeId);
|
|
$amounts = $route->amounts();
|
|
foreach (TradeRules::CARGO as $resource) {
|
|
if (isset($changes[$resource])) {
|
|
$amounts[$resource] = $changes[$resource];
|
|
}
|
|
}
|
|
$cargo = $this->rules->cargo($amounts);
|
|
if (array_sum($cargo) <= 0) {
|
|
throw new GameRuleViolation('nothing', 'Send at least one resource.');
|
|
}
|
|
$every = $changes['every'] ?? $route->every;
|
|
$this->rules->checkEvery($every);
|
|
$replan = $every !== $route->every;
|
|
$route->fill([...$cargo, 'every' => $every]);
|
|
|
|
$paused = $changes['paused'] ?? $route->paused;
|
|
if ($paused && ! $route->paused) {
|
|
$route->fill(['paused' => true, 'paused_reason' => null]);
|
|
} elseif (! $paused && $route->paused) {
|
|
$target = Village::find($route->target_id);
|
|
if (! $target || $target->player_id === null) {
|
|
throw new GameRuleViolation('barbarian', 'Barbarian villages don\'t trade.');
|
|
}
|
|
$route->fill(['paused' => false, 'paused_reason' => null, 'target_player_id' => $target->player_id]);
|
|
$replan = true;
|
|
}
|
|
|
|
if ($route->paused) {
|
|
self::dropRouteEvents($route->id);
|
|
$route->save();
|
|
|
|
return;
|
|
}
|
|
if ($replan) {
|
|
$route->next_at = $now->addSeconds($route->every);
|
|
}
|
|
$route->save();
|
|
if ($replan) {
|
|
$this->planRoute($route);
|
|
}
|
|
}
|
|
|
|
public function deleteRoute(int $routeId): void
|
|
{
|
|
$route = $this->route($routeId);
|
|
self::dropRouteEvents($route->id);
|
|
$route->delete();
|
|
}
|
|
|
|
/**
|
|
* The trade.route handler: send what the stock and the free merchants allow, then plan
|
|
* the next run `every` seconds after this one. A target with another owner than when
|
|
* the route was made pauses it instead. Runs once per event row: a route moved to
|
|
* another time or paused meanwhile ignores the old event.
|
|
*/
|
|
public function runRoute(GameEvent $event): void
|
|
{
|
|
$at = $event->fire_at;
|
|
$route = TradeRoute::whereKey($event->subject_id)->lockForUpdate()->first();
|
|
if (! $route || $route->village_id !== $this->village->id || $route->paused
|
|
|| $route->next_at->getTimestampMs() !== $at->getTimestampMs() || $this->village->world->ended_at) {
|
|
return;
|
|
}
|
|
$target = Village::find($route->target_id);
|
|
if (! $target || $target->player_id !== $route->target_player_id) {
|
|
$route->update(['paused' => true, 'paused_reason' => TradeRoute::OWNER_CHANGED]);
|
|
Push::queue($this->village->id);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->sim->settle($at);
|
|
$free = $this->building() ? $this->free() : 0;
|
|
$cargo = $this->rules->routeCargo($route->amounts(), $this->village->resources(), $free);
|
|
if (array_sum($cargo) > 0) {
|
|
$this->sim->pay($cargo);
|
|
$this->dispatch($this->village, $target, $cargo, $this->rules->needed(array_sum($cargo)), $at, $route->id);
|
|
}
|
|
// An empty run is recorded too, so the player sees the route found nothing to send.
|
|
$route->fill(['last_sent_at' => $at, 'last_cargo' => $cargo, 'next_at' => $at->addSeconds($route->every)])->save();
|
|
$this->planRoute($route);
|
|
}
|
|
|
|
/**
|
|
* What a village loses with its owner on the market: its open offers with the goods
|
|
* they reserved, and its routes. Its trades under way go with its other commands
|
|
* (Nobility::release); trades coming to it still arrive.
|
|
*/
|
|
public static function release(Village $village): void
|
|
{
|
|
TradeOffer::where('village_id', $village->id)->delete();
|
|
foreach (TradeRoute::where('village_id', $village->id)->pluck('id') as $id) {
|
|
self::dropRouteEvents($id);
|
|
}
|
|
TradeRoute::where('village_id', $village->id)->delete();
|
|
}
|
|
|
|
private function route(int $routeId): TradeRoute
|
|
{
|
|
$route = TradeRoute::whereKey($routeId)->lockForUpdate()->first();
|
|
if (! $route || $route->village_id !== $this->village->id) {
|
|
throw new GameRuleViolation('not_found', 'No such route.');
|
|
}
|
|
|
|
return $route;
|
|
}
|
|
|
|
private function planRoute(TradeRoute $route): void
|
|
{
|
|
self::dropRouteEvents($route->id);
|
|
GameEvent::create([
|
|
'world_id' => $this->village->world_id,
|
|
'village_id' => $route->village_id,
|
|
'type' => GameEvent::TRADE_ROUTE,
|
|
'subject_id' => $route->id,
|
|
'fire_at' => $route->next_at,
|
|
]);
|
|
}
|
|
|
|
private static function dropRouteEvents(int $routeId): void
|
|
{
|
|
GameEvent::where('type', GameEvent::TRADE_ROUTE)->where('subject_id', $routeId)->whereNull('processed_at')->delete();
|
|
}
|
|
|
|
/**
|
|
* Merchants leave $from for $to with this cargo. Their arrival is an event on the
|
|
* target, and the target sees them from the start.
|
|
*
|
|
* @param array{wood: int, clay: int, iron: int} $cargo
|
|
*/
|
|
private function dispatch(Village $from, Village $to, array $cargo, int $merchants, CarbonImmutable $at, ?int $routeId = null, bool $offer = false): Movement
|
|
{
|
|
$seconds = $this->rules->seconds(TravelTime::distance($from->x, $from->y, $to->x, $to->y));
|
|
$movement = Movement::create([
|
|
'world_id' => $from->world_id,
|
|
'player_id' => $from->player_id,
|
|
'type' => Movement::TRADE,
|
|
// Merchants have one pace; the column wants a mode.
|
|
'mode' => (new TravelTime($this->sim->config()))->defaultMode(),
|
|
'origin_id' => $from->id,
|
|
'target_id' => $to->id,
|
|
'units' => [],
|
|
'cargo' => $cargo,
|
|
'merchants' => $merchants,
|
|
'route_id' => $routeId,
|
|
'offer' => $offer,
|
|
'sent_at' => $at,
|
|
'arrives_at' => $at->addSeconds($seconds),
|
|
'visible_at' => $at,
|
|
]);
|
|
$this->schedule($movement, $to->id, $movement->arrives_at);
|
|
Push::queue($to->id);
|
|
|
|
return $movement;
|
|
}
|
|
|
|
private function schedule(Movement $movement, int $villageId, CarbonImmutable $at): void
|
|
{
|
|
GameEvent::create([
|
|
'world_id' => $movement->world_id,
|
|
'village_id' => $villageId,
|
|
'type' => GameEvent::MOVEMENT_ARRIVES,
|
|
'subject_id' => $movement->id,
|
|
'fire_at' => $at,
|
|
]);
|
|
}
|
|
}
|