feat: market: merchants carry resources between villages, offers between players, repeating trade routes
Trades are movements (trade, trade_return) that arrive by the target's
movement.arrives event; they stay out of the rally lists, the map and the
rally cancel. A trade.route event sends a route's next shipment. A village
that changes hands loses its trades under way, offers and routes.
WS: market.show|preview|send|offers|offer|cancelOffer|accept|routeCreate|routeUpdate|routeDelete;
the village payload carries market {building_id, level, merchants, free, carry}.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
parent
b8d5983a63
commit
b79dcb81e7
|
|
@ -0,0 +1,57 @@
|
|||
<?php
|
||||
|
||||
namespace App\Actions;
|
||||
|
||||
use App\Engine\Rally;
|
||||
use App\Game\GameRuleViolation;
|
||||
use App\Game\Trade\TradeRules;
|
||||
use App\Game\Travel\TravelTime;
|
||||
use App\Models\TradeOffer;
|
||||
use App\Models\User;
|
||||
use App\Models\Village;
|
||||
use App\Presenters\MarketPresenter;
|
||||
|
||||
/** The open offers of a world, nearest to the village first, optionally of one resource given or asked for. */
|
||||
final class ListOffers
|
||||
{
|
||||
public const LIMIT = 100;
|
||||
|
||||
public function __invoke(User $user, int $villageId, ?string $give = null, ?string $want = null): array
|
||||
{
|
||||
$village = Village::with('player', 'world')->find($villageId);
|
||||
if (! $village || $village->player?->user_id !== $user->id) {
|
||||
throw new GameRuleViolation('not_found', 'Village not found.');
|
||||
}
|
||||
$rules = new TradeRules($village->world->gameConfig());
|
||||
[$x, $y] = [$village->x, $village->y];
|
||||
|
||||
$offers = TradeOffer::with('village.player')
|
||||
->select('trade_offers.*')
|
||||
->join('villages', 'villages.id', '=', 'trade_offers.village_id')
|
||||
->where('trade_offers.world_id', $village->world_id)
|
||||
->when($give, fn ($q) => $q->where('trade_offers.give_resource', $give))
|
||||
->when($want, fn ($q) => $q->where('trade_offers.want_resource', $want))
|
||||
->orderByRaw('(villages.x - ?) * (villages.x - ?) + (villages.y - ?) * (villages.y - ?)', [$x, $x, $y, $y])
|
||||
->orderBy('trade_offers.id')
|
||||
->limit(self::LIMIT)
|
||||
->get();
|
||||
|
||||
return [
|
||||
'server_time' => MarketPresenter::iso(now()),
|
||||
'offers' => $offers->map(function (TradeOffer $o) use ($village, $rules, $x, $y) {
|
||||
$distance = TravelTime::distance($x, $y, $o->village->x, $o->village->y);
|
||||
|
||||
return [
|
||||
'id' => $o->id,
|
||||
'village' => Rally::summary($o->village),
|
||||
'give' => ['resource' => $o->give_resource, 'amount' => $o->give_amount],
|
||||
'want' => ['resource' => $o->want_resource, 'amount' => $o->want_amount],
|
||||
'count' => $o->count,
|
||||
'distance' => round($distance, 2),
|
||||
'seconds' => $rules->seconds($distance),
|
||||
'own' => $o->village->player_id === $village->player_id,
|
||||
];
|
||||
})->values()->all(),
|
||||
];
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
<?php
|
||||
|
||||
namespace App\Actions;
|
||||
|
||||
use App\Engine\Market;
|
||||
use App\Engine\Simulation;
|
||||
use App\Game\GameRuleViolation;
|
||||
use App\Models\User;
|
||||
use App\Models\Village;
|
||||
use Carbon\CarbonImmutable;
|
||||
|
||||
/** Sending resources, making and taking back offers, and accepting another player's offer. */
|
||||
final class MarketDeals extends VillageAction
|
||||
{
|
||||
/** @param array<string, mixed> $amounts wood, clay, iron */
|
||||
public function send(User $user, int $villageId, int $x, int $y, array $amounts): Village
|
||||
{
|
||||
return $this->mutate($user, $villageId, function (Simulation $sim, Village $village, CarbonImmutable $now) use ($x, $y, $amounts) {
|
||||
$market = Market::of($village, $sim);
|
||||
$market->requireMarket();
|
||||
$market->send(self::target($village, $x, $y), $amounts, $now);
|
||||
});
|
||||
}
|
||||
|
||||
public function offer(User $user, int $villageId, string $give, int $giveAmount, string $want, int $wantAmount, int $count): Village
|
||||
{
|
||||
return $this->mutate($user, $villageId, function (Simulation $sim, Village $village) use ($give, $giveAmount, $want, $wantAmount, $count) {
|
||||
Market::of($village, $sim)->offer($give, $giveAmount, $want, $wantAmount, $count);
|
||||
});
|
||||
}
|
||||
|
||||
public function cancelOffer(User $user, int $villageId, int $offerId): Village
|
||||
{
|
||||
return $this->mutate($user, $villageId, function (Simulation $sim, Village $village) use ($offerId) {
|
||||
Market::of($village, $sim)->cancelOffer($offerId);
|
||||
});
|
||||
}
|
||||
|
||||
public function accept(User $user, int $villageId, int $offerId, int $count): Village
|
||||
{
|
||||
return $this->mutate($user, $villageId, function (Simulation $sim, Village $village, CarbonImmutable $now) use ($offerId, $count) {
|
||||
Market::of($village, $sim)->accept($offerId, $count, $now);
|
||||
});
|
||||
}
|
||||
|
||||
/** The village at x|y on the same world. */
|
||||
public static function target(Village $village, int $x, int $y): Village
|
||||
{
|
||||
return Village::with('player')->where('world_id', $village->world_id)->where('x', $x)->where('y', $y)->first()
|
||||
?? throw new GameRuleViolation('not_found', 'No village there.');
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
<?php
|
||||
|
||||
namespace App\Actions;
|
||||
|
||||
use App\Engine\Market;
|
||||
use App\Engine\Simulation;
|
||||
use App\Models\User;
|
||||
use App\Models\Village;
|
||||
use Carbon\CarbonImmutable;
|
||||
|
||||
/** Trade routes: a shipment from this village repeated every few (real) seconds. */
|
||||
final class MarketRoutes extends VillageAction
|
||||
{
|
||||
/** @param array<string, mixed> $amounts wood, clay, iron */
|
||||
public function create(User $user, int $villageId, int $x, int $y, array $amounts, int $every): Village
|
||||
{
|
||||
return $this->mutate($user, $villageId, function (Simulation $sim, Village $village, CarbonImmutable $now) use ($x, $y, $amounts, $every) {
|
||||
$market = Market::of($village, $sim);
|
||||
$market->requireMarket();
|
||||
$market->createRoute(MarketDeals::target($village, $x, $y), $amounts, $every, $now);
|
||||
});
|
||||
}
|
||||
|
||||
/** @param array{wood?: int|null, clay?: int|null, iron?: int|null, every?: int|null, paused?: bool|null} $changes null leaves a field as it is */
|
||||
public function update(User $user, int $villageId, int $routeId, array $changes): Village
|
||||
{
|
||||
return $this->mutate($user, $villageId, function (Simulation $sim, Village $village, CarbonImmutable $now) use ($routeId, $changes) {
|
||||
Market::of($village, $sim)->updateRoute($routeId, $changes, $now);
|
||||
});
|
||||
}
|
||||
|
||||
public function delete(User $user, int $villageId, int $routeId): Village
|
||||
{
|
||||
return $this->mutate($user, $villageId, function (Simulation $sim, Village $village) use ($routeId) {
|
||||
Market::of($village, $sim)->deleteRoute($routeId);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
<?php
|
||||
|
||||
namespace App\Actions;
|
||||
|
||||
use App\Engine\Market;
|
||||
use App\Engine\Rally;
|
||||
use App\Game\GameRuleViolation;
|
||||
use App\Models\User;
|
||||
use App\Models\Village;
|
||||
use App\Presenters\MarketPresenter;
|
||||
|
||||
/** What the market's send form shows first: the village at x|y, the distance and the merchants' travel time. Changes nothing. */
|
||||
final class PlanTrade
|
||||
{
|
||||
public function __invoke(User $user, int $villageId, int $x, int $y): array
|
||||
{
|
||||
$village = Village::with('player')->find($villageId);
|
||||
if (! $village || $village->player?->user_id !== $user->id) {
|
||||
throw new GameRuleViolation('not_found', 'Village not found.');
|
||||
}
|
||||
$target = Village::with('player')->where('world_id', $village->world_id)->where('x', $x)->where('y', $y)->first()
|
||||
?? throw new GameRuleViolation('not_found', 'No village there.');
|
||||
$market = Market::of($village);
|
||||
$market->checkTarget($target);
|
||||
$plan = $market->plan($target, now()->toImmutable());
|
||||
|
||||
return [
|
||||
'target' => Rally::summary($target),
|
||||
'distance' => round($plan['distance'], 2),
|
||||
'seconds' => $plan['seconds'],
|
||||
'arrives_at' => MarketPresenter::iso($plan['arrives_at']),
|
||||
];
|
||||
}
|
||||
}
|
||||
|
|
@ -15,7 +15,7 @@ final class Reports
|
|||
public const PER_PAGE = 25;
|
||||
|
||||
/**
|
||||
* A page of reports, newest first; `type` keeps one kind (attack, defense, support).
|
||||
* A page of reports, newest first; `type` keeps one kind (attack, defense, support, trade).
|
||||
* The unread count is over every kind.
|
||||
*
|
||||
* @return array{reports: list<array<string, mixed>>, page: int, pages: int, unread: int}
|
||||
|
|
@ -23,7 +23,7 @@ final class Reports
|
|||
public function list(User $user, int $worldId, int $page = 1, ?string $type = null): array
|
||||
{
|
||||
$query = $this->of($user, $worldId)->orderByDesc('happened_at')->orderByDesc('id');
|
||||
if (in_array($type, [Report::ATTACK, Report::DEFENSE, Report::SUPPORT], true)) {
|
||||
if (in_array($type, [Report::ATTACK, Report::DEFENSE, Report::SUPPORT, Report::TRADE], true)) {
|
||||
$query->where('type', $type);
|
||||
}
|
||||
$pages = max(1, (int) ceil($query->count() / self::PER_PAGE));
|
||||
|
|
|
|||
|
|
@ -114,6 +114,7 @@ final class ShowMap
|
|||
|
||||
return Movement::with(['origin:id,name,x,y', 'target:id,name,x,y'])
|
||||
->where('world_id', $world->id)
|
||||
->whereNotIn('type', Movement::TRADES)
|
||||
->where(fn ($q) => $q->where('player_id', $me->id)
|
||||
->orWhere(fn ($q) => $q->whereIn('target_id', $mine)->where('type', '!=', Movement::RETURN)->where('visible_at', '<=', Engine::stamp($now))))
|
||||
->where('arrives_at', '>', Engine::stamp($now))
|
||||
|
|
|
|||
|
|
@ -0,0 +1,20 @@
|
|||
<?php
|
||||
|
||||
namespace App\Actions;
|
||||
|
||||
use App\Models\User;
|
||||
use App\Models\Village;
|
||||
|
||||
/** The village's market as it is now: due arrivals and route runs are caught up first. */
|
||||
final class ShowMarket extends VillageAction
|
||||
{
|
||||
public function __invoke(User $user, int $villageId): Village
|
||||
{
|
||||
return $this->mutate($user, $villageId, fn () => null);
|
||||
}
|
||||
|
||||
protected function readOnly(): bool
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -38,7 +38,7 @@ final class Engine
|
|||
public function catchUpAround(int $villageId, CarbonImmutable $now): void
|
||||
{
|
||||
$targets = Movement::where('origin_id', $villageId)
|
||||
->whereIn('type', [Movement::ATTACK, Movement::SUPPORT])
|
||||
->whereIn('type', [Movement::ATTACK, Movement::SUPPORT, Movement::TRADE])
|
||||
->where('arrives_at', '<=', self::stamp($now))
|
||||
->distinct()->pluck('target_id');
|
||||
foreach ($targets as $target) {
|
||||
|
|
@ -129,6 +129,7 @@ final class Engine
|
|||
// The target starts to see an incoming group; the worker's push is all it takes.
|
||||
GameEvent::MOVEMENT_SPOTTED => null,
|
||||
GameEvent::SUPPORT_RECALLED => Rally::of($village)->sendHome((int) $event->subject_id, $event->fire_at),
|
||||
GameEvent::TRADE_ROUTE => Market::of($village)->runRoute($event),
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,458 @@
|
|||
<?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;
|
||||
use Illuminate\Support\Facades\DB;
|
||||
|
||||
/**
|
||||
* 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 = (int) TradeOffer::where('village_id', $id)->sum(DB::raw('count * 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,
|
||||
]);
|
||||
}
|
||||
}
|
||||
|
|
@ -104,10 +104,12 @@ final class Nobility
|
|||
$village->levy_until = null;
|
||||
$village->starving_since = null;
|
||||
Hospital::clear($village);
|
||||
// Its offers (with the goods they reserved) and its trade routes.
|
||||
Market::release($village);
|
||||
|
||||
// The old owner's commands from here and troops on their way home here.
|
||||
$lost = Movement::where(fn ($q) => $q->where('origin_id', $village->id)->whereIn('type', [Movement::ATTACK, Movement::SUPPORT]))
|
||||
->orWhere(fn ($q) => $q->where('target_id', $village->id)->where('type', Movement::RETURN))
|
||||
// The old owner's commands and merchants from here, and troops and merchants on their way home here.
|
||||
$lost = Movement::where(fn ($q) => $q->where('origin_id', $village->id)->whereIn('type', [Movement::ATTACK, Movement::SUPPORT, Movement::TRADE]))
|
||||
->orWhere(fn ($q) => $q->where('target_id', $village->id)->whereIn('type', [Movement::RETURN, Movement::TRADE_RETURN]))
|
||||
->get();
|
||||
foreach ($lost as $movement) {
|
||||
GameEvent::whereIn('type', [GameEvent::MOVEMENT_ARRIVES, GameEvent::MOVEMENT_SPOTTED])
|
||||
|
|
|
|||
|
|
@ -203,7 +203,7 @@ final class Rally
|
|||
public function cancel(int $movementId, CarbonImmutable $now): void
|
||||
{
|
||||
$movement = Movement::whereKey($movementId)->lockForUpdate()->first();
|
||||
if (! $movement || $movement->origin_id !== $this->village->id || $movement->type === Movement::RETURN) {
|
||||
if (! $movement || $movement->origin_id !== $this->village->id || ! in_array($movement->type, [Movement::ATTACK, Movement::SUPPORT], true)) {
|
||||
throw new GameRuleViolation('not_found', 'No such command.');
|
||||
}
|
||||
if ($now->greaterThan($movement->sent_at->addSeconds($this->cancelWindow())) || ! $movement->arrives_at->greaterThan($now)) {
|
||||
|
|
@ -276,6 +276,7 @@ final class Rally
|
|||
Movement::ATTACK => $this->battle($movement, $at),
|
||||
Movement::SUPPORT => $this->station($movement, $at),
|
||||
Movement::RETURN => $this->homecoming($movement),
|
||||
Movement::TRADE, Movement::TRADE_RETURN => Market::of($this->village, $this->sim)->arrive($movement, $at),
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -38,6 +38,9 @@ class GameEvent extends Model
|
|||
// The owner calls support back: village_id is the host, subject_id the support's home village.
|
||||
public const SUPPORT_RECALLED = 'support.recalled';
|
||||
|
||||
// A trade route sends its next shipment: village_id is where it starts, subject_id the route.
|
||||
public const TRADE_ROUTE = 'trade.route';
|
||||
|
||||
protected $guarded = [];
|
||||
|
||||
protected $dateFormat = 'Y-m-d H:i:s.v';
|
||||
|
|
|
|||
|
|
@ -14,6 +14,14 @@ class Movement extends Model
|
|||
|
||||
public const RETURN = 'return';
|
||||
|
||||
// Merchants with cargo on their way to another village, and empty on their way home.
|
||||
public const TRADE = 'trade';
|
||||
|
||||
public const TRADE_RETURN = 'trade_return';
|
||||
|
||||
/** Merchants, not troops: they never fight and stay out of the rally lists, the map and the noble slots. */
|
||||
public const TRADES = [self::TRADE, self::TRADE_RETURN];
|
||||
|
||||
protected $guarded = [];
|
||||
|
||||
protected $dateFormat = 'Y-m-d H:i:s.v';
|
||||
|
|
@ -24,6 +32,9 @@ class Movement extends Model
|
|||
'units' => 'array',
|
||||
'cargo' => 'array',
|
||||
'rng_seed' => 'integer',
|
||||
'merchants' => 'integer',
|
||||
'route_id' => 'integer',
|
||||
'offer' => 'boolean',
|
||||
'sent_at' => 'immutable_datetime',
|
||||
'arrives_at' => 'immutable_datetime',
|
||||
'visible_at' => 'immutable_datetime',
|
||||
|
|
@ -43,6 +54,6 @@ class Movement extends Model
|
|||
/** Where the troops belong: a return trip goes there, the others start there. */
|
||||
public function homeId(): int
|
||||
{
|
||||
return $this->type === self::RETURN ? $this->target_id : $this->origin_id;
|
||||
return in_array($this->type, [self::RETURN, self::TRADE_RETURN], true) ? $this->target_id : $this->origin_id;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,6 +14,9 @@ class Report extends Model
|
|||
|
||||
public const SUPPORT = 'support';
|
||||
|
||||
// Merchants delivered resources between two players' villages.
|
||||
public const TRADE = 'trade';
|
||||
|
||||
protected $guarded = [];
|
||||
|
||||
protected $dateFormat = 'Y-m-d H:i:s.v';
|
||||
|
|
|
|||
|
|
@ -0,0 +1,30 @@
|
|||
<?php
|
||||
|
||||
namespace App\Models;
|
||||
|
||||
use Illuminate\Database\Eloquent\Model;
|
||||
use Illuminate\Database\Eloquent\Relations\BelongsTo;
|
||||
|
||||
/**
|
||||
* An open offer at a village's market: count times give_amount of one resource for
|
||||
* want_amount of another. The resources and merchants for the open count are reserved.
|
||||
*/
|
||||
class TradeOffer extends Model
|
||||
{
|
||||
protected $guarded = [];
|
||||
|
||||
protected function casts(): array
|
||||
{
|
||||
return [
|
||||
'give_amount' => 'integer',
|
||||
'want_amount' => 'integer',
|
||||
'count' => 'integer',
|
||||
'merchants' => 'integer',
|
||||
];
|
||||
}
|
||||
|
||||
public function village(): BelongsTo
|
||||
{
|
||||
return $this->belongsTo(Village::class);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
<?php
|
||||
|
||||
namespace App\Models;
|
||||
|
||||
use Illuminate\Database\Eloquent\Model;
|
||||
use Illuminate\Database\Eloquent\Relations\BelongsTo;
|
||||
|
||||
/** A shipment from a village repeated every `every` real seconds; a trade.route event at next_at sends it. */
|
||||
class TradeRoute extends Model
|
||||
{
|
||||
public const OWNER_CHANGED = 'owner_changed';
|
||||
|
||||
protected $guarded = [];
|
||||
|
||||
protected $dateFormat = 'Y-m-d H:i:s.v';
|
||||
|
||||
protected function casts(): array
|
||||
{
|
||||
return [
|
||||
'wood' => 'integer',
|
||||
'clay' => 'integer',
|
||||
'iron' => 'integer',
|
||||
'every' => 'integer',
|
||||
'paused' => 'boolean',
|
||||
'next_at' => 'immutable_datetime',
|
||||
'last_sent_at' => 'immutable_datetime',
|
||||
'last_cargo' => 'array',
|
||||
];
|
||||
}
|
||||
|
||||
public function village(): BelongsTo
|
||||
{
|
||||
return $this->belongsTo(Village::class);
|
||||
}
|
||||
|
||||
public function target(): BelongsTo
|
||||
{
|
||||
return $this->belongsTo(Village::class, 'target_id');
|
||||
}
|
||||
|
||||
/** @return array{wood: int, clay: int, iron: int} */
|
||||
public function amounts(): array
|
||||
{
|
||||
return ['wood' => $this->wood, 'clay' => $this->clay, 'iron' => $this->iron];
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,119 @@
|
|||
<?php
|
||||
|
||||
namespace App\Presenters;
|
||||
|
||||
use App\Engine\Market;
|
||||
use App\Engine\Rally;
|
||||
use App\Engine\Simulation;
|
||||
use App\Game\Trade\TradeRules;
|
||||
use App\Models\Movement;
|
||||
use App\Models\TradeOffer;
|
||||
use App\Models\TradeRoute;
|
||||
use App\Models\Village;
|
||||
use Carbon\CarbonImmutable;
|
||||
use DateTimeInterface;
|
||||
|
||||
/** The `market.show` payload, and the market part of `village.show`. */
|
||||
final class MarketPresenter
|
||||
{
|
||||
/**
|
||||
* For the village payload: the market and its merchants, or null without one. Kept
|
||||
* cheap: no market costs no query, a market two sums.
|
||||
*
|
||||
* @return array{building_id: int, level: int, merchants: int, free: int, carry: int}|null
|
||||
*/
|
||||
public static function summary(Village $village, Simulation $sim): ?array
|
||||
{
|
||||
$market = Market::of($village, $sim);
|
||||
$building = $market->building();
|
||||
if (! $building) {
|
||||
return null;
|
||||
}
|
||||
$merchants = $market->merchants();
|
||||
|
||||
return [
|
||||
'building_id' => $building->id,
|
||||
'level' => $building->level,
|
||||
'merchants' => $merchants,
|
||||
'free' => TradeRules::free($merchants, $market->busy()),
|
||||
'carry' => $market->rules()->carry(),
|
||||
];
|
||||
}
|
||||
|
||||
public static function present(Village $village, CarbonImmutable $now): array
|
||||
{
|
||||
$sim = Simulation::of($village);
|
||||
$market = Market::of($village, $sim);
|
||||
$rules = $market->rules();
|
||||
$building = $market->building();
|
||||
$config = $sim->config();
|
||||
$id = $village->id;
|
||||
|
||||
$merchants = $market->merchants();
|
||||
$busy = $building ? $market->busy() : 0;
|
||||
|
||||
return [
|
||||
'server_time' => self::iso($now),
|
||||
'market' => $building ? [
|
||||
'building_id' => $building->id,
|
||||
'level' => $building->level,
|
||||
'merchants' => $merchants,
|
||||
'free' => TradeRules::free($merchants, $busy),
|
||||
'busy' => $busy,
|
||||
'carry' => $rules->carry(),
|
||||
// At this world's speed, like the rest of the payload's durations.
|
||||
'minutes_per_field' => round($rules->minutesPerField() / ($config->speed() * $config->get('movement.unit_speed', 1.0)), 4),
|
||||
'resources' => $rules->resources(),
|
||||
'max_ratio' => $rules->maxRatio(),
|
||||
'route' => ['min_every' => $rules->minEvery(), 'max_every' => $rules->maxEvery(), 'max_routes' => $rules->maxRoutes()],
|
||||
] : null,
|
||||
// out: this village's merchants on the way there; back: on their way home; in:
|
||||
// anyone's merchants coming here with cargo.
|
||||
'trades' => Movement::with(['origin.player', 'target.player'])
|
||||
->where(fn ($q) => $q
|
||||
->where(fn ($q) => $q->where('origin_id', $id)->where('type', Movement::TRADE))
|
||||
->orWhere(fn ($q) => $q->where('target_id', $id)->whereIn('type', Movement::TRADES)))
|
||||
->orderBy('arrives_at')->orderBy('id')
|
||||
->get()
|
||||
->map(fn (Movement $m) => [
|
||||
'id' => $m->id,
|
||||
'kind' => $m->type === Movement::TRADE_RETURN ? 'back' : ($m->origin_id === $id ? 'out' : 'in'),
|
||||
'from' => Rally::summary($m->origin),
|
||||
'to' => Rally::summary($m->target),
|
||||
'cargo' => $m->cargo,
|
||||
'merchants' => $m->merchants,
|
||||
'sent_at' => self::iso($m->sent_at),
|
||||
'arrives_at' => self::iso($m->arrives_at),
|
||||
'route_id' => $m->route_id,
|
||||
'offer' => $m->offer,
|
||||
])->values()->all(),
|
||||
'offers' => TradeOffer::where('village_id', $id)->orderBy('id')->get()
|
||||
->map(fn (TradeOffer $o) => [
|
||||
'id' => $o->id,
|
||||
'give' => ['resource' => $o->give_resource, 'amount' => $o->give_amount],
|
||||
'want' => ['resource' => $o->want_resource, 'amount' => $o->want_amount],
|
||||
'count' => $o->count,
|
||||
// Per unit of count.
|
||||
'merchants' => $o->merchants,
|
||||
'created_at' => self::iso($o->created_at),
|
||||
])->values()->all(),
|
||||
'routes' => TradeRoute::with('target.player')->where('village_id', $id)->orderBy('id')->get()
|
||||
->map(fn (TradeRoute $r) => [
|
||||
'id' => $r->id,
|
||||
'to' => Rally::summary($r->target),
|
||||
'resources' => $r->amounts(),
|
||||
'every' => $r->every,
|
||||
'next_at' => self::iso($r->next_at),
|
||||
'paused' => $r->paused,
|
||||
'paused_reason' => $r->paused_reason,
|
||||
'last_sent_at' => $r->last_sent_at ? self::iso($r->last_sent_at) : null,
|
||||
'last_cargo' => $r->last_cargo,
|
||||
])->values()->all(),
|
||||
];
|
||||
}
|
||||
|
||||
public static function iso(DateTimeInterface $at): string
|
||||
{
|
||||
return CarbonImmutable::instance($at)->utc()->format('Y-m-d\TH:i:s.v\Z');
|
||||
}
|
||||
}
|
||||
|
|
@ -22,6 +22,7 @@ final class RallyPresenter
|
|||
$window = Rally::of($village)->cancelWindow();
|
||||
|
||||
return Movement::with(['origin.player', 'target.player'])
|
||||
->whereNotIn('type', Movement::TRADES)
|
||||
->where(fn ($q) => $q
|
||||
->where(fn ($q) => $q->where('origin_id', $id)->where('type', '!=', Movement::RETURN))
|
||||
->orWhere(fn ($q) => $q->where('target_id', $id)->where('type', Movement::RETURN))
|
||||
|
|
|
|||
|
|
@ -77,6 +77,7 @@ final class VillagePresenter
|
|||
'movements' => RallyPresenter::movements($village, $now),
|
||||
'support' => RallyPresenter::support($village),
|
||||
'rally' => RallyPresenter::rally($village, $now),
|
||||
'market' => MarketPresenter::summary($village, $sim),
|
||||
'loyalty' => (int) floor(Nobility::of($village)->loyalty($village, $now)),
|
||||
'conquest' => self::conquest($village),
|
||||
// The player's villages in this world, for the switcher.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,108 @@
|
|||
<?php
|
||||
|
||||
namespace App\Websocket\Controllers;
|
||||
|
||||
use App\Actions\ListOffers;
|
||||
use App\Actions\MarketDeals;
|
||||
use App\Actions\MarketRoutes;
|
||||
use App\Actions\PlanTrade;
|
||||
use App\Actions\ShowMarket;
|
||||
use App\Presenters\MarketPresenter;
|
||||
use App\Websocket\GameController;
|
||||
use Closure;
|
||||
|
||||
/**
|
||||
* market.show {village_id}; market.preview {village_id, x, y}: target, distance and travel time;
|
||||
* market.offers {village_id, give?, want?}: the world's open offers, nearest first.
|
||||
* market.send {village_id, x, y, wood, clay, iron}, market.offer {village_id, give, want, count},
|
||||
* market.cancelOffer {village_id, offer_id}, market.accept {village_id, offer_id, count},
|
||||
* market.routeCreate {village_id, x, y, wood, clay, iron, every},
|
||||
* market.routeUpdate {village_id, route_id, wood?, clay?, iron?, every?, paused?},
|
||||
* market.routeDelete {village_id, route_id}: each answers with the market.show payload.
|
||||
*/
|
||||
class MarketController extends GameController
|
||||
{
|
||||
public function show()
|
||||
{
|
||||
return $this->market(fn ($user, $id) => app(ShowMarket::class)($user, $id));
|
||||
}
|
||||
|
||||
public function preview()
|
||||
{
|
||||
return $this->play(fn () => app(PlanTrade::class)(auth()->user(), (int) request('village_id'), (int) request('x'), (int) request('y')));
|
||||
}
|
||||
|
||||
public function offers()
|
||||
{
|
||||
return $this->play(fn () => app(ListOffers::class)(
|
||||
auth()->user(),
|
||||
(int) request('village_id'),
|
||||
request('give') ? (string) request('give') : null,
|
||||
request('want') ? (string) request('want') : null,
|
||||
));
|
||||
}
|
||||
|
||||
public function send()
|
||||
{
|
||||
return $this->market(fn ($user, $id) => app(MarketDeals::class)->send($user, $id, (int) request('x'), (int) request('y'), $this->amounts()));
|
||||
}
|
||||
|
||||
public function offer()
|
||||
{
|
||||
$give = (array) request('give', []);
|
||||
$want = (array) request('want', []);
|
||||
|
||||
return $this->market(fn ($user, $id) => app(MarketDeals::class)->offer(
|
||||
$user,
|
||||
$id,
|
||||
(string) ($give['resource'] ?? ''),
|
||||
(int) ($give['amount'] ?? 0),
|
||||
(string) ($want['resource'] ?? ''),
|
||||
(int) ($want['amount'] ?? 0),
|
||||
(int) request('count', 1),
|
||||
));
|
||||
}
|
||||
|
||||
public function cancelOffer()
|
||||
{
|
||||
return $this->market(fn ($user, $id) => app(MarketDeals::class)->cancelOffer($user, $id, (int) request('offer_id')));
|
||||
}
|
||||
|
||||
public function accept()
|
||||
{
|
||||
return $this->market(fn ($user, $id) => app(MarketDeals::class)->accept($user, $id, (int) request('offer_id'), (int) request('count', 1)));
|
||||
}
|
||||
|
||||
public function routeCreate()
|
||||
{
|
||||
return $this->market(fn ($user, $id) => app(MarketRoutes::class)->create($user, $id, (int) request('x'), (int) request('y'), $this->amounts(), (int) request('every')));
|
||||
}
|
||||
|
||||
public function routeUpdate()
|
||||
{
|
||||
$changes = [];
|
||||
foreach (['wood', 'clay', 'iron', 'every'] as $key) {
|
||||
$changes[$key] = request($key) === null ? null : (int) request($key);
|
||||
}
|
||||
$changes['paused'] = request('paused') === null ? null : filter_var(request('paused'), FILTER_VALIDATE_BOOLEAN);
|
||||
|
||||
return $this->market(fn ($user, $id) => app(MarketRoutes::class)->update($user, $id, (int) request('route_id'), $changes));
|
||||
}
|
||||
|
||||
public function routeDelete()
|
||||
{
|
||||
return $this->market(fn ($user, $id) => app(MarketRoutes::class)->delete($user, $id, (int) request('route_id')));
|
||||
}
|
||||
|
||||
/** @return array{wood: int, clay: int, iron: int} */
|
||||
private function amounts(): array
|
||||
{
|
||||
return ['wood' => (int) request('wood', 0), 'clay' => (int) request('clay', 0), 'iron' => (int) request('iron', 0)];
|
||||
}
|
||||
|
||||
/** Runs a market intent and answers with the market as it is afterwards. */
|
||||
private function market(Closure $action)
|
||||
{
|
||||
return $this->play(fn () => MarketPresenter::present($action(auth()->user(), (int) request('village_id')), now()->toImmutable()));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
<?php
|
||||
|
||||
use Illuminate\Database\Migrations\Migration;
|
||||
use Illuminate\Database\Schema\Blueprint;
|
||||
use Illuminate\Support\Facades\Schema;
|
||||
|
||||
// The market: merchants under way are movements, open offers and trade routes have their own rows.
|
||||
return new class extends Migration
|
||||
{
|
||||
public function up(): void
|
||||
{
|
||||
Schema::table('movements', function (Blueprint $table) {
|
||||
// Merchants on a trade or trade_return; 0 for troops.
|
||||
$table->unsignedInteger('merchants')->default(0);
|
||||
// The trade route that sent them, if one did (no foreign key: the trip outlives a deleted route).
|
||||
$table->unsignedBigInteger('route_id')->nullable();
|
||||
// Sent for an accepted offer.
|
||||
$table->boolean('offer')->default(false);
|
||||
});
|
||||
|
||||
// An open offer: count times give_amount of give_resource for want_amount of
|
||||
// want_resource. The resources and merchants for the open count are reserved.
|
||||
Schema::create('trade_offers', function (Blueprint $table) {
|
||||
$table->id();
|
||||
$table->foreignId('world_id')->constrained()->cascadeOnDelete();
|
||||
$table->foreignId('village_id')->constrained()->cascadeOnDelete();
|
||||
$table->string('give_resource', 8);
|
||||
$table->unsignedInteger('give_amount');
|
||||
$table->string('want_resource', 8);
|
||||
$table->unsignedInteger('want_amount');
|
||||
$table->unsignedInteger('count');
|
||||
// Reserved per unit of count: ceil(give_amount / carry) when it was made.
|
||||
$table->unsignedInteger('merchants');
|
||||
$table->timestamps();
|
||||
$table->index(['world_id', 'give_resource', 'want_resource']);
|
||||
});
|
||||
|
||||
// A shipment repeated every `every` real seconds; a trade.route event at next_at sends it.
|
||||
Schema::create('trade_routes', function (Blueprint $table) {
|
||||
$table->id();
|
||||
$table->foreignId('village_id')->constrained()->cascadeOnDelete();
|
||||
$table->foreignId('target_id')->constrained('villages')->cascadeOnDelete();
|
||||
// The target's owner when the route was made; another owner pauses the route. No
|
||||
// foreign key, so a deleted player still counts as a change.
|
||||
$table->unsignedBigInteger('target_player_id')->nullable();
|
||||
$table->unsignedInteger('wood')->default(0);
|
||||
$table->unsignedInteger('clay')->default(0);
|
||||
$table->unsignedInteger('iron')->default(0);
|
||||
$table->unsignedInteger('every');
|
||||
$table->dateTime('next_at', 3);
|
||||
$table->boolean('paused')->default(false);
|
||||
$table->string('paused_reason', 32)->nullable();
|
||||
$table->dateTime('last_sent_at', 3)->nullable();
|
||||
$table->json('last_cargo')->nullable();
|
||||
$table->timestamps();
|
||||
});
|
||||
}
|
||||
|
||||
public function down(): void
|
||||
{
|
||||
Schema::dropIfExists('trade_routes');
|
||||
Schema::dropIfExists('trade_offers');
|
||||
Schema::table('movements', function (Blueprint $table) {
|
||||
$table->dropColumn(['merchants', 'route_id', 'offer']);
|
||||
});
|
||||
}
|
||||
};
|
||||
Loading…
Reference in New Issue