wip: process_war에서 defenderList 변경

- defenderList를 General[] 에서 WarUnit[]으로 변경
- extractBattleOrder를 WarUnit을 받도록 변경

hwe/j_simulate_battle.php

@@ -1,4 +1,5 @@
 <?php
+
 namespace sammo;
 
 use Ds\Map;
@@ -86,123 +87,6 @@ $rawDefenderNation = $query['defenderNation'];
 
 $warSeed = $query['seed'] ?? '';
 
-$generalCheck = [
-    'required'=>[
-        'no', 'name', 'nation', 'turntime', 'personal', 'special2', 'crew', 'crewtype', 'atmos', 'train',
-        'intel', 'intel_exp', 'book', 'strength', 'strength_exp', 'weapon', 'injury', 'leadership', 'leadership_exp', 'horse', 'item',
-        'explevel', 'experience', 'dedication', 'officer_level', 'officer_city', 'gold', 'rice', 'dex1', 'dex2', 'dex3', 'dex4', 'dex5',
-        'recent_war', 'warnum', 'killnum', 'killcrew',
-    ],
-    'integer'=>[
-        'no', 'nation', 'crew', 'crewtype', 'atmos', 'train',
-        'intel', 'intel_exp', 'strength', 'strength_exp',  'injury', 'leadership', 'leadership_exp',
-        'explevel', 'experience', 'dedication', 'officer_level', 'officer_city', 'gold', 'rice', 'dex1', 'dex2', 'dex3', 'dex4', 'dex5',
-        'warnum', 'killnum', 'killcrew',
-    ],
-    'min'=>[
-        ['no', 1],
-        ['nation', 1],
-        ['crew', 0],
-        ['intel', 0],
-        ['strength', 0],
-        ['leadership', 0],
-        ['experience', 0],
-        ['gold', 0],
-        ['rice', 0],
-        ['dex1', 0],
-        ['dex2', 0],
-        ['dex3', 0],
-        ['dex4', 0],
-        ['dex5', 0],
-        ['warnum', 0],
-        ['killnum', 0],
-        ['killcrew', 0],
-    ],
-    'between'=>[
-        ['train', [40, GameConst::$maxTrainByWar]],
-        ['atmos', [40, GameConst::$maxAtmosByWar]],
-        ['explevel', [0, 300]],
-        ['injury', [0, 80]],
-        ['officer_level', [1, 12]]
-    ],
-    'in'=>[
-        ['personal', array_merge(GameConst::$availablePersonality, GameConst::$optionalPersonality)],
-        ['special2', array_merge(GameConst::$availableSpecialWar, GameConst::$optionalSpecialWar)],
-        ['crewtype', array_keys(GameUnitConst::all())],
-        ['horse', array_merge(array_keys(GameConst::$allItems['horse']), ['None'])],
-        ['weapon', array_merge(array_keys(GameConst::$allItems['weapon']), ['None'])],
-        ['book', array_merge(array_keys(GameConst::$allItems['book']), ['None'])],
-        ['item', array_merge(array_keys(GameConst::$allItems['item']), ['None'])],
-    ],
-    'array'=>['inheritBuff'],
-];
-
-$inheritBuffCheck = [
-    'between'=>[
-        [TriggerInheritBuff::WAR_AVOID_RATIO, [0, 5]],
-        [TriggerInheritBuff::WAR_CRITICAL_RATIO, [0, 5]],
-        [TriggerInheritBuff::WAR_MAGIC_TRIAL_PROB, [0, 5]],
-
-        [TriggerInheritBuff::OPPOSE_WAR_AVOID_RATIO, [0, 5]],
-        [TriggerInheritBuff::OPPOSE_WAR_CRITICAL_RATIO, [0, 5]],
-        [TriggerInheritBuff::OPPOSE_WAR_MAGIC_TRIAL_PROB, [0, 5]],
-    ]
-];
-
-$v = new Validator($rawAttacker);
-$v->rules($generalCheck);
-if(!$v->validate()){
-    Json::die([
-        'result'=>false,
-        'reason'=>'[출병자]'.$v->errorStr()
-    ]);
-}
-$rawAttacker['aux'] = [];
-if(key_exists('inheritBuff', $rawAttacker)){
-    $v = new Validator($rawAttacker['inheritBuff']);
-    $v->rules($inheritBuffCheck);
-    if(!$v->validate()){
-        Json::die([
-            'result'=>false,
-            'reason'=>'[출병자]'.$v->errorStr()
-        ]);
-    }
-    $rawAttacker['aux']['inheritBuff'] = $rawAttacker['inheritBuff'];
-}
-$rawAttacker['aux'] = Json::encode($rawAttacker['aux']);
-$rawAttacker['owner'] = 0;
-
-$defenderList = [];
-foreach($rawDefenderList as $idx=>$rawDefenderGeneral){
-    $v = new Validator($rawDefenderGeneral);
-    $v->rules($generalCheck);
-    if(!$v->validate()){
-        $idx+=1;
-        Json::die([
-            'result'=>false,
-            'reason'=>"[수비자{$idx}]".$v->errorStr()
-        ]);
-    }
-    $rawDefenderGeneral['aux'] = [];
-    if(key_exists('inheritBuff', $rawDefenderGeneral)){
-        $v = new Validator($rawDefenderGeneral['inheritBuff']);
-        $v->rules($inheritBuffCheck);
-        if(!$v->validate()){
-            $idx+=1;
-            Json::die([
-                'result'=>false,
-                'reason'=>"[수비자{$idx}]".$v->errorStr()
-            ]);
-        }
-        $rawDefenderGeneral['aux']['inheritBuff'] = $rawDefenderGeneral['inheritBuff'];
-    }
-    $rawDefenderGeneral['aux'] = Json::encode($rawDefenderGeneral['aux']);
-    $rawDefenderGeneral['owner'] = 0;
-
-    $defenderList[] = new General($rawDefenderGeneral, extractRankVar($rawDefenderGeneral), $rawDefenderCity, $rawAttackerNation, $year, $month, true);
-}
-
-
 $cityCheck = [
     'required' => [
         'city', 'nation', 'supply', 'name',
@@ -293,17 +177,157 @@ if(!$v->validate()){
     ]);
 }
 
