1580 lines
66 KiB
PHP
1580 lines
66 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace sammo;
|
|
|
|
if (PHP_SAPI !== 'cli' || getenv('TURN_DIFFERENTIAL_ENABLED') !== '1') {
|
|
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';
|
|
|
|
/** @param array<string, mixed> $values */
|
|
function comparisonMonthlyPatch(string $table, int $id, array $values): void
|
|
{
|
|
$definitions = [
|
|
'city' => [
|
|
'idColumn' => 'city',
|
|
'allowed' => [
|
|
'name', 'level', 'nation', 'supply', 'front', 'pop', 'pop_max',
|
|
'agri', 'agri_max', 'comm', 'comm_max', 'secu', 'secu_max',
|
|
'trust', 'trade', 'def', 'def_max', 'wall', 'wall_max',
|
|
'officer_set', 'state', 'region', 'term', 'conflict', 'dead',
|
|
],
|
|
],
|
|
'nation' => [
|
|
'idColumn' => 'nation',
|
|
'allowed' => [
|
|
'name', 'color', 'capital', 'gennum', 'gold', 'rice', 'tech',
|
|
'power', 'level', 'type', 'bill', 'rate_tmp', 'scout', 'chief_set', 'aux',
|
|
'rate', 'strategic_cmd_limit', 'surlimit', 'spy',
|
|
],
|
|
],
|
|
'general' => [
|
|
'idColumn' => 'no',
|
|
'allowed' => [
|
|
'name', 'nation', 'city', 'officer_level', 'officer_city',
|
|
'crew', 'train', 'atmos', 'owner', 'npc', 'killturn', 'belong',
|
|
'gold', 'rice', 'horse', 'weapon', 'book', 'item', 'aux',
|
|
'leadership', 'strength', 'intel', 'experience', 'dedication',
|
|
'injury',
|
|
'dex1', 'dex2', 'dex3', 'dex4', 'dex5', 'personal', 'special',
|
|
'specage', 'special2', 'specage2', 'betray', 'age',
|
|
'bornyear', 'deadyear', 'turntime', 'makelimit',
|
|
],
|
|
],
|
|
];
|
|
$definition = $definitions[$table] ?? null;
|
|
if ($definition === null) {
|
|
throw new \InvalidArgumentException("unsupported setup table: {$table}");
|
|
}
|
|
$patch = [];
|
|
foreach ($values as $key => $value) {
|
|
if (!is_string($key) || !in_array($key, $definition['allowed'], true)) {
|
|
throw new \InvalidArgumentException("unsupported {$table} setup field");
|
|
}
|
|
if (in_array($key, ['conflict', 'aux'], true) && is_array($value)) {
|
|
$value = json_encode($value, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE);
|
|
}
|
|
$patch[$key] = $value;
|
|
}
|
|
if ($table === 'nation') {
|
|
$patch += [
|
|
'nation' => $id,
|
|
'name' => "fixture-nation-{$id}",
|
|
'color' => '#777777',
|
|
'capital' => 0,
|
|
'gold' => 0,
|
|
'rice' => 0,
|
|
'level' => 1,
|
|
'type' => 'che_중립',
|
|
'aux' => '{}',
|
|
];
|
|
DB::db()->insertUpdate('nation', $patch, $patch);
|
|
} elseif ($patch !== []) {
|
|
DB::db()->update($table, $patch, "`{$definition['idColumn']}` = %i", $id);
|
|
}
|
|
}
|
|
|
|
/** @param array<string, mixed> $observe */
|
|
function comparisonMonthlyDetails(array $observe, int $worldHistoryAfterId): array
|
|
{
|
|
$db = DB::db();
|
|
$generals = array_map(
|
|
static fn(array $row): array => comparisonPickRow(
|
|
$row,
|
|
[
|
|
'id' => 'no',
|
|
'nationId' => 'nation',
|
|
'cityId' => 'city',
|
|
'officerLevel' => 'officer_level',
|
|
'officerCityId' => 'officer_city',
|
|
'crew' => 'crew',
|
|
'train' => 'train',
|
|
'atmos' => 'atmos',
|
|
'gold' => 'gold',
|
|
'rice' => 'rice',
|
|
'injury' => 'injury',
|
|
'leadership' => 'leadership',
|
|
'strength' => 'strength',
|
|
'intelligence' => 'intel',
|
|
'age' => 'age',
|
|
'specialDomestic' => 'special',
|
|
'specAge' => 'specage',
|
|
'specialWar' => 'special2',
|
|
'specAge2' => 'specage2',
|
|
'betray' => 'betray',
|
|
'makeLimit' => 'makelimit',
|
|
'horse' => 'horse',
|
|
'weapon' => 'weapon',
|
|
'book' => 'book',
|
|
'item' => 'item',
|
|
'dex1' => 'dex1',
|
|
'dex2' => 'dex2',
|
|
'dex3' => 'dex3',
|
|
'dex4' => 'dex4',
|
|
'dex5' => 'dex5',
|
|
'aux' => 'aux',
|
|
],
|
|
['aux'],
|
|
),
|
|
comparisonRowsById('general', 'no', comparisonIntegerList($observe['generalIds'] ?? [], 'generalIds')),
|
|
);
|
|
$cities = array_map(
|
|
static fn(array $row): array => comparisonPickRow(
|
|
$row,
|
|
[
|
|
'id' => 'city',
|
|
'nationId' => 'nation',
|
|
'state' => 'state',
|
|
'supplyState' => 'supply',
|
|
'frontState' => 'front',
|
|
'officerSet' => 'officer_set',
|
|
'term' => 'term',
|
|
'dead' => 'dead',
|
|
'population' => 'pop',
|
|
'populationMax' => 'pop_max',
|
|
'agriculture' => 'agri',
|
|
'agricultureMax' => 'agri_max',
|
|
'commerce' => 'comm',
|
|
'commerceMax' => 'comm_max',
|
|
'security' => 'secu',
|
|
'securityMax' => 'secu_max',
|
|
'trust' => 'trust',
|
|
'trade' => 'trade',
|
|
'defence' => 'def',
|
|
'defenceMax' => 'def_max',
|
|
'wall' => 'wall',
|
|
'wallMax' => 'wall_max',
|
|
'conflict' => 'conflict',
|
|
],
|
|
['conflict'],
|
|
),
|
|
comparisonRowsById('city', 'city', comparisonIntegerList($observe['cityIds'] ?? [], 'cityIds')),
|
|
);
|
|
$nations = array_map(
|
|
static fn(array $row): array => comparisonPickRow(
|
|
$row,
|
|
[
|
|
'id' => 'nation',
|
|
'gold' => 'gold',
|
|
'rice' => 'rice',
|
|
'rate' => 'rate_tmp',
|
|
'baseRate' => 'rate',
|
|
'power' => 'power',
|
|
'generalCount' => 'gennum',
|
|
'tech' => 'tech',
|
|
'typeCode' => 'type',
|
|
'scout' => 'scout',
|
|
'strategicCommandLimit' => 'strategic_cmd_limit',
|
|
'surrenderLimit' => 'surlimit',
|
|
'spy' => 'spy',
|
|
'chiefSet' => 'chief_set',
|
|
],
|
|
['spy'],
|
|
),
|
|
comparisonRowsById('nation', 'nation', comparisonIntegerList($observe['nationIds'] ?? [], 'nationIds')),
|
|
);
|
|
$worldHistory = array_map(
|
|
static fn(array $row): array => comparisonPickRow(
|
|
$row,
|
|
[
|
|
'id' => 'id',
|
|
'nationId' => 'nation_id',
|
|
'year' => 'year',
|
|
'month' => 'month',
|
|
'text' => 'text',
|
|
],
|
|
),
|
|
$db->query(
|
|
'SELECT id, nation_id, year, month, text FROM world_history WHERE id > %i ORDER BY id',
|
|
$worldHistoryAfterId,
|
|
),
|
|
);
|
|
$inheritanceKeys = $observe['inheritanceKeys'] ?? ['unifier'];
|
|
if (!is_array($inheritanceKeys) || array_filter($inheritanceKeys, static fn($key): bool => !is_string($key))) {
|
|
throw new \InvalidArgumentException('inheritanceKeys must be an array of strings');
|
|
}
|
|
$inheritancePoints = [];
|
|
foreach (comparisonIntegerList($observe['ownerIds'] ?? [], 'ownerIds') as $ownerId) {
|
|
$entry = ['ownerId' => $ownerId];
|
|
foreach ($inheritanceKeys as $key) {
|
|
$value = $db->queryFirstField(
|
|
'SELECT value FROM storage WHERE namespace = %s AND `key` = %s',
|
|
"inheritance_{$ownerId}",
|
|
$key,
|
|
);
|
|
$entry[$key] = $value === null ? 0 : (comparisonJsonValue($value)[0] ?? 0);
|
|
}
|
|
$inheritancePoints[] = $entry;
|
|
}
|
|
$rankGeneralIds = comparisonIntegerList($observe['rankGeneralIds'] ?? [], 'rankGeneralIds');
|
|
$rankTypes = $observe['rankTypes'] ?? [];
|
|
if (!is_array($rankTypes) || array_filter($rankTypes, static fn($type): bool => !is_string($type))) {
|
|
throw new \InvalidArgumentException('rankTypes must be an array of strings');
|
|
}
|
|
$rankData = (!$rankGeneralIds || !$rankTypes)
|
|
? []
|
|
: iterator_to_array($db->query(
|
|
'SELECT general_id AS generalId, nation_id AS nationId, `type`, `value` FROM rank_data WHERE general_id IN %li AND `type` IN %ls ORDER BY general_id, `type`',
|
|
$rankGeneralIds,
|
|
$rankTypes,
|
|
));
|
|
$generalAccessLogs = [];
|
|
$accessGeneralIds = comparisonIntegerList($observe['accessGeneralIds'] ?? [], 'accessGeneralIds');
|
|
if ($accessGeneralIds) {
|
|
$generalAccessLogs = iterator_to_array($db->query(
|
|
'SELECT general_id AS generalId, refresh_score_total AS refreshScoreTotal FROM general_access_log WHERE general_id IN %li ORDER BY general_id',
|
|
$accessGeneralIds,
|
|
));
|
|
}
|
|
$nationEnvironment = [];
|
|
$nationEnvironmentKeys = $observe['nationEnvironmentKeys'] ?? [];
|
|
if (
|
|
!is_array($nationEnvironmentKeys)
|
|
|| array_filter($nationEnvironmentKeys, static fn($key): bool => !is_string($key))
|
|
) {
|
|
throw new \InvalidArgumentException('nationEnvironmentKeys must be an array of strings');
|
|
}
|
|
foreach (comparisonIntegerList($observe['nationIds'] ?? [], 'nationIds') as $nationId) {
|
|
$entry = ['nationId' => $nationId];
|
|
$storage = KVStorage::getStorage($db, $nationId, 'nation_env');
|
|
foreach ($nationEnvironmentKeys as $key) {
|
|
$entry[$key] = $storage->getValue($key);
|
|
}
|
|
$nationEnvironment[] = $entry;
|
|
}
|
|
return [
|
|
'generals' => $generals,
|
|
'cities' => $cities,
|
|
'nations' => $nations,
|
|
'worldHistory' => $worldHistory,
|
|
'inheritancePoints' => $inheritancePoints,
|
|
'rankData' => $rankData,
|
|
'generalAccessLogs' => $generalAccessLogs,
|
|
'nationEnvironment' => $nationEnvironment,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Exercise the dynamically-created invader events against one evolving database.
|
|
*
|
|
* @param array<string, mixed> $request
|
|
* @param array<string, mixed> $environment
|
|
* @return array<string, mixed>
|
|
*/
|
|
function comparisonInvaderLifecycleTrace(
|
|
array $request,
|
|
array $environment,
|
|
int $generalIdBeforeAction,
|
|
int $nationIdBeforeAction,
|
|
int $eventIdBeforeAction,
|
|
int $worldHistoryIdBeforeAction,
|
|
): array {
|
|
$db = DB::db();
|
|
$args = $request['args'] ?? [];
|
|
if (!is_array($args) || count($args) > 4) {
|
|
throw new \InvalidArgumentException('InvaderLifecycle args must have at most four entries');
|
|
}
|
|
$year = $environment['year'];
|
|
$month = $environment['month'];
|
|
$startYear = $environment['startyear'];
|
|
$raiseEnvironment = [
|
|
'year' => $year,
|
|
'month' => $month,
|
|
'startyear' => $startYear,
|
|
'turnterm' => $environment['turnterm'],
|
|
'turntime' => $environment['turntime'],
|
|
'show_img_level' => $environment['show_img_level'] ?? 3,
|
|
'stored_icons' => $environment['stored_icons'] ?? [],
|
|
'icon_path' => $environment['icon_path'] ?? '.',
|
|
'fiction' => $environment['fiction'] ?? [0],
|
|
];
|
|
|
|
(new \sammo\Event\Action\RaiseInvader(...$args))->run($raiseEnvironment);
|
|
|
|
$invaderNationIds = array_map(
|
|
'intval',
|
|
$db->queryFirstColumn('SELECT nation FROM nation WHERE nation > %i ORDER BY nation', $nationIdBeforeAction),
|
|
);
|
|
$existingNationId = (int)$db->queryFirstField(
|
|
'SELECT nation FROM nation WHERE nation <= %i ORDER BY nation LIMIT 1',
|
|
$nationIdBeforeAction,
|
|
);
|
|
$rulerIds = array_map(
|
|
'intval',
|
|
$db->queryFirstColumn(
|
|
'SELECT no FROM general WHERE nation IN %li AND officer_level = 12 ORDER BY nation',
|
|
$invaderNationIds,
|
|
),
|
|
);
|
|
if ($invaderNationIds === [] || $existingNationId <= 0 || count($rulerIds) !== count($invaderNationIds)) {
|
|
throw new \RuntimeException('InvaderLifecycle failed to create the expected entities');
|
|
}
|
|
|
|
$autoDeleteEvents = [];
|
|
$endingEventId = 0;
|
|
foreach ($db->query('SELECT id, action FROM event WHERE id > %i ORDER BY id', $eventIdBeforeAction) as $row) {
|
|
$action = comparisonJsonValue($row['action']);
|
|
$actionName = $action[0][0] ?? null;
|
|
if ($actionName === 'AutoDeleteInvader') {
|
|
$autoDeleteEvents[] = [
|
|
'eventId' => (int)$row['id'],
|
|
'nationId' => (int)($action[0][1] ?? 0),
|
|
];
|
|
} elseif ($actionName === 'InvaderEnding') {
|
|
$endingEventId = (int)$row['id'];
|
|
}
|
|
}
|
|
if (count($autoDeleteEvents) !== count($invaderNationIds) || $endingEventId <= 0) {
|
|
throw new \RuntimeException('InvaderLifecycle failed to create follow-up events');
|
|
}
|
|
|
|
$diplomacyRows = iterator_to_array($db->query(
|
|
'SELECT me, you, state, term FROM diplomacy WHERE (me IN %li AND you = %i) OR (me = %i AND you IN %li) ORDER BY me, you',
|
|
$invaderNationIds,
|
|
$existingNationId,
|
|
$existingNationId,
|
|
$invaderNationIds,
|
|
));
|
|
$diplomacyStates = array_values(array_unique(array_map(
|
|
static fn(array $row): string => "{$row['state']}:{$row['term']}",
|
|
$diplomacyRows,
|
|
)));
|
|
sort($diplomacyStates);
|
|
$generalCounts = array_map(
|
|
static fn(int $nationId): int => (int)DB::db()->queryFirstField(
|
|
'SELECT count(*) FROM general WHERE nation = %i',
|
|
$nationId,
|
|
),
|
|
$invaderNationIds,
|
|
);
|
|
$diplomacyCounts = array_map(
|
|
static fn(int $nationId): int => (int)DB::db()->queryFirstField(
|
|
'SELECT count(*) FROM diplomacy WHERE (me = %i AND you = %i) OR (me = %i AND you = %i)',
|
|
$nationId,
|
|
$existingNationId,
|
|
$existingNationId,
|
|
$nationId,
|
|
),
|
|
$invaderNationIds,
|
|
);
|
|
$gameStorage = KVStorage::getStorage($db, 'game_env');
|
|
$afterRaise = [
|
|
'createdNationCount' => count($invaderNationIds),
|
|
'createdGeneralCount' => (int)$db->queryFirstField(
|
|
'SELECT count(*) FROM general WHERE no > %i',
|
|
$generalIdBeforeAction,
|
|
),
|
|
'followUpEventCount' => (int)$db->queryFirstField(
|
|
'SELECT count(*) FROM event WHERE id > %i',
|
|
$eventIdBeforeAction,
|
|
),
|
|
'generalCountsPerNation' => array_values(array_unique($generalCounts)),
|
|
'diplomacyCountsPerNation' => array_values(array_unique($diplomacyCounts)),
|
|
'diplomacyStates' => $diplomacyStates,
|
|
'isunited' => (int)$gameStorage->isunited,
|
|
'blockChangeScout' => (bool)$gameStorage->block_change_scout,
|
|
];
|
|
|
|
$warResults = [];
|
|
foreach ($autoDeleteEvents as $autoDeleteEvent) {
|
|
$warResult = (new \sammo\Event\Action\AutoDeleteInvader($autoDeleteEvent['nationId']))->run([
|
|
'year' => $year,
|
|
'month' => $month + 1,
|
|
'startyear' => $startYear,
|
|
'currentEventID' => $autoDeleteEvent['eventId'],
|
|
]);
|
|
$warResults[] = $warResult[1] ?? null;
|
|
}
|
|
$atWar = [
|
|
'results' => array_values(array_unique($warResults)),
|
|
'autoDeleteEventCount' => (int)$db->queryFirstField(
|
|
'SELECT count(*) FROM event WHERE id IN %li',
|
|
array_column($autoDeleteEvents, 'eventId'),
|
|
),
|
|
];
|
|
|
|
$db->update(
|
|
'diplomacy',
|
|
['state' => 2, 'term' => 0],
|
|
'me IN %li OR you IN %li',
|
|
$invaderNationIds,
|
|
$invaderNationIds,
|
|
);
|
|
$peaceResults = [];
|
|
foreach ($autoDeleteEvents as $autoDeleteEvent) {
|
|
$peaceResult = (new \sammo\Event\Action\AutoDeleteInvader($autoDeleteEvent['nationId']))->run([
|
|
'year' => $year,
|
|
'month' => $month + 2,
|
|
'startyear' => $startYear,
|
|
'currentEventID' => $autoDeleteEvent['eventId'],
|
|
]);
|
|
$peaceResults[] = $peaceResult[1] ?? null;
|
|
}
|
|
$atPeace = [
|
|
'results' => array_values(array_unique($peaceResults)),
|
|
'autoDeleteEventCount' => (int)$db->queryFirstField(
|
|
'SELECT count(*) FROM event WHERE id IN %li',
|
|
array_column($autoDeleteEvents, 'eventId'),
|
|
),
|
|
'rulerWanderTurnCount' => (int)$db->queryFirstField(
|
|
'SELECT count(*) FROM general_turn WHERE general_id IN %li AND action = %s',
|
|
$rulerIds,
|
|
'che_방랑',
|
|
),
|
|
'endingEventPresent' => (bool)$db->queryFirstField(
|
|
'SELECT count(*) FROM event WHERE id = %i',
|
|
$endingEventId,
|
|
),
|
|
];
|
|
|
|
$invaderGeneralIds = array_map('intval', $db->queryFirstColumn(
|
|
'SELECT no FROM general WHERE nation IN %li',
|
|
$invaderNationIds,
|
|
));
|
|
if ($invaderGeneralIds !== []) {
|
|
$db->delete('general_turn', 'general_id IN %li', $invaderGeneralIds);
|
|
$db->delete('rank_data', 'general_id IN %li', $invaderGeneralIds);
|
|
$db->delete('troop', 'nation IN %li', $invaderNationIds);
|
|
$db->delete('general', 'no IN %li', $invaderGeneralIds);
|
|
}
|
|
$db->delete('nation_turn', 'nation_id IN %li', $invaderNationIds);
|
|
$db->delete('diplomacy', 'me IN %li OR you IN %li', $invaderNationIds, $invaderNationIds);
|
|
$db->delete('nation', 'nation IN %li', $invaderNationIds);
|
|
$db->update('city', ['nation' => $existingNationId], true);
|
|
|
|
$endingResult = (new \sammo\Event\Action\InvaderEnding())->run([
|
|
'year' => $year,
|
|
'month' => $month + 3,
|
|
'startyear' => $startYear,
|
|
'currentEventID' => $endingEventId,
|
|
]);
|
|
$gameStorage->resetCache();
|
|
$afterUserWin = [
|
|
'result' => $endingResult[1] ?? null,
|
|
'endingEventPresent' => (bool)$db->queryFirstField(
|
|
'SELECT count(*) FROM event WHERE id = %i',
|
|
$endingEventId,
|
|
),
|
|
'isunited' => (int)$gameStorage->isunited,
|
|
'refreshLimit' => (int)$gameStorage->refreshLimit,
|
|
'logs' => array_values($db->queryFirstColumn(
|
|
'SELECT text FROM world_history WHERE id > %i AND nation_id = 0 AND year = %i AND month = %i ORDER BY id',
|
|
$worldHistoryIdBeforeAction,
|
|
$year,
|
|
$month + 3,
|
|
)),
|
|
];
|
|
|
|
return [
|
|
'schemaVersion' => 1,
|
|
'engine' => 'ref',
|
|
'action' => 'InvaderLifecycle',
|
|
'phases' => [
|
|
'afterRaise' => $afterRaise,
|
|
'atWar' => $atWar,
|
|
'atPeace' => $atPeace,
|
|
'afterUserWin' => $afterUserWin,
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Exercise NPC nation creation and the same-month troop leader follow-up.
|
|
*
|
|
* @param array<string, mixed> $environment
|
|
* @return array<string, mixed>
|
|
*/
|
|
function comparisonNpcNationLifecycleTrace(
|
|
array $environment,
|
|
int $generalIdBeforeAction,
|
|
int $nationIdBeforeAction,
|
|
int $worldHistoryIdBeforeAction,
|
|
): array {
|
|
$db = DB::db();
|
|
$actionEnvironment = [
|
|
'year' => $environment['year'],
|
|
'month' => $environment['month'],
|
|
'startyear' => $environment['startyear'],
|
|
'turnterm' => $environment['turnterm'],
|
|
'turntime' => $environment['turntime'],
|
|
'show_img_level' => $environment['show_img_level'] ?? 3,
|
|
'stored_icons' => $environment['stored_icons'] ?? [],
|
|
'icon_path' => $environment['icon_path'] ?? '.',
|
|
'fiction' => $environment['fiction'] ?? [0],
|
|
];
|
|
$gameStorage = KVStorage::getStorage($db, 'game_env');
|
|
$leaderCounterBefore = (int)($gameStorage->lastNPCTroopLeaderID ?? 0);
|
|
|
|
(new \sammo\Event\Action\RaiseNPCNation())->run($actionEnvironment);
|
|
$createdNationIds = array_map(
|
|
'intval',
|
|
$db->queryFirstColumn('SELECT nation FROM nation WHERE nation > %i ORDER BY nation', $nationIdBeforeAction),
|
|
);
|
|
if ($createdNationIds === []) {
|
|
throw new \RuntimeException('NpcNationLifecycle failed to create a nation');
|
|
}
|
|
$createdNationGeneralCounts = array_map(
|
|
static fn(int $nationId): int => (int)DB::db()->queryFirstField(
|
|
'SELECT count(*) FROM general WHERE nation = %i',
|
|
$nationId,
|
|
),
|
|
$createdNationIds,
|
|
);
|
|
$afterRaise = [
|
|
'createdNationCount' => count($createdNationIds),
|
|
'createdGeneralCount' => (int)$db->queryFirstField(
|
|
'SELECT count(*) FROM general WHERE no > %i',
|
|
$generalIdBeforeAction,
|
|
),
|
|
'generalCountsPerCreatedNation' => array_values(array_unique($createdNationGeneralCounts)),
|
|
'historyLogs' => array_values($db->queryFirstColumn(
|
|
'SELECT text FROM world_history WHERE id > %i AND nation_id = 0 ORDER BY id',
|
|
$worldHistoryIdBeforeAction,
|
|
)),
|
|
];
|
|
|
|
(new \sammo\Event\Action\ProvideNPCTroopLeader())->run($actionEnvironment);
|
|
$leaderIds = array_map(
|
|
'intval',
|
|
$db->queryFirstColumn('SELECT no FROM general WHERE no > %i AND npc = 5 ORDER BY no', $generalIdBeforeAction),
|
|
);
|
|
if ($leaderIds === []) {
|
|
throw new \RuntimeException('NpcNationLifecycle failed to create troop leaders');
|
|
}
|
|
$leaderNationCounts = array_map(
|
|
static fn(int $nationId): int => (int)DB::db()->queryFirstField(
|
|
'SELECT count(*) FROM general WHERE nation = %i AND npc = 5',
|
|
$nationId,
|
|
),
|
|
array_map(
|
|
'intval',
|
|
$db->queryFirstColumn('SELECT nation FROM nation WHERE level > 0 ORDER BY nation'),
|
|
),
|
|
);
|
|
$gatherTurnCounts = array_map(
|
|
static fn(int $generalId): int => (int)DB::db()->queryFirstField(
|
|
'SELECT count(*) FROM general_turn WHERE general_id = %i AND action = %s',
|
|
$generalId,
|
|
'che_집합',
|
|
),
|
|
$leaderIds,
|
|
);
|
|
$gameStorage->resetCache();
|
|
$afterProvide = [
|
|
'createdLeaderCount' => count($leaderIds),
|
|
'leaderCountsPerActiveNation' => array_values(array_unique($leaderNationCounts)),
|
|
'troopCount' => (int)$db->queryFirstField(
|
|
'SELECT count(*) FROM troop WHERE troop_leader IN %li',
|
|
$leaderIds,
|
|
),
|
|
'gatherTurnCounts' => array_values(array_unique($gatherTurnCounts)),
|
|
'leaderCounterDelta' => (int)$gameStorage->lastNPCTroopLeaderID - $leaderCounterBefore,
|
|
];
|
|
|
|
return [
|
|
'schemaVersion' => 1,
|
|
'engine' => 'ref',
|
|
'action' => 'NpcNationLifecycle',
|
|
'phases' => [
|
|
'afterRaise' => $afterRaise,
|
|
'afterProvide' => $afterProvide,
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Exercise nation betting from monthly open through real user bets and settlement.
|
|
*
|
|
* @param array<string, mixed> $request
|
|
* @param array<string, mixed> $environment
|
|
* @return array<string, mixed>
|
|
*/
|
|
function comparisonNationBettingLifecycleTrace(
|
|
array $request,
|
|
array $environment,
|
|
int $eventIdBeforeAction,
|
|
int $worldHistoryIdBeforeAction,
|
|
): array {
|
|
$db = DB::db();
|
|
$args = $request['args'] ?? [];
|
|
if (!is_array($args) || count($args) > 2) {
|
|
throw new \InvalidArgumentException('NationBettingLifecycle args must have at most two entries');
|
|
}
|
|
$bettorGeneralIds = comparisonIntegerList(
|
|
$request['bettorGeneralIds'] ?? [],
|
|
'bettorGeneralIds',
|
|
);
|
|
$bettorOwnerIds = comparisonIntegerList(
|
|
$request['bettorOwnerIds'] ?? [],
|
|
'bettorOwnerIds',
|
|
);
|
|
if (count($bettorGeneralIds) !== 2 || count($bettorOwnerIds) !== 2) {
|
|
throw new \InvalidArgumentException(
|
|
'NationBettingLifecycle requires exactly two bettorGeneralIds and bettorOwnerIds',
|
|
);
|
|
}
|
|
|
|
$year = $environment['year'];
|
|
$month = $environment['month'];
|
|
$startYear = $environment['startyear'];
|
|
(new \sammo\Event\Action\OpenNationBetting(...$args))->run([
|
|
'year' => $year,
|
|
'month' => $month,
|
|
'startyear' => $startYear,
|
|
]);
|
|
|
|
$gameStorage = KVStorage::getStorage($db, 'game_env');
|
|
$gameStorage->resetCache();
|
|
$bettingId = (int)$gameStorage->last_betting_id;
|
|
$betting = new Betting($bettingId);
|
|
$bettingInfo = $betting->getInfo();
|
|
$candidateNationIds = array_map(
|
|
static fn(\sammo\DTO\SelectItem $candidate): int => (int)($candidate->aux['nation'] ?? 0),
|
|
$bettingInfo->candidates,
|
|
);
|
|
if (count($candidateNationIds) !== 2) {
|
|
throw new \RuntimeException('NationBettingLifecycle requires exactly two candidates');
|
|
}
|
|
|
|
$finishEventCount = (int)$db->queryFirstField(
|
|
'SELECT count(*) FROM event WHERE id > %i AND action LIKE %s',
|
|
$eventIdBeforeAction,
|
|
"%FinishNationBetting%{$bettingId}%",
|
|
);
|
|
$afterOpen = [
|
|
'bettingId' => $bettingId,
|
|
'candidateNationIds' => $candidateNationIds,
|
|
'systemBonus' => (int)($db->queryFirstField(
|
|
'SELECT amount FROM ng_betting WHERE betting_id = %i AND general_id = 0',
|
|
$bettingId,
|
|
) ?? 0),
|
|
'finishEventCount' => $finishEventCount,
|
|
'historyLogs' => array_values($db->queryFirstColumn(
|
|
'SELECT text FROM world_history WHERE id > %i AND nation_id = 0 ORDER BY id',
|
|
$worldHistoryIdBeforeAction,
|
|
)),
|
|
];
|
|
|
|
$betting->bet($bettorGeneralIds[0], $bettorOwnerIds[0], [1], 100);
|
|
$betting->bet($bettorGeneralIds[1], $bettorOwnerIds[1], [0], 100);
|
|
$afterBets = [
|
|
'bets' => array_map(
|
|
static fn(array $row): array => [
|
|
'generalId' => (int)$row['general_id'],
|
|
'ownerId' => $row['user_id'] === null ? null : (int)$row['user_id'],
|
|
'selectionKey' => $row['betting_type'],
|
|
'amount' => (int)$row['amount'],
|
|
],
|
|
iterator_to_array($db->query(
|
|
'SELECT general_id, user_id, betting_type, amount FROM ng_betting WHERE betting_id = %i ORDER BY general_id',
|
|
$bettingId,
|
|
)),
|
|
),
|
|
'inheritancePrevious' => array_map(
|
|
static function (int $ownerId): int {
|
|
$value = KVStorage::getStorage(DB::db(), "inheritance_{$ownerId}")->getValue('previous');
|
|
return is_array($value) ? (int)($value[0] ?? 0) : 0;
|
|
},
|
|
$bettorOwnerIds,
|
|
),
|
|
'spentRank' => array_map(
|
|
static fn(int $generalId): int => (int)(DB::db()->queryFirstField(
|
|
'SELECT value FROM rank_data WHERE general_id = %i AND type = %s',
|
|
$generalId,
|
|
\sammo\Enums\RankColumn::inherit_point_spent_dynamic->value,
|
|
) ?? 0),
|
|
$bettorGeneralIds,
|
|
),
|
|
];
|
|
|
|
$db->update('nation', ['level' => 0], 'nation = %i', $candidateNationIds[1]);
|
|
$finishResult = (new \sammo\Event\Action\FinishNationBetting($bettingId))->run([
|
|
'year' => $year,
|
|
'month' => $month + 1,
|
|
'startyear' => $startYear,
|
|
]);
|
|
$settledInfo = (new Betting($bettingId))->getInfo();
|
|
$afterFinish = [
|
|
'result' => $finishResult[1] ?? null,
|
|
'finished' => $settledInfo->finished,
|
|
'winner' => $settledInfo->winner,
|
|
'inheritancePrevious' => array_map(
|
|
static function (int $ownerId): int {
|
|
$value = KVStorage::getStorage(DB::db(), "inheritance_{$ownerId}")->getValue('previous');
|
|
return is_array($value) ? (int)($value[0] ?? 0) : 0;
|
|
},
|
|
$bettorOwnerIds,
|
|
),
|
|
'earnedRank' => array_map(
|
|
static fn(int $generalId): int => (int)(DB::db()->queryFirstField(
|
|
'SELECT value FROM rank_data WHERE general_id = %i AND type = %s',
|
|
$generalId,
|
|
\sammo\Enums\RankColumn::inherit_point_earned_by_action->value,
|
|
) ?? 0),
|
|
$bettorGeneralIds,
|
|
),
|
|
'historyLogs' => array_values($db->queryFirstColumn(
|
|
'SELECT text FROM world_history WHERE id > %i AND nation_id = 0 ORDER BY id',
|
|
$worldHistoryIdBeforeAction,
|
|
)),
|
|
];
|
|
|
|
return [
|
|
'schemaVersion' => 1,
|
|
'engine' => 'ref',
|
|
'action' => 'NationBettingLifecycle',
|
|
'phases' => [
|
|
'afterOpen' => $afterOpen,
|
|
'afterBets' => $afterBets,
|
|
'afterFinish' => $afterFinish,
|
|
],
|
|
];
|
|
}
|
|
|
|
function comparisonMonthlyEventTraceMain(): void
|
|
{
|
|
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');
|
|
}
|
|
$actionName = $request['action'] ?? null;
|
|
$supportedActions = [
|
|
'UpdateCitySupply',
|
|
'UpdateNationLevel',
|
|
'RaiseDisaster',
|
|
'ProcessSemiAnnual',
|
|
'ProcessWarIncome',
|
|
'CreateAdminNPC',
|
|
'CreateManyNPC',
|
|
'RegNPC',
|
|
'RegNeutralNPC',
|
|
'RaiseNPCNation',
|
|
'NpcNationLifecycle',
|
|
'RaiseInvader',
|
|
'InvaderLifecycle',
|
|
'AutoDeleteInvader',
|
|
'InvaderEnding',
|
|
'ChangeCity',
|
|
'ProvideNPCTroopLeader',
|
|
'NationBettingLifecycle',
|
|
'OpenNationBetting',
|
|
'FinishNationBetting',
|
|
'BlockScoutAction',
|
|
'UnblockScoutAction',
|
|
'AssignGeneralSpeciality',
|
|
'AddGlobalBetray',
|
|
'LostUniqueItem',
|
|
'MergeInheritPointRank',
|
|
'ProcessIncome',
|
|
'NoticeToHistoryLog',
|
|
'NewYear',
|
|
'ResetOfficerLock',
|
|
'PreUpdateMonthly',
|
|
'PostUpdateMonthly',
|
|
'MonthlyBoundary',
|
|
];
|
|
if (!in_array($actionName, $supportedActions, true)) {
|
|
throw new \InvalidArgumentException('unsupported monthly action');
|
|
}
|
|
$setup = $request['setup'] ?? [];
|
|
if (!is_array($setup)) {
|
|
throw new \InvalidArgumentException('setup must be an object');
|
|
}
|
|
foreach (['city', 'nation', 'general'] as $table) {
|
|
$rows = $setup[$table] ?? [];
|
|
if (!is_array($rows)) {
|
|
throw new \InvalidArgumentException("setup.{$table} must be an array");
|
|
}
|
|
foreach ($rows as $row) {
|
|
if (!is_array($row) || !is_int($row['id'] ?? null) || !is_array($row['values'] ?? null)) {
|
|
throw new \InvalidArgumentException("invalid setup.{$table} row");
|
|
}
|
|
comparisonMonthlyPatch($table, $row['id'], $row['values']);
|
|
}
|
|
}
|
|
if (($setup['resetCities'] ?? false) === true) {
|
|
DB::db()->query('UPDATE city SET nation = 0, level = 1');
|
|
foreach ($setup['city'] ?? [] as $row) {
|
|
comparisonMonthlyPatch('city', $row['id'], $row['values']);
|
|
}
|
|
}
|
|
if (($setup['deleteOtherCities'] ?? false) === true) {
|
|
$keepCityIds = comparisonIntegerList($setup['keepCityIds'] ?? [], 'keepCityIds');
|
|
if ($keepCityIds === []) {
|
|
throw new \InvalidArgumentException('deleteOtherCities requires keepCityIds');
|
|
}
|
|
DB::db()->query('DELETE FROM city WHERE city NOT IN %li', $keepCityIds);
|
|
}
|
|
if (($setup['resetGenerals'] ?? false) === true) {
|
|
DB::db()->query(
|
|
'UPDATE general SET nation = 0, officer_level = 1, npc = 2, killturn = 0, horse = %s, weapon = %s, book = %s, item = %s',
|
|
'None',
|
|
'None',
|
|
'None',
|
|
'None',
|
|
);
|
|
foreach ($setup['general'] ?? [] as $row) {
|
|
comparisonMonthlyPatch('general', $row['id'], $row['values']);
|
|
}
|
|
}
|
|
if (($setup['deleteOtherGenerals'] ?? false) === true) {
|
|
$keepGeneralIds = comparisonIntegerList($setup['keepGeneralIds'] ?? [], 'keepGeneralIds');
|
|
if (!$keepGeneralIds) {
|
|
throw new \InvalidArgumentException('deleteOtherGenerals requires keepGeneralIds');
|
|
}
|
|
DB::db()->query('DELETE FROM general_turn WHERE general_id NOT IN %li', $keepGeneralIds);
|
|
DB::db()->query('DELETE FROM rank_data WHERE general_id NOT IN %li', $keepGeneralIds);
|
|
DB::db()->query('DELETE FROM general WHERE no NOT IN %li', $keepGeneralIds);
|
|
}
|
|
if (($setup['resetNations'] ?? false) === true) {
|
|
DB::db()->query('UPDATE nation SET level = 0, gennum = 0, tech = 0');
|
|
foreach ($setup['nation'] ?? [] as $row) {
|
|
comparisonMonthlyPatch('nation', $row['id'], $row['values']);
|
|
}
|
|
}
|
|
if (($setup['deleteOtherNations'] ?? false) === true) {
|
|
$keepNationIds = comparisonIntegerList($setup['keepNationIds'] ?? [], 'keepNationIds');
|
|
if (!$keepNationIds) {
|
|
throw new \InvalidArgumentException('deleteOtherNations requires keepNationIds');
|
|
}
|
|
DB::db()->query(
|
|
'DELETE FROM diplomacy WHERE me NOT IN %li OR you NOT IN %li',
|
|
$keepNationIds,
|
|
$keepNationIds,
|
|
);
|
|
DB::db()->query('DELETE FROM nation_turn WHERE nation_id NOT IN %li', $keepNationIds);
|
|
DB::db()->query('DELETE FROM nation WHERE nation NOT IN %li', $keepNationIds);
|
|
}
|
|
if (($setup['resetUniqueOccupancy'] ?? false) === true) {
|
|
DB::db()->delete('ng_auction', '`type` = %s AND finished = 0', 'uniqueItem');
|
|
DB::db()->query('DELETE FROM storage WHERE namespace LIKE %s', 'ut\\_%');
|
|
}
|
|
if (($setup['clearNeutralAuctions'] ?? false) === true) {
|
|
DB::db()->delete(
|
|
'ng_auction',
|
|
'`type` IN %ls AND host_general_id = 0',
|
|
['buyRice', 'sellRice'],
|
|
);
|
|
}
|
|
foreach (comparisonIntegerList($setup['clearNationTurnIds'] ?? [], 'clearNationTurnIds') as $nationId) {
|
|
DB::db()->delete('nation_turn', 'nation_id = %i', $nationId);
|
|
}
|
|
foreach (comparisonIntegerList($setup['clearInheritanceOwnerIds'] ?? [], 'clearInheritanceOwnerIds') as $ownerId) {
|
|
DB::db()->delete('storage', 'namespace = %s', "inheritance_{$ownerId}");
|
|
}
|
|
if (($setup['clearBetting'] ?? false) === true) {
|
|
DB::db()->query('DELETE FROM ng_betting');
|
|
DB::db()->query('DELETE FROM storage WHERE namespace = %s', 'betting');
|
|
$gameStorage = KVStorage::getStorage(DB::db(), 'game_env');
|
|
$gameStorage->setValue('last_betting_id', 0);
|
|
}
|
|
foreach ($setup['bettingInfo'] ?? [] as $rawBettingInfo) {
|
|
if (!is_array($rawBettingInfo) || !is_int($rawBettingInfo['id'] ?? null)) {
|
|
throw new \InvalidArgumentException('invalid setup.bettingInfo row');
|
|
}
|
|
KVStorage::getStorage(DB::db(), 'betting')->setValue(
|
|
"id_{$rawBettingInfo['id']}",
|
|
$rawBettingInfo,
|
|
);
|
|
}
|
|
foreach ($setup['bet'] ?? [] as $row) {
|
|
if (
|
|
!is_array($row)
|
|
|| !is_int($row['betting_id'] ?? null)
|
|
|| !is_int($row['general_id'] ?? null)
|
|
|| !is_string($row['betting_type'] ?? null)
|
|
|| !is_int($row['amount'] ?? null)
|
|
) {
|
|
throw new \InvalidArgumentException('invalid setup.bet row');
|
|
}
|
|
DB::db()->insert('ng_betting', [
|
|
'betting_id' => $row['betting_id'],
|
|
'general_id' => $row['general_id'],
|
|
'user_id' => $row['user_id'] ?? null,
|
|
'betting_type' => $row['betting_type'],
|
|
'amount' => $row['amount'],
|
|
]);
|
|
}
|
|
foreach ($setup['inheritancePrevious'] ?? [] as $ownerId => $value) {
|
|
if (!is_numeric($ownerId) || !is_int($value)) {
|
|
throw new \InvalidArgumentException('invalid setup.inheritancePrevious entry');
|
|
}
|
|
KVStorage::getStorage(DB::db(), "inheritance_{$ownerId}")->setValue('previous', [$value, null]);
|
|
}
|
|
foreach ($setup['inheritancePoints'] ?? [] as $row) {
|
|
if (
|
|
!is_array($row)
|
|
|| !is_int($row['ownerId'] ?? null)
|
|
|| !is_string($row['key'] ?? null)
|
|
|| !is_numeric($row['value'] ?? null)
|
|
) {
|
|
throw new \InvalidArgumentException('invalid setup.inheritancePoints row');
|
|
}
|
|
KVStorage::getStorage(DB::db(), "inheritance_{$row['ownerId']}")->setValue(
|
|
$row['key'],
|
|
[$row['value'], null],
|
|
);
|
|
}
|
|
foreach ($setup['rankData'] ?? [] as $row) {
|
|
if (
|
|
!is_array($row)
|
|
|| !is_int($row['generalId'] ?? null)
|
|
|| !is_string($row['type'] ?? null)
|
|
|| !is_int($row['value'] ?? null)
|
|
) {
|
|
throw new \InvalidArgumentException('invalid setup.rankData row');
|
|
}
|
|
$nationId = (int)(DB::db()->queryFirstField(
|
|
'SELECT nation FROM general WHERE no = %i',
|
|
$row['generalId'],
|
|
) ?? 0);
|
|
DB::db()->insertUpdate('rank_data', [
|
|
'general_id' => $row['generalId'],
|
|
'nation_id' => $nationId,
|
|
'type' => $row['type'],
|
|
'value' => $row['value'],
|
|
], [
|
|
'nation_id' => $nationId,
|
|
'value' => $row['value'],
|
|
]);
|
|
}
|
|
foreach ($setup['generalAccessLog'] ?? [] as $row) {
|
|
if (
|
|
!is_array($row)
|
|
|| !is_int($row['generalId'] ?? null)
|
|
|| !is_int($row['refreshScoreTotal'] ?? null)
|
|
) {
|
|
throw new \InvalidArgumentException('invalid setup.generalAccessLog row');
|
|
}
|
|
DB::db()->insertUpdate('general_access_log', [
|
|
'general_id' => $row['generalId'],
|
|
'refresh_score_total' => $row['refreshScoreTotal'],
|
|
], [
|
|
'refresh_score_total' => $row['refreshScoreTotal'],
|
|
]);
|
|
}
|
|
foreach ($setup['nationEnvironment'] ?? [] as $row) {
|
|
if (
|
|
!is_array($row)
|
|
|| !is_int($row['nationId'] ?? null)
|
|
|| !is_string($row['key'] ?? null)
|
|
|| !array_key_exists('value', $row)
|
|
) {
|
|
throw new \InvalidArgumentException('invalid setup.nationEnvironment row');
|
|
}
|
|
KVStorage::getStorage(DB::db(), $row['nationId'], 'nation_env')->setValue(
|
|
$row['key'],
|
|
$row['value'],
|
|
);
|
|
}
|
|
if (($setup['resetDiplomacy'] ?? false) === true) {
|
|
DB::db()->query('DELETE FROM diplomacy');
|
|
}
|
|
foreach ($setup['diplomacy'] ?? [] as $row) {
|
|
if (
|
|
!is_array($row)
|
|
|| !is_int($row['fromNationId'] ?? null)
|
|
|| !is_int($row['toNationId'] ?? null)
|
|
|| !is_int($row['state'] ?? null)
|
|
|| !is_int($row['term'] ?? null)
|
|
) {
|
|
throw new \InvalidArgumentException('invalid setup.diplomacy row');
|
|
}
|
|
$diplomacyPatch = [
|
|
'me' => $row['fromNationId'],
|
|
'you' => $row['toNationId'],
|
|
'state' => $row['state'],
|
|
'term' => $row['term'],
|
|
'dead' => $row['dead'] ?? 0,
|
|
];
|
|
DB::db()->insertUpdate('diplomacy', $diplomacyPatch, $diplomacyPatch);
|
|
}
|
|
if (($setup['resetEvents'] ?? false) === true) {
|
|
DB::db()->query('DELETE FROM event');
|
|
}
|
|
foreach ($setup['event'] ?? [] as $row) {
|
|
if (!is_array($row) || !is_int($row['id'] ?? null) || !is_array($row['action'] ?? null)) {
|
|
throw new \InvalidArgumentException('invalid setup.event row');
|
|
}
|
|
$eventPatch = [
|
|
'id' => $row['id'],
|
|
'target' => $row['target'] ?? 'month',
|
|
'priority' => $row['priority'] ?? 1000,
|
|
'condition' => Json::encode($row['condition'] ?? true),
|
|
'action' => Json::encode($row['action']),
|
|
];
|
|
DB::db()->insertUpdate('event', $eventPatch, $eventPatch);
|
|
}
|
|
$gameEnvironmentPatch = $setup['gameEnvironment'] ?? [];
|
|
if (!is_array($gameEnvironmentPatch)) {
|
|
throw new \InvalidArgumentException('setup.gameEnvironment must be an object');
|
|
}
|
|
$gameStorage = KVStorage::getStorage(DB::db(), 'game_env');
|
|
$worldPatch = $setup['world'] ?? [];
|
|
if (!is_array($worldPatch)) {
|
|
throw new \InvalidArgumentException('setup.world must be an object');
|
|
}
|
|
if (array_key_exists('hiddenSeed', $worldPatch)) {
|
|
if (!is_string($worldPatch['hiddenSeed']) || $worldPatch['hiddenSeed'] === '') {
|
|
throw new \InvalidArgumentException('setup.world.hiddenSeed must be a non-empty string');
|
|
}
|
|
UniqueConst::$hiddenSeed = $worldPatch['hiddenSeed'];
|
|
}
|
|
foreach ([
|
|
'isunited',
|
|
'refreshLimit',
|
|
'block_change_scout',
|
|
'lastNPCTroopLeaderID',
|
|
'tournament',
|
|
'tnmt_trig',
|
|
'tnmt_pattern',
|
|
'prev_winner',
|
|
] as $key) {
|
|
if (array_key_exists($key, $gameEnvironmentPatch)) {
|
|
$gameStorage->setValue($key, $gameEnvironmentPatch[$key]);
|
|
}
|
|
}
|
|
if (($setup['setAllCitiesNation'] ?? null) !== null) {
|
|
if (!is_int($setup['setAllCitiesNation'])) {
|
|
throw new \InvalidArgumentException('setup.setAllCitiesNation must be an integer');
|
|
}
|
|
DB::db()->update('city', ['nation' => $setup['setAllCitiesNation']], true);
|
|
}
|
|
|
|
$db = DB::db();
|
|
$generalIdBeforeAction =
|
|
(int)($db->queryFirstField('SELECT COALESCE(MAX(no), 0) FROM general') ?? 0);
|
|
$nationIdBeforeAction =
|
|
(int)($db->queryFirstField('SELECT COALESCE(MAX(nation), 0) FROM nation') ?? 0);
|
|
$eventIdBeforeAction =
|
|
(int)($db->queryFirstField('SELECT COALESCE(MAX(id), 0) FROM event') ?? 0);
|
|
$auctionIdBeforeAction =
|
|
(int)($db->queryFirstField('SELECT COALESCE(MAX(id), 0) FROM ng_auction') ?? 0);
|
|
$snapshotRequest = ['observe' => $request['observe'] ?? []];
|
|
$snapshotRequest['observe']['logAfterId'] =
|
|
(int)($db->queryFirstField('SELECT COALESCE(MAX(id), 0) FROM general_record') ?? 0);
|
|
$worldHistoryAfterId =
|
|
(int)($db->queryFirstField('SELECT COALESCE(MAX(id), 0) FROM world_history') ?? 0);
|
|
$before = comparisonTurnStateSnapshot($snapshotRequest);
|
|
$beforeDetails = comparisonMonthlyDetails($snapshotRequest['observe'], $worldHistoryAfterId);
|
|
|
|
$environment = $request['environment'] ?? [];
|
|
if (!is_array($environment)) {
|
|
throw new \InvalidArgumentException('environment must be an object');
|
|
}
|
|
$year = $environment['year'] ?? null;
|
|
$month = $environment['month'] ?? null;
|
|
$startYear = $environment['startyear'] ?? null;
|
|
if (!is_int($year) || !is_int($month) || !is_int($startYear)) {
|
|
throw new \InvalidArgumentException('environment year, month, and startyear must be integers');
|
|
}
|
|
if (($setup['syncEnvironment'] ?? false) === true) {
|
|
$gameStorage = KVStorage::getStorage(DB::db(), 'game_env');
|
|
$environmentValues = [
|
|
'year' => $year,
|
|
'month' => $month,
|
|
'startyear' => $startYear,
|
|
'killturn' => $environment['killturn'] ?? $gameStorage->killturn,
|
|
'turnterm' => $environment['turnterm'] ?? $gameStorage->turnterm,
|
|
];
|
|
if (isset($environment['starttime'])) {
|
|
if (!is_string($environment['starttime']) || $environment['starttime'] === '') {
|
|
throw new \InvalidArgumentException('environment.starttime must be a non-empty string');
|
|
}
|
|
$environmentValues['starttime'] = $environment['starttime'];
|
|
}
|
|
foreach ($environmentValues as $key => $value) {
|
|
$gameStorage->setValue($key, $value);
|
|
}
|
|
if ($actionName === 'MonthlyBoundary') {
|
|
$before = comparisonTurnStateSnapshot($snapshotRequest);
|
|
$beforeDetails = comparisonMonthlyDetails($snapshotRequest['observe'], $worldHistoryAfterId);
|
|
}
|
|
}
|
|
|
|
if ($actionName === 'InvaderLifecycle') {
|
|
foreach (['turnterm', 'turntime'] as $requiredEnvironmentKey) {
|
|
if (!array_key_exists($requiredEnvironmentKey, $environment)) {
|
|
throw new \InvalidArgumentException(
|
|
"InvaderLifecycle requires environment.{$requiredEnvironmentKey}",
|
|
);
|
|
}
|
|
}
|
|
echo json_encode(
|
|
comparisonInvaderLifecycleTrace(
|
|
$request,
|
|
$environment,
|
|
$generalIdBeforeAction,
|
|
$nationIdBeforeAction,
|
|
$eventIdBeforeAction,
|
|
$worldHistoryAfterId,
|
|
),
|
|
JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION,
|
|
), PHP_EOL;
|
|
return;
|
|
}
|
|
if ($actionName === 'NpcNationLifecycle') {
|
|
foreach (['turnterm', 'turntime'] as $requiredEnvironmentKey) {
|
|
if (!array_key_exists($requiredEnvironmentKey, $environment)) {
|
|
throw new \InvalidArgumentException(
|
|
"NpcNationLifecycle requires environment.{$requiredEnvironmentKey}",
|
|
);
|
|
}
|
|
}
|
|
echo json_encode(
|
|
comparisonNpcNationLifecycleTrace(
|
|
$environment,
|
|
$generalIdBeforeAction,
|
|
$nationIdBeforeAction,
|
|
$worldHistoryAfterId,
|
|
),
|
|
JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION,
|
|
), PHP_EOL;
|
|
return;
|
|
}
|
|
if ($actionName === 'NationBettingLifecycle') {
|
|
echo json_encode(
|
|
comparisonNationBettingLifecycleTrace(
|
|
$request,
|
|
$environment,
|
|
$eventIdBeforeAction,
|
|
$worldHistoryAfterId,
|
|
),
|
|
JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION,
|
|
), PHP_EOL;
|
|
return;
|
|
}
|
|
|
|
$actionClass = "\\sammo\\Event\\Action\\{$actionName}";
|
|
if (in_array($actionName, ['PreUpdateMonthly', 'PostUpdateMonthly', 'MonthlyBoundary'], true)) {
|
|
$action = null;
|
|
} elseif ($actionName === 'ProcessSemiAnnual') {
|
|
$resource = $request['resource'] ?? null;
|
|
if (!is_string($resource)) {
|
|
throw new \InvalidArgumentException('ProcessSemiAnnual requires resource');
|
|
}
|
|
$action = new $actionClass($resource);
|
|
} elseif (in_array($actionName, ['CreateManyNPC', 'RegNPC', 'RegNeutralNPC', 'RaiseInvader', 'AutoDeleteInvader', 'ChangeCity', 'OpenNationBetting', 'FinishNationBetting', 'BlockScoutAction', 'UnblockScoutAction', 'AddGlobalBetray', 'LostUniqueItem', 'ProcessIncome', 'NoticeToHistoryLog'], true)) {
|
|
$args = $request['args'] ?? [];
|
|
if (!is_array($args)) {
|
|
throw new \InvalidArgumentException("{$actionName} args must be an array");
|
|
}
|
|
if ($actionName === 'CreateManyNPC' && count($args) > 2) {
|
|
throw new \InvalidArgumentException('CreateManyNPC args must have at most two entries');
|
|
}
|
|
if ($actionName === 'RaiseInvader' && count($args) > 4) {
|
|
throw new \InvalidArgumentException('RaiseInvader args must have at most four entries');
|
|
}
|
|
if ($actionName === 'ChangeCity' && count($args) !== 2) {
|
|
throw new \InvalidArgumentException('ChangeCity args must have exactly two entries');
|
|
}
|
|
if ($actionName === 'OpenNationBetting' && count($args) > 2) {
|
|
throw new \InvalidArgumentException('OpenNationBetting args must have at most two entries');
|
|
}
|
|
if ($actionName === 'FinishNationBetting' && count($args) !== 1) {
|
|
throw new \InvalidArgumentException('FinishNationBetting args must have exactly one entry');
|
|
}
|
|
if (in_array($actionName, ['BlockScoutAction', 'UnblockScoutAction'], true) && count($args) > 1) {
|
|
throw new \InvalidArgumentException("{$actionName} args must have at most one entry");
|
|
}
|
|
if ($actionName === 'AddGlobalBetray' && count($args) > 2) {
|
|
throw new \InvalidArgumentException('AddGlobalBetray args must have at most two entries');
|
|
}
|
|
if ($actionName === 'LostUniqueItem' && count($args) > 1) {
|
|
throw new \InvalidArgumentException('LostUniqueItem args must have at most one entry');
|
|
}
|
|
if ($actionName === 'ProcessIncome' && count($args) !== 1) {
|
|
throw new \InvalidArgumentException('ProcessIncome args must have exactly one entry');
|
|
}
|
|
if ($actionName === 'NoticeToHistoryLog' && (count($args) < 1 || count($args) > 2)) {
|
|
throw new \InvalidArgumentException('NoticeToHistoryLog args must have one or two entries');
|
|
}
|
|
$action = new $actionClass(...$args);
|
|
} else {
|
|
$action = new $actionClass();
|
|
}
|
|
$actionEnvironment = [
|
|
'year' => $year,
|
|
'month' => $month,
|
|
'startyear' => $startYear,
|
|
];
|
|
if (isset($environment['currentEventID'])) {
|
|
if (!is_int($environment['currentEventID'])) {
|
|
throw new \InvalidArgumentException('currentEventID must be an integer');
|
|
}
|
|
$actionEnvironment['currentEventID'] = $environment['currentEventID'];
|
|
}
|
|
if ($actionName === 'UpdateNationLevel') {
|
|
$killturn = $environment['killturn'] ?? null;
|
|
$turnterm = $environment['turnterm'] ?? null;
|
|
if (!is_int($killturn) || !is_int($turnterm) || $turnterm <= 0) {
|
|
throw new \InvalidArgumentException('UpdateNationLevel requires integer killturn and positive turnterm');
|
|
}
|
|
$actionEnvironment['killturn'] = $killturn;
|
|
$actionEnvironment['turnterm'] = $turnterm;
|
|
}
|
|
if (in_array($actionName, ['CreateManyNPC', 'RegNPC', 'RegNeutralNPC', 'RaiseNPCNation', 'RaiseInvader', 'ProvideNPCTroopLeader'], true)) {
|
|
$turnterm = $environment['turnterm'] ?? null;
|
|
$turntime = $environment['turntime'] ?? null;
|
|
$showImgLevel = $environment['show_img_level'] ?? 3;
|
|
$fiction = $environment['fiction'] ?? [0];
|
|
if (
|
|
!is_int($turnterm)
|
|
|| $turnterm <= 0
|
|
|| !is_string($turntime)
|
|
|| !is_int($showImgLevel)
|
|
|| !is_array($fiction)
|
|
) {
|
|
throw new \InvalidArgumentException(
|
|
"{$actionName} requires positive turnterm, string turntime, integer show_img_level, and array fiction",
|
|
);
|
|
}
|
|
$actionEnvironment += [
|
|
'turnterm' => $turnterm,
|
|
'turntime' => $turntime,
|
|
'show_img_level' => $showImgLevel,
|
|
'stored_icons' => $environment['stored_icons'] ?? [],
|
|
'icon_path' => $environment['icon_path'] ?? '.',
|
|
'fiction' => $fiction,
|
|
];
|
|
}
|
|
if ($actionName === 'PreUpdateMonthly') {
|
|
if (!preUpdateMonthly()) {
|
|
throw new \RuntimeException('preUpdateMonthly failed');
|
|
}
|
|
} elseif ($actionName === 'PostUpdateMonthly') {
|
|
$seedYear = $environment['seedYear'] ?? null;
|
|
$seedMonth = $environment['seedMonth'] ?? null;
|
|
if (!is_int($seedYear) || !is_int($seedMonth)) {
|
|
throw new \InvalidArgumentException('PostUpdateMonthly requires seedYear and seedMonth');
|
|
}
|
|
postUpdateMonthly(new RandUtil(new LiteHashDRBG(Util::simpleSerialize(
|
|
UniqueConst::$hiddenSeed,
|
|
'monthly',
|
|
$seedYear,
|
|
$seedMonth,
|
|
))));
|
|
} elseif ($actionName === 'MonthlyBoundary') {
|
|
$turntime = $environment['turntime'] ?? null;
|
|
if (!is_string($turntime) || $turntime === '') {
|
|
throw new \InvalidArgumentException('MonthlyBoundary requires turntime');
|
|
}
|
|
$gameStorage = KVStorage::getStorage($db, 'game_env');
|
|
$seedYear = (int)$gameStorage->year;
|
|
$seedMonth = (int)$gameStorage->month;
|
|
TurnExecutionHelper::runEventHandler($db, $gameStorage, Enums\EventTarget::PreMonth);
|
|
if (!preUpdateMonthly()) {
|
|
throw new \RuntimeException('preUpdateMonthly failed');
|
|
}
|
|
turnDate($turntime);
|
|
$gameStorage->resetCache();
|
|
if ((int)$gameStorage->month === 1) {
|
|
checkStatistic();
|
|
}
|
|
TurnExecutionHelper::runEventHandler($db, $gameStorage, Enums\EventTarget::Month);
|
|
postUpdateMonthly(new RandUtil(new LiteHashDRBG(Util::simpleSerialize(
|
|
UniqueConst::$hiddenSeed,
|
|
'monthly',
|
|
$seedYear,
|
|
$seedMonth,
|
|
))));
|
|
} else {
|
|
$action->run($actionEnvironment);
|
|
}
|
|
unset($action);
|
|
gc_collect_cycles();
|
|
|
|
$after = comparisonTurnStateSnapshot($snapshotRequest);
|
|
$afterDetails = comparisonMonthlyDetails($snapshotRequest['observe'], $worldHistoryAfterId);
|
|
$createdGenerals = [];
|
|
if (in_array($actionName, ['CreateManyNPC', 'RegNPC', 'RegNeutralNPC', 'RaiseNPCNation', 'RaiseInvader', 'ProvideNPCTroopLeader'], true)) {
|
|
foreach ($db->query('SELECT * FROM general WHERE no > %i ORDER BY no', $generalIdBeforeAction) as $row) {
|
|
$generalId = (int)$row['no'];
|
|
$turnRows = $db->query(
|
|
'SELECT turn_idx, action, arg FROM general_turn WHERE general_id = %i ORDER BY turn_idx',
|
|
$generalId,
|
|
);
|
|
$createdGenerals[] = comparisonPickRow(
|
|
$row,
|
|
[
|
|
'id' => 'no',
|
|
'name' => 'name',
|
|
'nationId' => 'nation',
|
|
'cityId' => 'city',
|
|
'leadership' => 'leadership',
|
|
'strength' => 'strength',
|
|
'intelligence' => 'intel',
|
|
'experience' => 'experience',
|
|
'dedication' => 'dedication',
|
|
'officerLevel' => 'officer_level',
|
|
'gold' => 'gold',
|
|
'rice' => 'rice',
|
|
'crew' => 'crew',
|
|
'crewTypeId' => 'crewtype',
|
|
'train' => 'train',
|
|
'atmos' => 'atmos',
|
|
'turnTime' => 'turntime',
|
|
'killturn' => 'killturn',
|
|
'age' => 'age',
|
|
'npcState' => 'npc',
|
|
'npcOriginalState' => 'npc_org',
|
|
'affinity' => 'affinity',
|
|
'personality' => 'personal',
|
|
'specialDomestic' => 'special',
|
|
'specialWar' => 'special2',
|
|
'specAge' => 'specage',
|
|
'specAge2' => 'specage2',
|
|
'bornYear' => 'bornyear',
|
|
'deadYear' => 'deadyear',
|
|
'picture' => 'picture',
|
|
'dex1' => 'dex1',
|
|
'dex2' => 'dex2',
|
|
'dex3' => 'dex3',
|
|
'dex4' => 'dex4',
|
|
'dex5' => 'dex5',
|
|
],
|
|
) + [
|
|
'turnCount' => count($turnRows),
|
|
'turnActions' => array_values(array_unique(array_column($turnRows, 'action'))),
|
|
'rankCount' => (int)$db->queryFirstField(
|
|
'SELECT count(*) FROM rank_data WHERE general_id = %i',
|
|
$generalId,
|
|
),
|
|
'nonZeroRankCount' => (int)$db->queryFirstField(
|
|
'SELECT count(*) FROM rank_data WHERE general_id = %i AND value != 0',
|
|
$generalId,
|
|
),
|
|
'troop' => $db->queryFirstRow(
|
|
'SELECT troop_leader AS id, nation AS nationId, name FROM troop WHERE troop_leader = %i',
|
|
$generalId,
|
|
) ?: null,
|
|
];
|
|
}
|
|
}
|
|
$createdNations = [];
|
|
if (in_array($actionName, ['RaiseNPCNation', 'RaiseInvader'], true)) {
|
|
foreach ($db->query('SELECT * FROM nation WHERE nation > %i ORDER BY nation', $nationIdBeforeAction) as $row) {
|
|
$nationId = (int)$row['nation'];
|
|
$createdNations[] = comparisonPickRow(
|
|
$row,
|
|
[
|
|
'id' => 'nation',
|
|
'name' => 'name',
|
|
'color' => 'color',
|
|
'capitalCityId' => 'capital',
|
|
'generalCount' => 'gennum',
|
|
'gold' => 'gold',
|
|
'rice' => 'rice',
|
|
'tech' => 'tech',
|
|
'level' => 'level',
|
|
'typeCode' => 'type',
|
|
'bill' => 'bill',
|
|
'rate' => 'rate',
|
|
'scout' => 'scout',
|
|
'war' => 'war',
|
|
'strategicCommandLimit' => 'strategic_cmd_limit',
|
|
'surrenderLimit' => 'surlimit',
|
|
'aux' => 'aux',
|
|
],
|
|
['aux'],
|
|
) + [
|
|
'nationTurnCount' => (int)$db->queryFirstField(
|
|
'SELECT count(*) FROM nation_turn WHERE nation_id = %i',
|
|
$nationId,
|
|
),
|
|
'diplomacyCount' => (int)$db->queryFirstField(
|
|
'SELECT count(*) FROM diplomacy WHERE me = %i OR you = %i',
|
|
$nationId,
|
|
$nationId,
|
|
),
|
|
];
|
|
}
|
|
}
|
|
$response = [
|
|
'schemaVersion' => 1,
|
|
'engine' => 'ref',
|
|
'action' => $actionName,
|
|
'before' => $before,
|
|
'beforeDetails' => $beforeDetails,
|
|
'after' => $after,
|
|
'afterDetails' => $afterDetails,
|
|
];
|
|
if (in_array($actionName, ['CreateManyNPC', 'RegNPC', 'RegNeutralNPC'], true)) {
|
|
$response['createdGenerals'] = $createdGenerals;
|
|
}
|
|
if (in_array($actionName, ['RaiseNPCNation', 'RaiseInvader'], true)) {
|
|
$response['createdGenerals'] = $createdGenerals;
|
|
$response['createdNations'] = $createdNations;
|
|
}
|
|
if ($actionName === 'ProvideNPCTroopLeader') {
|
|
$response['createdGenerals'] = $createdGenerals;
|
|
$response['gameEnvironment'] = KVStorage::getStorage(DB::db(), 'game_env')->getValues([
|
|
'lastNPCTroopLeaderID',
|
|
]);
|
|
}
|
|
if ($actionName === 'PreUpdateMonthly') {
|
|
$response['gameEnvironment'] = KVStorage::getStorage(DB::db(), 'game_env')->getValues([
|
|
'develcost',
|
|
]);
|
|
}
|
|
if ($actionName === 'PostUpdateMonthly') {
|
|
$response['gameEnvironment'] = KVStorage::getStorage(DB::db(), 'game_env')->getValues([
|
|
'tournament',
|
|
'tnmt_trig',
|
|
'tnmt_pattern',
|
|
'tnmt_type',
|
|
'tnmt_auto',
|
|
'phase',
|
|
]);
|
|
$response['createdNeutralAuctions'] = array_map(
|
|
static fn(array $row): array => [
|
|
'id' => (int)$row['id'],
|
|
'type' => $row['type'],
|
|
'target' => $row['target'],
|
|
'detail' => Json::decode($row['detail']),
|
|
],
|
|
iterator_to_array(
|
|
$db->query(
|
|
'SELECT id, `type`, target, detail FROM ng_auction WHERE id > %i AND host_general_id = 0 ORDER BY id',
|
|
$auctionIdBeforeAction,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
if (in_array($actionName, ['OpenNationBetting', 'FinishNationBetting'], true)) {
|
|
$bettingStorage = KVStorage::getStorage(DB::db(), 'betting');
|
|
$response['betting'] = $bettingStorage->getAll();
|
|
$response['bets'] = iterator_to_array(
|
|
$db->query(
|
|
'SELECT betting_id AS bettingId, general_id AS generalId, user_id AS userId, betting_type AS selectionKey, amount FROM ng_betting ORDER BY id',
|
|
),
|
|
);
|
|
$response['createdEvents'] = array_map(
|
|
static fn(array $row): array => comparisonPickRow(
|
|
$row,
|
|
[
|
|
'id' => 'id',
|
|
'targetCode' => 'target',
|
|
'priority' => 'priority',
|
|
'condition' => 'condition',
|
|
'action' => 'action',
|
|
],
|
|
['condition', 'action'],
|
|
),
|
|
iterator_to_array(
|
|
$db->query(
|
|
'SELECT id, target, priority, `condition`, action FROM event WHERE id > %i ORDER BY id',
|
|
$eventIdBeforeAction,
|
|
),
|
|
),
|
|
);
|
|
$response['gameEnvironment'] = KVStorage::getStorage(DB::db(), 'game_env')->getValues([
|
|
'last_betting_id',
|
|
]);
|
|
$response['inheritancePrevious'] = [];
|
|
foreach (comparisonIntegerList($request['observe']['ownerIds'] ?? [], 'ownerIds') as $ownerId) {
|
|
$value = KVStorage::getStorage(DB::db(), "inheritance_{$ownerId}")->getValue('previous');
|
|
$response['inheritancePrevious'][(string)$ownerId] = is_array($value) ? ($value[0] ?? 0) : 0;
|
|
}
|
|
}
|
|
if (in_array($actionName, ['BlockScoutAction', 'UnblockScoutAction'], true)) {
|
|
$response['gameEnvironment'] = KVStorage::getStorage(DB::db(), 'game_env')->getValues([
|
|
'block_change_scout',
|
|
]);
|
|
}
|
|
if ($actionName === 'RaiseInvader') {
|
|
$response['createdEvents'] = array_map(
|
|
static fn(array $row): array => comparisonPickRow(
|
|
$row,
|
|
[
|
|
'id' => 'id',
|
|
'targetCode' => 'target',
|
|
'priority' => 'priority',
|
|
'condition' => 'condition',
|
|
'action' => 'action',
|
|
],
|
|
['condition', 'action'],
|
|
),
|
|
iterator_to_array(
|
|
$db->query(
|
|
'SELECT id, target, priority, `condition`, action FROM event WHERE id > %i ORDER BY id',
|
|
$eventIdBeforeAction,
|
|
),
|
|
),
|
|
);
|
|
$response['createdDiplomacy'] = iterator_to_array(
|
|
$db->query(
|
|
'SELECT me AS fromNationId, you AS toNationId, state, term FROM diplomacy WHERE me > %i OR you > %i ORDER BY me, you',
|
|
$nationIdBeforeAction,
|
|
$nationIdBeforeAction,
|
|
),
|
|
);
|
|
$gameStorage = KVStorage::getStorage(DB::db(), 'game_env');
|
|
$response['gameEnvironment'] = $gameStorage->getValues([
|
|
'isunited',
|
|
'turnterm',
|
|
'block_change_scout',
|
|
'refreshLimit',
|
|
]);
|
|
}
|
|
if (in_array($actionName, ['AutoDeleteInvader', 'InvaderEnding'], true)) {
|
|
$gameStorage = KVStorage::getStorage(DB::db(), 'game_env');
|
|
$response['gameEnvironment'] = $gameStorage->getValues([
|
|
'isunited',
|
|
'turnterm',
|
|
'block_change_scout',
|
|
'refreshLimit',
|
|
]);
|
|
}
|
|
if (($request['compactOutput'] ?? false) === true) {
|
|
$observedGeneralTurns = [];
|
|
foreach (comparisonIntegerList($request['observe']['generalIds'] ?? [], 'generalIds') as $generalId) {
|
|
$observedGeneralTurns[(string)$generalId] = iterator_to_array(
|
|
$db->query(
|
|
'SELECT turn_idx AS turnIndex, action, arg FROM general_turn WHERE general_id = %i ORDER BY turn_idx',
|
|
$generalId,
|
|
),
|
|
);
|
|
}
|
|
$response = [
|
|
'schemaVersion' => 1,
|
|
'engine' => 'ref',
|
|
'action' => $actionName,
|
|
'afterDetails' => $afterDetails,
|
|
'createdGeneralCount' => count($createdGenerals),
|
|
'firstCreatedGenerals' => array_slice($createdGenerals, 0, 3),
|
|
'createdNations' => $response['createdNations'] ?? [],
|
|
'createdEvents' => $response['createdEvents'] ?? [],
|
|
'createdDiplomacy' => $response['createdDiplomacy'] ?? [],
|
|
'gameEnvironment' => $response['gameEnvironment'] ?? [],
|
|
'logs' => $after['logs'],
|
|
'observedGeneralTurns' => $observedGeneralTurns,
|
|
'remainingEventIds' => array_map(
|
|
'intval',
|
|
$db->queryFirstColumn('SELECT id FROM event ORDER BY id'),
|
|
),
|
|
];
|
|
}
|
|
echo json_encode(
|
|
$response,
|
|
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);
|
|
}
|
|
}
|
|
|
|
comparisonMonthlyEventTraceMain();
|