665 lines
24 KiB
PHP
665 lines
24 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace sammo;
|
|
|
|
use sammo\Enums\RankColumn;
|
|
|
|
if (PHP_SAPI !== 'cli') {
|
|
http_response_code(404);
|
|
exit;
|
|
}
|
|
|
|
chdir(dirname(__DIR__));
|
|
$_SERVER['REMOTE_ADDR'] ??= '127.0.0.1';
|
|
error_reporting(E_ALL & ~E_DEPRECATED);
|
|
require_once 'lib.php';
|
|
require_once 'func.php';
|
|
require_once __DIR__ . '/turn_state_snapshot.php';
|
|
|
|
final class TurnComparisonTracingRNG implements RNG
|
|
{
|
|
private int $sequence = 0;
|
|
|
|
/** @var list<array<string, mixed>> */
|
|
public array $calls = [];
|
|
|
|
public function __construct(private readonly RNG $inner)
|
|
{
|
|
}
|
|
|
|
public static function getMaxInt(): int
|
|
{
|
|
return LiteHashDRBG::getMaxInt();
|
|
}
|
|
|
|
public function nextBytes(int $bytes): string
|
|
{
|
|
$value = $this->inner->nextBytes($bytes);
|
|
$this->record('nextBytes', ['bytes' => $bytes], bin2hex($value));
|
|
return $value;
|
|
}
|
|
|
|
public function nextBits(int $bits): string
|
|
{
|
|
$value = $this->inner->nextBits($bits);
|
|
$this->record('nextBits', ['bits' => $bits], bin2hex($value));
|
|
return $value;
|
|
}
|
|
|
|
public function nextInt(?int $max = null): int
|
|
{
|
|
$value = $this->inner->nextInt($max);
|
|
$this->record('nextInt', ['maxInclusive' => $max], $value);
|
|
return $value;
|
|
}
|
|
|
|
public function nextFloat1(): float
|
|
{
|
|
$value = $this->inner->nextFloat1();
|
|
$this->record('nextFloat1', [], $value);
|
|
return $value;
|
|
}
|
|
|
|
private function record(string $operation, array $arguments, mixed $result): void
|
|
{
|
|
$this->calls[] = [
|
|
'seq' => $this->sequence++,
|
|
'operation' => $operation,
|
|
'arguments' => $arguments === [] ? (object)[] : $arguments,
|
|
'result' => $result,
|
|
];
|
|
}
|
|
}
|
|
|
|
/** @return array<string, mixed> */
|
|
function comparisonMappedPatch(array $row, array $mapping): array
|
|
{
|
|
$patch = [];
|
|
foreach ($mapping as $canonical => $legacy) {
|
|
if (array_key_exists($canonical, $row)) {
|
|
$patch[$legacy] = $row[$canonical];
|
|
}
|
|
}
|
|
return $patch;
|
|
}
|
|
|
|
function comparisonApplyTurnFixtureSetup(mixed $setup): void
|
|
{
|
|
if ($setup === null) {
|
|
return;
|
|
}
|
|
if (!is_array($setup)) {
|
|
throw new \InvalidArgumentException('setup must be an object');
|
|
}
|
|
$db = DB::db();
|
|
$world = $setup['world'] ?? null;
|
|
if ($world !== null) {
|
|
if (!is_array($world)) {
|
|
throw new \InvalidArgumentException('setup.world must be an object');
|
|
}
|
|
$game = KVStorage::getStorage($db, 'game_env');
|
|
foreach (['year', 'month', 'startyear', 'init_year', 'init_month'] as $key) {
|
|
$fixtureKey = match ($key) {
|
|
'startyear' => 'startYear',
|
|
'init_year' => 'initYear',
|
|
'init_month' => 'initMonth',
|
|
default => $key,
|
|
};
|
|
if (!array_key_exists($fixtureKey, $world)) {
|
|
continue;
|
|
}
|
|
$value = $world[$fixtureKey];
|
|
if (
|
|
!is_int($value)
|
|
|| $value < 1
|
|
|| (in_array($key, ['month', 'init_month'], true) && $value > 12)
|
|
) {
|
|
throw new \InvalidArgumentException("setup.world.{$fixtureKey} is invalid");
|
|
}
|
|
$game->setValue($key, $value);
|
|
}
|
|
$game->resetCache();
|
|
if (array_key_exists('hiddenSeed', $world)) {
|
|
$hiddenSeed = $world['hiddenSeed'];
|
|
if (!is_string($hiddenSeed) || $hiddenSeed === '' || strlen($hiddenSeed) > 256) {
|
|
throw new \InvalidArgumentException('setup.world.hiddenSeed is invalid');
|
|
}
|
|
UniqueConst::$hiddenSeed = $hiddenSeed;
|
|
}
|
|
}
|
|
|
|
foreach (['nations', 'cities', 'generals', 'troops', 'diplomacy'] as $collection) {
|
|
if (isset($setup[$collection]) && !is_array($setup[$collection])) {
|
|
throw new \InvalidArgumentException("setup.{$collection} must be an array");
|
|
}
|
|
}
|
|
$generalCooldowns = comparisonGeneralCooldownSelectors(
|
|
$setup['generalCooldowns'] ?? [],
|
|
'setup.generalCooldowns',
|
|
);
|
|
if ($generalCooldowns !== []) {
|
|
$nextExecuteStorage = KVStorage::getStorage($db, 'next_execute');
|
|
foreach ($setup['generalCooldowns'] as $entry) {
|
|
$nextAvailableTurn = $entry['nextAvailableTurn'] ?? null;
|
|
if (!is_int($nextAvailableTurn) || $nextAvailableTurn < 0) {
|
|
throw new \InvalidArgumentException(
|
|
'setup.generalCooldowns entries require a non-negative nextAvailableTurn',
|
|
);
|
|
}
|
|
$key = "next_execute_{$entry['generalId']}_{$entry['actionName']}";
|
|
$nextExecuteStorage->setValue($key, $nextAvailableTurn);
|
|
}
|
|
$nextExecuteStorage->resetCache();
|
|
}
|
|
if (isset($setup['randomFoundingCandidateCityIds'])) {
|
|
$candidateCityIds = comparisonIntegerList(
|
|
$setup['randomFoundingCandidateCityIds'],
|
|
'randomFoundingCandidateCityIds',
|
|
);
|
|
$db->update('city', ['level' => 4], '1 = 1');
|
|
if ($candidateCityIds !== []) {
|
|
$db->update('city', ['level' => 5], 'city IN %li', $candidateCityIds);
|
|
}
|
|
}
|
|
|
|
if (($setup['isolateWorld'] ?? false) === true) {
|
|
$generalIds = array_values(array_map(
|
|
static fn(array $row): int => (int)$row['id'],
|
|
$setup['generals'] ?? [],
|
|
));
|
|
$nationIds = array_values(array_map(
|
|
static fn(array $row): int => (int)$row['id'],
|
|
$setup['nations'] ?? [],
|
|
));
|
|
if ($generalIds === [] || $nationIds === []) {
|
|
throw new \InvalidArgumentException('isolateWorld requires generals and nations');
|
|
}
|
|
$generalTemplate = $db->queryFirstRow(
|
|
'SELECT * FROM general WHERE no IN %li ORDER BY no LIMIT 1',
|
|
$generalIds,
|
|
);
|
|
if ($generalTemplate === null) {
|
|
throw new \InvalidArgumentException('isolateWorld requires at least one existing fixture general');
|
|
}
|
|
$generalTemplateId = (int)$generalTemplate['no'];
|
|
$rankDataTemplate = $db->query(
|
|
'SELECT `type`, `value` FROM rank_data WHERE general_id = %i',
|
|
$generalTemplateId,
|
|
);
|
|
$db->delete('general_turn', 'general_id NOT IN %li', $generalIds);
|
|
$db->delete('rank_data', 'general_id NOT IN %li', $generalIds);
|
|
$db->delete('nation_turn', 'nation_id NOT IN %li', $nationIds);
|
|
$db->delete('troop', '1 = 1');
|
|
$db->delete('diplomacy', '1 = 1');
|
|
$db->delete('general', 'no NOT IN %li', $generalIds);
|
|
foreach ($generalIds as $generalId) {
|
|
if ($db->queryFirstField('SELECT no FROM general WHERE no = %i', $generalId) !== null) {
|
|
continue;
|
|
}
|
|
$newGeneral = $generalTemplate;
|
|
$newGeneral['no'] = $generalId;
|
|
$newGeneral['owner'] = 0;
|
|
$newGeneral['name'] = "fixture-general-{$generalId}";
|
|
$db->insert('general', $newGeneral);
|
|
}
|
|
foreach ($generalIds as $generalId) {
|
|
foreach ($rankDataTemplate as $rankRow) {
|
|
$rankData = [
|
|
'general_id' => $generalId,
|
|
'type' => $rankRow['type'],
|
|
'value' => $rankRow['value'],
|
|
];
|
|
$db->insertUpdate('rank_data', $rankData, $rankData);
|
|
}
|
|
}
|
|
$db->delete('nation', 'nation NOT IN %li', $nationIds);
|
|
$db->update('city', [
|
|
'nation' => 0,
|
|
'supply' => 0,
|
|
'front' => 0,
|
|
'state' => 0,
|
|
'term' => 0,
|
|
'conflict' => '{}',
|
|
'officer_set' => 0,
|
|
], '1 = 1');
|
|
}
|
|
|
|
foreach ($setup['nations'] ?? [] as $row) {
|
|
if (!is_array($row) || !is_int($row['id'] ?? null) || $row['id'] < 1) {
|
|
throw new \InvalidArgumentException('setup.nations requires positive integer ids');
|
|
}
|
|
$data = comparisonMappedPatch($row, [
|
|
'id' => 'nation',
|
|
'name' => 'name',
|
|
'color' => 'color',
|
|
'capitalCityId' => 'capital',
|
|
'gold' => 'gold',
|
|
'rice' => 'rice',
|
|
'tech' => 'tech',
|
|
'level' => 'level',
|
|
'typeCode' => 'type',
|
|
'war' => 'war',
|
|
'diplomacyLimit' => 'surlimit',
|
|
'generalCount' => 'gennum',
|
|
'power' => 'power',
|
|
'capitalRevision' => 'capset',
|
|
'strategicCommandLimit' => 'strategic_cmd_limit',
|
|
]);
|
|
if (isset($row['meta'])) {
|
|
$data['aux'] = Json::encode($row['meta']);
|
|
}
|
|
$data += [
|
|
'name' => "fixture-nation-{$row['id']}",
|
|
'color' => '#777777',
|
|
'capital' => 0,
|
|
'gold' => 0,
|
|
'rice' => 0,
|
|
'level' => 1,
|
|
'type' => 'che_중립',
|
|
'aux' => '{}',
|
|
];
|
|
$db->insertUpdate('nation', $data, $data);
|
|
$nationStor = KVStorage::getStorage($db, $row['id'], 'nation_env');
|
|
if (($setup['isolateWorld'] ?? false) === true) {
|
|
$nationStor->deleteValue('recv_assist');
|
|
$nationStor->deleteValue('resp_assist');
|
|
}
|
|
if (array_key_exists('nationEnv', $row)) {
|
|
if (!is_array($row['nationEnv'])) {
|
|
throw new \InvalidArgumentException('setup.nations.nationEnv must be an object');
|
|
}
|
|
foreach ($row['nationEnv'] as $key => $value) {
|
|
if (!is_string($key) || $key === '') {
|
|
throw new \InvalidArgumentException('setup.nations.nationEnv keys must be non-empty strings');
|
|
}
|
|
$nationStor->setValue($key, $value);
|
|
}
|
|
$nationStor->resetCache();
|
|
}
|
|
if (array_key_exists('turnLastByOfficerLevel', $row)) {
|
|
$turnLastByOfficerLevel = $row['turnLastByOfficerLevel'];
|
|
if (!is_array($turnLastByOfficerLevel)) {
|
|
throw new \InvalidArgumentException('setup.nations.turnLastByOfficerLevel must be an object');
|
|
}
|
|
foreach ($turnLastByOfficerLevel as $officerLevel => $lastTurn) {
|
|
$officerLevel = filter_var($officerLevel, FILTER_VALIDATE_INT);
|
|
if (
|
|
$officerLevel === false
|
|
|| $officerLevel < 5
|
|
|| $officerLevel > 12
|
|
|| !is_array($lastTurn)
|
|
) {
|
|
throw new \InvalidArgumentException(
|
|
'setup.nations.turnLastByOfficerLevel requires officer levels 5 through 12'
|
|
);
|
|
}
|
|
$nationStor->setValue("turn_last_{$officerLevel}", $lastTurn);
|
|
}
|
|
$nationStor->resetCache();
|
|
}
|
|
}
|
|
if (($setup['isolateWorld'] ?? false) === true && ($setup['nations'] ?? []) !== []) {
|
|
$maxNationId = max(array_map(
|
|
static fn(array $row): int => (int)$row['id'],
|
|
$setup['nations'],
|
|
));
|
|
$db->query('ALTER TABLE nation AUTO_INCREMENT = %i', $maxNationId + 1);
|
|
}
|
|
|
|
foreach ($setup['cities'] ?? [] as $row) {
|
|
if (!is_array($row) || !is_int($row['id'] ?? null) || $row['id'] < 1) {
|
|
throw new \InvalidArgumentException('setup.cities requires positive integer ids');
|
|
}
|
|
$patch = comparisonMappedPatch($row, [
|
|
'nationId' => 'nation',
|
|
'level' => 'level',
|
|
'population' => 'pop',
|
|
'populationMax' => 'pop_max',
|
|
'agriculture' => 'agri',
|
|
'agricultureMax' => 'agri_max',
|
|
'commerce' => 'comm',
|
|
'commerceMax' => 'comm_max',
|
|
'security' => 'secu',
|
|
'securityMax' => 'secu_max',
|
|
'supplyState' => 'supply',
|
|
'frontState' => 'front',
|
|
'defence' => 'def',
|
|
'defenceMax' => 'def_max',
|
|
'wall' => 'wall',
|
|
'wallMax' => 'wall_max',
|
|
'state' => 'state',
|
|
'term' => 'term',
|
|
'trust' => 'trust',
|
|
'trade' => 'trade',
|
|
'officerSet' => 'officer_set',
|
|
]);
|
|
if (array_key_exists('conflict', $row)) {
|
|
if (!is_array($row['conflict'])) {
|
|
throw new \InvalidArgumentException('setup.cities.conflict must be an object');
|
|
}
|
|
$patch['conflict'] = Json::encode($row['conflict']);
|
|
}
|
|
if ($patch !== []) {
|
|
$db->update('city', $patch, 'city = %i', $row['id']);
|
|
}
|
|
}
|
|
|
|
foreach ($setup['generals'] ?? [] as $row) {
|
|
if (!is_array($row) || !is_int($row['id'] ?? null) || $row['id'] < 1) {
|
|
throw new \InvalidArgumentException('setup.generals requires positive integer ids');
|
|
}
|
|
$patch = comparisonMappedPatch($row, [
|
|
'name' => 'name',
|
|
'nationId' => 'nation',
|
|
'cityId' => 'city',
|
|
'troopId' => 'troop',
|
|
'leadership' => 'leadership',
|
|
'strength' => 'strength',
|
|
'intelligence' => 'intel',
|
|
'leadershipExp' => 'leadership_exp',
|
|
'strengthExp' => 'strength_exp',
|
|
'intelExp' => 'intel_exp',
|
|
'experience' => 'experience',
|
|
'dedication' => 'dedication',
|
|
'expLevel' => 'explevel',
|
|
'officerLevel' => 'officer_level',
|
|
'officerCityId' => 'officer_city',
|
|
'belong' => 'belong',
|
|
'permission' => 'permission',
|
|
'betray' => 'betray',
|
|
'makeLimit' => 'makelimit',
|
|
'injury' => 'injury',
|
|
'age' => 'age',
|
|
'gold' => 'gold',
|
|
'rice' => 'rice',
|
|
'crew' => 'crew',
|
|
'crewTypeId' => 'crewtype',
|
|
'train' => 'train',
|
|
'atmos' => 'atmos',
|
|
'dex1' => 'dex1',
|
|
'dex2' => 'dex2',
|
|
'dex3' => 'dex3',
|
|
'dex4' => 'dex4',
|
|
'dex5' => 'dex5',
|
|
'specAge' => 'specage',
|
|
'specAge2' => 'specage2',
|
|
'killTurn' => 'killturn',
|
|
'npcState' => 'npc',
|
|
'blockState' => 'block',
|
|
'specialDomestic' => 'special',
|
|
'specialWar' => 'special2',
|
|
'personality' => 'personal',
|
|
'itemHorse' => 'horse',
|
|
'itemWeapon' => 'weapon',
|
|
'itemBook' => 'book',
|
|
'itemExtra' => 'item',
|
|
]);
|
|
if (isset($row['meta'])) {
|
|
$patch['aux'] = Json::encode($row['meta']);
|
|
}
|
|
if (array_key_exists('penalty', $row)) {
|
|
if (!is_array($row['penalty'])) {
|
|
throw new \InvalidArgumentException('setup.generals.penalty must be an object');
|
|
}
|
|
$patch['penalty'] = Json::encode($row['penalty']);
|
|
}
|
|
if (isset($row['lastTurn']) && is_array($row['lastTurn'])) {
|
|
$patch['last_turn'] = Json::encode($row['lastTurn']);
|
|
}
|
|
if ($patch !== []) {
|
|
$db->update('general', $patch, 'no = %i', $row['id']);
|
|
}
|
|
if (array_key_exists('nationId', $row)) {
|
|
$db->update('rank_data', [
|
|
'nation_id' => $row['nationId'],
|
|
], 'general_id = %i', $row['id']);
|
|
}
|
|
}
|
|
foreach ($setup['rankData'] ?? [] as $row) {
|
|
if (
|
|
!is_array($row)
|
|
|| !is_int($row['generalId'] ?? null)
|
|
|| !is_string($row['type'] ?? null)
|
|
|| RankColumn::tryFrom($row['type']) === null
|
|
|| !is_int($row['value'] ?? null)
|
|
) {
|
|
throw new \InvalidArgumentException('invalid setup.rankData row');
|
|
}
|
|
$nationId = (int)($db->queryFirstField(
|
|
'SELECT nation FROM general WHERE no = %i',
|
|
$row['generalId'],
|
|
) ?? 0);
|
|
$db->insertUpdate('rank_data', [
|
|
'general_id' => $row['generalId'],
|
|
'nation_id' => $nationId,
|
|
'type' => $row['type'],
|
|
'value' => $row['value'],
|
|
], [
|
|
'nation_id' => $nationId,
|
|
'value' => $row['value'],
|
|
]);
|
|
}
|
|
if (($setup['isolateWorld'] ?? false) === true && ($setup['generals'] ?? []) !== []) {
|
|
$maxGeneralId = max(array_map(
|
|
static fn(array $row): int => (int)$row['id'],
|
|
$setup['generals'],
|
|
));
|
|
$db->query('ALTER TABLE general AUTO_INCREMENT = %i', $maxGeneralId + 1);
|
|
}
|
|
|
|
foreach ($setup['troops'] ?? [] as $row) {
|
|
if (
|
|
!is_array($row)
|
|
|| !is_int($row['id'] ?? null)
|
|
|| !is_int($row['nationId'] ?? null)
|
|
|| !is_string($row['name'] ?? null)
|
|
|| $row['id'] < 1
|
|
|| $row['nationId'] < 1
|
|
|| $row['name'] === ''
|
|
) {
|
|
throw new \InvalidArgumentException('setup.troops requires positive id/nationId and non-empty name');
|
|
}
|
|
$data = [
|
|
'troop_leader' => $row['id'],
|
|
'nation' => $row['nationId'],
|
|
'name' => $row['name'],
|
|
];
|
|
$db->insertUpdate('troop', $data, $data);
|
|
}
|
|
|
|
foreach ($setup['diplomacy'] ?? [] as $row) {
|
|
if (
|
|
!is_array($row) ||
|
|
!is_int($row['fromNationId'] ?? null) ||
|
|
!is_int($row['toNationId'] ?? null) ||
|
|
$row['fromNationId'] < 1 ||
|
|
$row['toNationId'] < 1
|
|
) {
|
|
throw new \InvalidArgumentException('setup.diplomacy requires positive integer nation ids');
|
|
}
|
|
$data = comparisonMappedPatch($row, [
|
|
'fromNationId' => 'me',
|
|
'toNationId' => 'you',
|
|
'state' => 'state',
|
|
'term' => 'term',
|
|
'dead' => 'dead',
|
|
]);
|
|
$data += ['state' => 3, 'term' => 0, 'dead' => 0];
|
|
$db->insertUpdate('diplomacy', $data, $data);
|
|
}
|
|
}
|
|
|
|
function comparisonRunTurnCommand(array $request): array
|
|
{
|
|
if (getenv('TURN_DIFFERENTIAL_ENABLED') !== '1') {
|
|
throw new \RuntimeException('TURN_DIFFERENTIAL_ENABLED=1 is required');
|
|
}
|
|
$kind = $request['kind'] ?? null;
|
|
if (!in_array($kind, ['general', 'nation', 'instantNation'], true)) {
|
|
throw new \InvalidArgumentException('kind must be general, nation, or instantNation');
|
|
}
|
|
$actorGeneralId = $request['actorGeneralId'] ?? null;
|
|
$action = $request['action'] ?? null;
|
|
$args = $request['args'] ?? null;
|
|
if (!is_int($actorGeneralId) || $actorGeneralId < 1) {
|
|
throw new \InvalidArgumentException('actorGeneralId must be a positive integer');
|
|
}
|
|
if (!is_string($action) || $action === '') {
|
|
throw new \InvalidArgumentException('action must be a non-empty string');
|
|
}
|
|
|
|
comparisonApplyTurnFixtureSetup($request['setup'] ?? null);
|
|
$snapshotRequest = ['observe' => $request['observe'] ?? []];
|
|
$before = comparisonTurnStateSnapshot($snapshotRequest);
|
|
$db = DB::db();
|
|
$gameStorage = KVStorage::getStorage($db, 'game_env');
|
|
$gameStorage->resetCache();
|
|
$environment = $gameStorage->getAll();
|
|
$general = General::createObjFromDB($actorGeneralId);
|
|
if ($kind === 'instantNation') {
|
|
$command = buildNationCommandClass($action, $general, $environment, new LastTurn(), $args);
|
|
if (!$command->hasFullConditionMet()) {
|
|
throw new \RuntimeException($command->getFailString());
|
|
}
|
|
$completed = $command->run(NoRNG::rngInstance());
|
|
$command->setNextAvailable();
|
|
$general->getLogger()->flush();
|
|
$after = comparisonTurnStateSnapshot($snapshotRequest);
|
|
|
|
return [
|
|
'schemaVersion' => 1,
|
|
'engine' => 'ref',
|
|
'execution' => [
|
|
'kind' => $kind,
|
|
'actorGeneralId' => $actorGeneralId,
|
|
'action' => $action,
|
|
'args' => $args,
|
|
'seedDomain' => 'none',
|
|
'outcome' => [
|
|
'lastTurn' => (object)[],
|
|
'commandName' => $command->getName(),
|
|
'completed' => $completed,
|
|
],
|
|
],
|
|
'before' => $before,
|
|
'after' => $after,
|
|
'rng' => [],
|
|
];
|
|
}
|
|
$turn = new TurnExecutionHelper($general);
|
|
$general->increaseInheritancePoint(Enums\InheritanceKey::lived_month, 1);
|
|
$preprocessRng = new RandUtil(new LiteHashDRBG(Util::simpleSerialize(
|
|
UniqueConst::$hiddenSeed,
|
|
'preprocess',
|
|
(int)$environment['year'],
|
|
(int)$environment['month'],
|
|
$actorGeneralId,
|
|
)));
|
|
$turn->preprocessCommand($preprocessRng, $environment);
|
|
$seedDomain = $kind === 'general' ? 'generalCommand' : 'nationCommand';
|
|
$seed = Util::simpleSerialize(
|
|
UniqueConst::$hiddenSeed,
|
|
$seedDomain,
|
|
(int)$environment['year'],
|
|
(int)$environment['month'],
|
|
$actorGeneralId,
|
|
$action,
|
|
);
|
|
$tracingRng = new TurnComparisonTracingRNG(new LiteHashDRBG($seed));
|
|
$rng = new RandUtil($tracingRng);
|
|
if ($kind === 'general' && $action === 'che_견문') {
|
|
\sammo\TextDecoration\SightseeingMessage::setComparisonRng($rng);
|
|
}
|
|
|
|
if ($kind === 'general') {
|
|
$previousLastTurn = $general->getLastTurn();
|
|
$previousLastTurnRaw = $previousLastTurn->toRaw();
|
|
$command = buildGeneralCommandClass($action, $general, $environment, $args);
|
|
$commandFullConditionMet = $command->hasFullConditionMet();
|
|
$resultTurn = $turn->processCommand($rng, $command, false);
|
|
} else {
|
|
$nationStor = KVStorage::getStorage($db, $general->getNationID(), 'nation_env');
|
|
$lastNationTurnKey = "turn_last_{$general->getVar('officer_level')}";
|
|
$previousLastTurn = LastTurn::fromRaw($nationStor->getValue($lastNationTurnKey));
|
|
$previousLastTurnRaw = $previousLastTurn->toRaw();
|
|
$command = buildNationCommandClass($action, $general, $environment, $previousLastTurn, $args);
|
|
$commandFullConditionMet = $command->hasFullConditionMet();
|
|
$resultTurn = $turn->processNationCommand($rng, $command);
|
|
$nationStor->setValue($lastNationTurnKey, $resultTurn->toRaw());
|
|
}
|
|
|
|
$general->getLogger()->flush();
|
|
$turn->applyDB();
|
|
unset($turn);
|
|
$after = comparisonTurnStateSnapshot($snapshotRequest);
|
|
$resultTurnRaw = $resultTurn->toRaw();
|
|
$resultTerm = (int)($resultTurnRaw['term'] ?? 0);
|
|
$preReqTurn = $command->getPreReqTurn();
|
|
$acceptScoutCompleted = (
|
|
$action === 'che_등용수락'
|
|
&& is_array($args)
|
|
&& is_int($args['destNationID'] ?? null)
|
|
&& $general->getNationID() === $args['destNationID']
|
|
);
|
|
$foundNationCompleted = (
|
|
in_array($action, ['che_건국', 'cr_건국', 'che_무작위건국'], true)
|
|
&& is_array($args)
|
|
&& is_string($args['nationName'] ?? null)
|
|
&& DB::db()->queryFirstField(
|
|
'SELECT name FROM nation WHERE nation = %i',
|
|
$general->getNationID(),
|
|
) === $args['nationName']
|
|
);
|
|
$completedByState = (
|
|
$action === 'che_접경귀환'
|
|
&& $tracingRng->calls !== []
|
|
) || $acceptScoutCompleted || $foundNationCompleted || (($resultTurnRaw['command'] ?? null) === $command->getName()
|
|
&& (
|
|
($preReqTurn === 0 && $resultTerm === 0)
|
|
|| (
|
|
$preReqTurn > 0
|
|
&& ($previousLastTurnRaw['command'] ?? null) === $command->getName()
|
|
&& ($previousLastTurnRaw['arg'] ?? null) === $command->getArg()
|
|
&& (int)($previousLastTurnRaw['term'] ?? 0) === $preReqTurn
|
|
)
|
|
));
|
|
$completed = $commandFullConditionMet && $completedByState;
|
|
|
|
return [
|
|
'schemaVersion' => 1,
|
|
'engine' => 'ref',
|
|
'execution' => [
|
|
'kind' => $kind,
|
|
'actorGeneralId' => $actorGeneralId,
|
|
'action' => $action,
|
|
'args' => $args,
|
|
'seedDomain' => $seedDomain,
|
|
'outcome' => [
|
|
'lastTurn' => $resultTurnRaw,
|
|
'commandName' => $command->getName(),
|
|
'completed' => $completed,
|
|
],
|
|
],
|
|
'before' => $before,
|
|
'after' => $after,
|
|
'rng' => $tracingRng->calls,
|
|
];
|
|
}
|
|
|
|
try {
|
|
$input = stream_get_contents(STDIN);
|
|
$request = json_decode($input === '' ? '{}' : $input, true, flags: JSON_THROW_ON_ERROR);
|
|
if (!is_array($request)) {
|
|
throw new \InvalidArgumentException('request must be an object');
|
|
}
|
|
echo json_encode(
|
|
comparisonRunTurnCommand($request),
|
|
JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION,
|
|
), PHP_EOL;
|
|
} catch (\Throwable $throwable) {
|
|
fwrite(STDERR, $throwable::class . ': ' . $throwable->getMessage() . PHP_EOL);
|
|
exit(1);
|
|
}
|