192 lines
7.5 KiB
PHP
192 lines
7.5 KiB
PHP
#!/usr/bin/env php
|
|
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
use sammo\DB;
|
|
use sammo\GameClock;
|
|
use sammo\KVStorage;
|
|
use sammo\TurnExecutionHelper;
|
|
use sammo\Util;
|
|
|
|
if (PHP_SAPI !== 'cli') {
|
|
http_response_code(404);
|
|
exit(1);
|
|
}
|
|
|
|
$_SERVER['REMOTE_ADDR'] ??= '127.0.0.1';
|
|
$_SERVER['REQUEST_URI'] ??= '/cli/verify-game-clock-engine';
|
|
|
|
require dirname(__DIR__) . '/hwe/lib.php';
|
|
require dirname(__DIR__) . '/hwe/func.php';
|
|
while (ob_get_level() > 0) {
|
|
ob_end_flush();
|
|
}
|
|
ob_implicit_flush(true);
|
|
|
|
$options = getopt('', ['apply', 'engine-calls:', 'until-unification', 'max-months:']);
|
|
if (!isset($options['apply'])) {
|
|
fwrite(STDERR, "Usage: php scripts/verify-game-clock-engine.php --apply [--engine-calls=N] [--until-unification --max-months=N]\n");
|
|
exit(2);
|
|
}
|
|
$untilUnification = isset($options['until-unification']);
|
|
$engineCalls = filter_var($options['engine-calls'] ?? ($untilUnification ? '100' : '1'), FILTER_VALIDATE_INT);
|
|
if ($engineCalls === false || $engineCalls < 1 || $engineCalls > 1000) {
|
|
throw new InvalidArgumentException('--engine-calls는 1..1000이어야 합니다.');
|
|
}
|
|
$maxMonths = filter_var($options['max-months'] ?? '2400', FILTER_VALIDATE_INT);
|
|
if ($maxMonths === false || $maxMonths < 1 || $maxMonths > 10000) {
|
|
throw new InvalidArgumentException('--max-months는 1..10000이어야 합니다.');
|
|
}
|
|
|
|
$db = DB::db();
|
|
$gameStor = KVStorage::getStorage($db, 'game_env');
|
|
$clock = GameClock::fromStorage($gameStor);
|
|
if ($clock->getMode() !== GameClock::MODE_MANUAL) {
|
|
throw new RuntimeException('재현 검증은 manual clock에서만 실행할 수 있습니다.');
|
|
}
|
|
|
|
$fixedNowTick = $clock->nowTick();
|
|
$before = $gameStor->getValues(['year', 'month', 'turntime']);
|
|
|
|
if ($untilUnification) {
|
|
$startedAt = GameClock::readWallTime();
|
|
$startProjection = $clock->formatTick($fixedNowTick, true);
|
|
$advancedMonths = 0;
|
|
$totalEngineCalls = 0;
|
|
while ($advancedMonths < $maxMonths) {
|
|
$gameStor->resetCache();
|
|
$state = $gameStor->getValues(['year', 'month', 'turntime', 'turnterm', 'isunited']);
|
|
if (in_array(Util::toInt($state['isunited']), [2, 3], true)) {
|
|
break;
|
|
}
|
|
|
|
$beforeYearMonth = Util::joinYearMonth(Util::toInt($state['year']), Util::toInt($state['month']));
|
|
$clock = GameClock::fromStorage($gameStor);
|
|
$nextMonthBoundary = $clock->addTurns(
|
|
\sammo\cutTurn(Util::toInt($state['turntime']), Util::toInt($state['turnterm'])),
|
|
1,
|
|
);
|
|
$nextMonthTick = GameClock::addTicks($nextMonthBoundary, 1);
|
|
|
|
if (!\sammo\tryLock()) {
|
|
throw new RuntimeException('manual clock 전진을 위한 GAME lock을 획득하지 못했습니다.');
|
|
}
|
|
try {
|
|
$clock->persistTick($gameStor, $nextMonthTick, GameClock::MODE_MANUAL);
|
|
} finally {
|
|
$gameStor->resetCache();
|
|
\sammo\unlock();
|
|
}
|
|
|
|
$monthAdvanced = false;
|
|
for ($call = 0; $call < $engineCalls; $call++) {
|
|
$executed = false;
|
|
$locked = false;
|
|
TurnExecutionHelper::executeAllCommand($executed, $locked);
|
|
$totalEngineCalls++;
|
|
$gameStor->resetCache();
|
|
$clock = GameClock::fromStorage($gameStor);
|
|
if ($clock->getMode() !== GameClock::MODE_MANUAL || $clock->nowTick() !== $nextMonthTick) {
|
|
throw new RuntimeException('실제 턴 엔진 실행 중 manual clock 상태가 벽시계에 의해 바뀌었습니다.');
|
|
}
|
|
$afterCall = $gameStor->getValues(['year', 'month', 'turntime', 'isunited']);
|
|
if (Util::toInt($afterCall['turntime']) > $nextMonthTick) {
|
|
throw new RuntimeException('마지막 실행 tick이 현재 manual clock tick을 넘어갔습니다.');
|
|
}
|
|
if (in_array(Util::toInt($afterCall['isunited']), [2, 3], true)) {
|
|
$monthAdvanced = true;
|
|
break;
|
|
}
|
|
// turntime is the authoritative completed schedule boundary. Some
|
|
// legacy monthly state is cached until the next storage read, so do
|
|
// not spin merely because year/month from that same call is stale.
|
|
if (Util::toInt($afterCall['turntime']) >= $nextMonthBoundary) {
|
|
$monthAdvanced = true;
|
|
break;
|
|
}
|
|
$afterYearMonth = Util::joinYearMonth(Util::toInt($afterCall['year']), Util::toInt($afterCall['month']));
|
|
if ($afterYearMonth !== $beforeYearMonth) {
|
|
$monthAdvanced = true;
|
|
break;
|
|
}
|
|
if ($locked) {
|
|
throw new RuntimeException('통일 전 실제 턴 엔진이 GAME lock 또는 동결 상태에 머물렀습니다.');
|
|
}
|
|
}
|
|
if (!$monthAdvanced) {
|
|
throw new RuntimeException("한 달을 {$engineCalls}회 엔진 호출 안에 완료하지 못했습니다.");
|
|
}
|
|
|
|
$advancedMonths++;
|
|
if ($advancedMonths % 12 === 0) {
|
|
$gameStor->resetCache();
|
|
printf(
|
|
"progress months=%d game=%d-%02d clock_tick=%d nations=%d engine_calls=%d\n",
|
|
$advancedMonths,
|
|
Util::toInt($gameStor->year),
|
|
Util::toInt($gameStor->month),
|
|
GameClock::fromStorage($gameStor)->nowTick(),
|
|
Util::toInt($db->queryFirstField('SELECT COUNT(*) FROM nation WHERE level > 0')),
|
|
$totalEngineCalls,
|
|
);
|
|
}
|
|
}
|
|
|
|
$gameStor->resetCache();
|
|
$finalState = $gameStor->getValues(['year', 'month', 'turntime', 'isunited']);
|
|
if (!in_array(Util::toInt($finalState['isunited']), [2, 3], true)) {
|
|
throw new RuntimeException("{$maxMonths}개월 안에 천하통일에 도달하지 못했습니다.");
|
|
}
|
|
$finalClock = GameClock::fromStorage($gameStor);
|
|
printf(
|
|
"UNIFIED months=%d engine_calls=%d game=%d-%02d isunited=%d clock_tick=%d projected=%s start_projected=%s wall_elapsed=%.6f\n",
|
|
$advancedMonths,
|
|
$totalEngineCalls,
|
|
Util::toInt($finalState['year']),
|
|
Util::toInt($finalState['month']),
|
|
Util::toInt($finalState['isunited']),
|
|
$finalClock->nowTick(),
|
|
$finalClock->formatNow(true),
|
|
$startProjection,
|
|
(float)GameClock::readWallTime()->format('U.u') - (float)$startedAt->format('U.u'),
|
|
);
|
|
exit(0);
|
|
}
|
|
|
|
$executedCount = 0;
|
|
for ($call = 0; $call < $engineCalls; $call++) {
|
|
$executed = false;
|
|
$locked = false;
|
|
TurnExecutionHelper::executeAllCommand($executed, $locked);
|
|
if ($locked) {
|
|
throw new RuntimeException('엔진이 GAME lock 또는 동결 상태로 진행하지 못했습니다.');
|
|
}
|
|
if ($executed) {
|
|
$executedCount++;
|
|
}
|
|
$gameStor->resetCache();
|
|
$clock = GameClock::fromStorage($gameStor);
|
|
if ($clock->nowTick() !== $fixedNowTick) {
|
|
throw new RuntimeException('엔진 실행 중 manual clock tick이 실제 시간에 의해 변했습니다.');
|
|
}
|
|
}
|
|
|
|
$after = $gameStor->getValues(['year', 'month', 'turntime']);
|
|
if (Util::toInt($after['turntime']) > $fixedNowTick) {
|
|
throw new RuntimeException('마지막 실행 tick이 현재 game tick을 넘어갔습니다.');
|
|
}
|
|
printf(
|
|
"clock_tick=%d clock=%s calls=%d executed_calls=%d before=%d-%02d/%d after=%d-%02d/%d\n",
|
|
$fixedNowTick,
|
|
$clock->formatTick($fixedNowTick, true),
|
|
$engineCalls,
|
|
$executedCount,
|
|
Util::toInt($before['year']),
|
|
Util::toInt($before['month']),
|
|
Util::toInt($before['turntime']),
|
|
Util::toInt($after['year']),
|
|
Util::toInt($after['month']),
|
|
Util::toInt($after['turntime']),
|
|
);
|