+$generalCheck = [
+    'required' => [
+        'no', 'name', 'nation', 'turntime', 'personal', 'special2', 'crew', 'crewtype', 'atmos', 'train',
+        'intel', 'intel_exp', 'book', 'strength', 'strength_exp', 'weapon', 'injury', 'leadership', 'leadership_exp', 'horse', 'item',
+        'explevel', 'experience', 'dedication', 'officer_level', 'officer_city', 'gold', 'rice', 'dex1', 'dex2', 'dex3', 'dex4', 'dex5',
+        'recent_war', 'warnum', 'killnum', 'killcrew',
+    ],
+    'integer' => [
+        'no', 'nation', 'crew', 'crewtype', 'atmos', 'train',
+        'intel', 'intel_exp', 'strength', 'strength_exp',  'injury', 'leadership', 'leadership_exp',
+        'explevel', 'experience', 'dedication', 'officer_level', 'officer_city', 'gold', 'rice', 'dex1', 'dex2', 'dex3', 'dex4', 'dex5',
+        'warnum', 'killnum', 'killcrew',
+    ],
+    'min' => [
+        ['no', 1],
+        ['nation', 1],
+        ['crew', 0],
+        ['intel', 0],
+        ['strength', 0],
+        ['leadership', 0],
+        ['experience', 0],
+        ['gold', 0],
+        ['rice', 0],
+        ['dex1', 0],
+        ['dex2', 0],
+        ['dex3', 0],
+        ['dex4', 0],
+        ['dex5', 0],
+        ['warnum', 0],
+        ['killnum', 0],
+        ['killcrew', 0],
+    ],
+    'between' => [
+        ['train', [40, GameConst::$maxTrainByWar]],
+        ['atmos', [40, GameConst::$maxAtmosByWar]],
+        ['explevel', [0, 300]],
+        ['injury', [0, 80]],
+        ['officer_level', [1, 12]]
+    ],
+    'in' => [
+        ['personal', array_merge(GameConst::$availablePersonality, GameConst::$optionalPersonality)],
+        ['special2', array_merge(GameConst::$availableSpecialWar, GameConst::$optionalSpecialWar)],
+        ['crewtype', array_keys(GameUnitConst::all())],
+        ['horse', array_merge(array_keys(GameConst::$allItems['horse']), ['None'])],
+        ['weapon', array_merge(array_keys(GameConst::$allItems['weapon']), ['None'])],
+        ['book', array_merge(array_keys(GameConst::$allItems['book']), ['None'])],
+        ['item', array_merge(array_keys(GameConst::$allItems['item']), ['None'])],
+    ],
+    'array' => ['inheritBuff'],
+];
+
+$inheritBuffCheck = [
+    'between' => [
+        [TriggerInheritBuff::WAR_AVOID_RATIO, [0, 5]],
+        [TriggerInheritBuff::WAR_CRITICAL_RATIO, [0, 5]],
+        [TriggerInheritBuff::WAR_MAGIC_TRIAL_PROB, [0, 5]],
+
+        [TriggerInheritBuff::OPPOSE_WAR_AVOID_RATIO, [0, 5]],
+        [TriggerInheritBuff::OPPOSE_WAR_CRITICAL_RATIO, [0, 5]],
+        [TriggerInheritBuff::OPPOSE_WAR_MAGIC_TRIAL_PROB, [0, 5]],
+    ]
+];
+
+if(!$warSeed){
+    $warSeed = bin2hex(random_bytes(16));
+}
+else {
+    $repeatCnt = 1;
+}
+$tmpRNG = new RandUtil(new LiteHashDRBG($warSeed));
+
+$v = new Validator($rawAttacker);
+$v->rules($generalCheck);
+if (!$v->validate()) {
+    Json::die([
+        'result' => false,
+        'reason' => '[출병자]' . $v->errorStr()
+    ]);
+}
+$rawAttacker['aux'] = [];
+if (key_exists('inheritBuff', $rawAttacker)) {
+    $v = new Validator($rawAttacker['inheritBuff']);
+    $v->rules($inheritBuffCheck);
+    if (!$v->validate()) {
+        Json::die([
+            'result' => false,
+            'reason' => '[출병자]' . $v->errorStr()
+        ]);
+    }
+    $rawAttacker['aux']['inheritBuff'] = $rawAttacker['inheritBuff'];
+}
+$rawAttacker['aux'] = Json::encode($rawAttacker['aux']);
+$rawAttacker['owner'] = 0;
 $attackerGeneral = new General($rawAttacker, extractRankVar($rawAttacker), $rawAttackerCity, $rawAttackerNation, $year, $month);
+$attacker = new WarUnitGeneral(
+    $tmpRNG,
+    $attackerGeneral,
+    $rawAttackerNation,
+    true
+);
+
+
+/** @var WarUnit[] */
+$defenderList = [];
+
+foreach ($rawDefenderList as $idx => $rawDefenderGeneral) {
+    $v = new Validator($rawDefenderGeneral);
+    $v->rules($generalCheck);
+    if (!$v->validate()) {
+        $idx += 1;
+        Json::die([
+            'result' => false,
+            'reason' => "[수비자{$idx}]" . $v->errorStr()
+        ]);
+    }
+    $rawDefenderGeneral['aux'] = [];
+    if (key_exists('inheritBuff', $rawDefenderGeneral)) {
+        $v = new Validator($rawDefenderGeneral['inheritBuff']);
+        $v->rules($inheritBuffCheck);
+        if (!$v->validate()) {
+            $idx += 1;
+            Json::die([
+                'result' => false,
+                'reason' => "[수비자{$idx}]" . $v->errorStr()
+            ]);
+        }
+        $rawDefenderGeneral['aux']['inheritBuff'] = $rawDefenderGeneral['inheritBuff'];
+    }
+    $rawDefenderGeneral['aux'] = Json::encode($rawDefenderGeneral['aux']);
+    $rawDefenderGeneral['owner'] = 0;
+
+    $defenderGeneral = new General($rawDefenderGeneral, extractRankVar($rawDefenderGeneral), $rawDefenderCity, $rawAttackerNation, $year, $month, true);
+
+    $defenderList[] = new WarUnitGeneral(
+        $tmpRNG,
+        $defenderGeneral,
+        $rawDefenderNation,
+        false
+    );
+}
 
 if ($action == 'reorder') {
+    $noRng = NoRNG::rngInstance();
 
-    usort($defenderList, function(General $lhs, General $rhs) use ($attackerGeneral){
+    usort($defenderList, function (WarUnit $lhs, WarUnit $rhs) use ($attacker) {
-        return -(extractBattleOrder($lhs, $attackerGeneral) <=> extractBattleOrder($rhs, $attackerGeneral));
+        return - (extractBattleOrder($lhs, $attacker) <=> extractBattleOrder($rhs, $attacker));
     });
 
     $order = [];
-    foreach($defenderList as $defenderGeneral){
+    foreach ($defenderList as $defender) {
-        $order[] = $defenderGeneral->getID();
+        $order[] = $defender->getGeneral()->getID();
     }
 
     Json::die([
@@ -313,12 +337,12 @@ if($action == 'reorder'){
     ]);
 }
 
-usort($defenderList, function(General $lhs, General $rhs) use ($attackerGeneral){
+usort($defenderList, function (WarUnit $lhs, WarUnit $rhs) use ($attacker) {
-    return -(extractBattleOrder($lhs, $attackerGeneral) <=> extractBattleOrder($rhs, $attackerGeneral));
+    return - (extractBattleOrder($lhs, $attacker) <=> extractBattleOrder($rhs, $attacker));
 });
 
-$rawDefenderList = array_map(function(General $general){
+$rawDefenderList = array_map(function (WarUnit $unit) {
-    return $general->getRaw();
+    return $unit->getRaw();
 }, $defenderList);
 unset($defenderList);
 
@@ -326,7 +350,8 @@ $db = DB::db();
 $gameStor = KVStorage::getStorage($db, 'game_env');
 $startYear = $gameStor->startyear;
 
-function extractRankVar(array $rawVal):Map{
+function extractRankVar(array $rawVal): Map
+{
     $rankVars = new Map;
     foreach ($rawVal as $rawKey => $rawVal) {
         $key = RankColumn::tryFrom($rawKey);
@@ -339,9 +364,16 @@ function extractRankVar(array $rawVal):Map{
 }
 
 function simulateBattle(
-    $rawAttacker, $rawAttackerCity, $rawAttackerNation,
+    $rawAttacker,
-    $rawDefenderList, $rawDefenderCity, $rawDefenderNation,
+    $rawAttackerCity,
-    $startYear, $year, $month, $warSeed
+    $rawAttackerNation,
+    $rawDefenderList,
+    $rawDefenderCity,
+    $rawDefenderNation,
+    $startYear,
+    $year,
+    $month,
+    $warSeed
 ) {
 
     if (!$warSeed) {
@@ -359,16 +391,33 @@ function simulateBattle(
     );
     $city = new WarUnitCity($warRng, $rawDefenderCity, $rawDefenderNation, $year, $month, $startYear);
 
-    $iterDefender = new \ArrayIterator($rawDefenderList);
+    /** @var WarUnit[] */
+    $defenderList = [];
+
+    foreach ($rawDefenderList as $rawDefenderGeneral) {
+        $defenderGeneral = new General($rawDefenderGeneral, extractRankVar($rawDefenderGeneral), $rawDefenderCity, $rawAttackerNation, $year, $month, true);
+
+        $defenderList[] = new WarUnitGeneral(
+            $warRng,
+            $defenderGeneral,
+            $rawDefenderNation,
+            false
+        );
+    }
+
+    $defenderList[] = $city;
+
+
+    $iterDefender = new \ArrayIterator($defenderList);
     $iterDefender->rewind();
 
     $battleResult = [];
 
-    $attackerRice = $rawAttacker['rice'];
+    $attackerRice = $attacker->getGeneral()->getVar('rice');
     $defenderRice = 0;
 
     $getNextDefender = function (?WarUnit $prevDefender, bool $reqNext)
-        use ($warRng, $iterDefender, $rawDefenderCity, $rawDefenderNation, $year, $month, &$battleResult, &$defenderRice, $attackerGeneral) {
+    use ($iterDefender, &$battleResult, &$defenderRice, $attacker): ?WarUnit {
         if ($prevDefender !== null) {
             $prevDefender->getLogger()->rollback();
             $battleResult[] = $prevDefender;
@@ -385,35 +434,27 @@ function simulateBattle(
             return null;
         }
 
-        $defenderObj = new General($iterDefender->current(), extractRankVar($iterDefender->current()), $rawDefenderCity, $rawDefenderNation, $year, $month);
+        /** @var WarUnit */
-        if(extractBattleOrder($defenderObj, $attackerGeneral) <= 0){
+        $defender = $iterDefender->current();
+
+        if (extractBattleOrder($defender, $attacker) <= 0) {
             return null;
         }
 
-        $defenderRice += $defenderObj->getVar('rice');
+        $defenderRice += $defender->getVar('rice');
 
-        $retVal = new WarUnitGeneral(
-            $warRng,
-            $defenderObj,
-            $rawDefenderNation,
-            false
-        );
         $iterDefender->next();
-        return $retVal;
+        return $defender;
     };
 
-    $conquerCity = processWar_NG($warSeed, $attacker, $getNextDefender, $city, $year - $startYear);
+    $conquerCity = processWar_NG($warSeed, $attacker, $getNextDefender, $city);
-
-    $rawDefenderCity = $city->getRaw();
-    $updateAttackerNation = [];
-    $updateDefenderNation = [];
 
     $attackerRice -= $attacker->getVar('rice');
 
     if ($city->getPhase() > 0) {
         $rice = $city->getKilled() / 100 * 0.8;
         $rice *= $city->getCrewType()->rice;
-        $rice *= getTechCost($rawDefenderNation['tech']);
+        $rice *= getTechCost($city->getRawNation()['tech']);
         $rice *= $city->getCityTrainAtmos() / 100 - 0.2;
         Util::setRound($rice);
 
@@ -421,8 +462,8 @@ function simulateBattle(
     }
 
     $totalDead = $attacker->getKilled() + $attacker->getDead();
-    $attackerCityDead = $totalDead * 0.4;
+    //$attackerCityDead = $totalDead * 0.4;
-    $defenderCityDead = $totalDead * 0.6;
+    //$defenderCityDead = $totalDead * 0.6;
 
     return [$attacker, $city, $battleResult, $conquerCity, $attackerRice, $defenderRice];
 }
@@ -448,16 +489,24 @@ $avgWar = 0;
 $attackerActivatedSkills = [];
 $defendersActivatedSkills = [];
 
-if($warSeed){
-    $repeatCnt = 1;
-}
 
 foreach (Util::range($repeatCnt) as $repeatIdx) {
+    if($repeatIdx > 0){
+        $warSeed = bin2hex(random_bytes(16));
+    }
+
     /** @var WarUnit $attacker */
     [$attacker, $city, $battleResult, $conquerCity, $attackerRice, $defenderRice] = simulateBattle(
-        $rawAttacker, $rawAttackerCity, $rawAttackerNation,
+        $rawAttacker,
-        $rawDefenderList, $rawDefenderCity, $rawDefenderNation,
+        $rawAttackerCity,
-        $startYear, $year, $month, $warSeed
+        $rawAttackerNation,
+        $rawDefenderList,
+        $rawDefenderCity,
+        $rawDefenderNation,
+        $startYear,
+        $year,
+        $month,
+        $warSeed
     );
     $lastWarLog = Util::mapWithKey(function ($key, $values) {
         return ConvertLog(join('<br>', $values));
@@ -485,8 +534,7 @@ foreach(Util::range($repeatCnt) as $repeatIdx){
     foreach ($attacker->getActivatedSkillLog() as $skillName => $skillCnt) {
         if (!key_exists($skillName, $attackerActivatedSkills)) {
             $attackerActivatedSkills[$skillName] = $skillCnt / $repeatCnt;
-        }
+        } else {
-        else{
             $attackerActivatedSkills[$skillName] += $skillCnt / $repeatCnt;
         }
     }
@@ -500,12 +548,10 @@ foreach(Util::range($repeatCnt) as $repeatIdx){
         foreach ($defender->getActivatedSkillLog() as $skillName => $skillCnt) {
             if (!key_exists($skillName, $activatedSkills)) {
                 $activatedSkills[$skillName] = $skillCnt / $repeatCnt;
-            }
+            } else {
-            else{
                 $activatedSkills[$skillName] += $skillCnt / $repeatCnt;
             }
         }
-
     }
 }
 

hwe/process_war.php

@@ -37,16 +37,24 @@ function processWar(string $warSeed, General $attackerGeneral, array $rawAttacke
     $city = new WarUnitCity($rng, $rawDefenderCity, $rawDefenderNation, $year, $month, $startYear);
 
     $defenderIDList = $db->queryFirstColumn('SELECT no FROM general WHERE nation=%i AND city=%i AND nation!=0 and crew > 0 and rice>(crew/100) and train>=defence_train and atmos>=defence_train', $city->getVar('nation'), $city->getVar('city'));
-    $defenderList = General::createGeneralObjListFromDB($defenderIDList, null, 2);
+    $defenderGeneralList = General::createGeneralObjListFromDB($defenderIDList, null, 2);
 
-    usort($defenderList, function (General $lhs, General $rhs) use ($attackerGeneral) {
+    /** @var WarUnit[] */
-        return - (extractBattleOrder($lhs, $attackerGeneral) <=> extractBattleOrder($rhs, $attackerGeneral));
+    $defenderList = [];
+    foreach($defenderGeneralList as $defenderGeneral){
+        $defenderList[] = new WarUnitGeneral($rng, $defenderGeneral, $rawDefenderNation, false);
+    }
+
+    $defenderList[] = $city;
+
+    usort($defenderList, function (WarUnit $lhs, WarUnit $rhs) use ($attacker) {
+        return - (extractBattleOrder($lhs, $attacker) <=> extractBattleOrder($rhs, $attacker));
     });
 
     $iterDefender = new \ArrayIterator($defenderList);
     $iterDefender->rewind();
 
-    $getNextDefender = function (?WarUnit $prevDefender, bool $reqNext) use ($rng, $iterDefender, $rawDefenderNation, $rawDefenderCity, $db, $attackerGeneral) {
+    $getNextDefender = function (?WarUnit $prevDefender, bool $reqNext) use ($iterDefender, $db, $attacker) {
         if ($prevDefender !== null) {
             $prevDefender->applyDB($db);
         }
@@ -59,24 +67,16 @@ function processWar(string $warSeed, General $attackerGeneral, array $rawAttacke
             return null;
         }
 
+        /** @var WarUnit */
         $nextDefender = $iterDefender->current();
-        $nextDefender->setRawCity($rawDefenderCity);
+        if (extractBattleOrder($nextDefender, $attacker) <= 0) {
-        if (extractBattleOrder($nextDefender, $attackerGeneral) <= 0) {
             return null;
         }
-
-
-        $retVal = new WarUnitGeneral(
-            $rng,
-            $nextDefender,
-            $rawDefenderNation,
-            false
-        );
         $iterDefender->next();
-        return $retVal;
+        return $nextDefender;
     };
 
-    $conquerCity = processWar_NG($warSeed, $attacker, $getNextDefender, $city, $year - $startYear);
+    $conquerCity = processWar_NG($warSeed, $attacker, $getNextDefender, $city);
 
     $attacker->applyDB($db);
 
@@ -180,8 +180,13 @@ function processWar(string $warSeed, General $attackerGeneral, array $rawAttacke
     ], $attacker->getGeneral(), $city->getRaw());
 }
 
-function extractBattleOrder(General $general, General $attackerGeneral)
+function extractBattleOrder(WarUnit $defender, WarUnit $attacker)
 {
+    if($defender instanceof WarUnitCity){
+        return -1;
+    }
+
+    $general = $defender->getGeneral();
     if ($general->getVar('crew') == 0) {
         return 0;
     }
@@ -212,7 +217,6 @@ function processWar_NG(
     WarUnitGeneral $attacker,
     callable $getNextDefender,
     WarUnitCity $city,
-    int $relYear
 ): bool {
     $templates = new \League\Plates\Engine(__DIR__ . '/templates');