mirror of
https://github.com/openfrontio/OpenFrontIO.git
synced 2026-06-24 04:43:36 +00:00
VariableVince
515b9efa42
## Description: Some optimizations for bot & fakehuman execution. Better performance measured using profiling, at the start of a game or in singple player, but since the circumstances differ it is not a very reliable comparison. --- In BotExecution: Added getNeighborTraitorToAttack in Botbehavior to use in maybeAttack. No caching for playerNeighbors array, because although it could be re-used up to two times in selectRandomEnemy, maybeAttack runs every tick and selectEnemy only every 10 seconds so the cache overhead would not be worth it. --- In Botbehavior: Put repeated code in dedicated functions for readability, maintainance ease, and reduce the chances of forgetting to update the timestamp for enemyUpdated. Can be seen as a follow-up to PRs #434 and #946. -- In both selectEnemy and selectRandomEnemy: Put the first if this.enemy === null statement parenthesis, around the two checks below. Because if there's already an enemy (if forgetEnemies hasn't nullified it, enemy === null is false at the first if statement), then enemy === null will still be false for the two checks below the first. No need to check it thrice then. Once inside the first if statement (when enemy === null is true), then we need to check it two times more in case the code inside already set an enemy. -- In selectEnemy under 'Prefer neighboring bots': Removed unneccessary check for enemy === null. Replaced sort with more performant for loop. -- In selectRandomEnemy: Under 'Select a traitor as an enemy', if a traitor is a friendly player, they got less odds to be chosen as enemy over an unfriendly player, but they weren't ruled out. While below in the Sanity Check, we specifically rule out friendly players as enemy and set enemy=null. So excluded friendly players under 'Select a traitor as an enemy' instead of only giving them lower odds. Use the new shared method getNeighborTraitorToAttack. -- In checkIncomingAttacks, since we're only interested in the max value, replaced sort with loop that makes a single pass through the attacks to find the largest one. -- For shouldAcceptAllianceRequest, #1049 added tests and improved readability of Alliance requests. It may have also deoptimized it a bit. Const notTooManyAlliances would, in the past, not be computed if requestorIsMuchLarger was already found to be true. Since the readability changes, tooManyAlliances was always computed regardless of the value of requestorIsMuchLarger. This PR attempts to address this too, while still keeping it as readable hopefully. Also choose for early returns to optimize a bit more. So if isTraitor is true, don't compute any further and just return false immediately etc. Switched the order of testing for noMalice and isTraitor. Traitor status used to be throughout the game, now it's only 30 seconds or will be maybe 45 seconds to 1 minute. So the chances of someone asking for alliance and being a traitor at the same time have decreased. isMalice chances could be bigger. Removed the named constants and choose to put them in comments, so readability should be about the same as #1049 intended. Kept the braces for the if statements because otherwise Prettier would misalign the comments.) ## Please complete the following: - [x] I have added screenshots for all UI updates - [x] I process any text displayed to the user through translateText() and I've added it to the en.json file - [x] I have added relevant tests to the test directory - [x] I confirm I have thoroughly tested these changes and take full responsibility for any bugs introduced - [x] I understand that submitting code with bugs that could have been caught through manual testing blocks releases and new features for all contributors ## Please put your Discord username so you can be contacted if a bug or regression is found: tryout33
89 lines
2.3 KiB
TypeScript
89 lines
2.3 KiB
TypeScript
import { Execution, Game, Player } from "../game/Game";
|
|
import { PseudoRandom } from "../PseudoRandom";
|
|
import { simpleHash } from "../Util";
|
|
import { BotBehavior } from "./utils/BotBehavior";
|
|
|
|
export class BotExecution implements Execution {
|
|
private active = true;
|
|
private random: PseudoRandom;
|
|
private mg: Game;
|
|
private neighborsTerraNullius = true;
|
|
|
|
private behavior: BotBehavior | null = null;
|
|
private attackRate: number;
|
|
private attackTick: number;
|
|
private triggerRatio: number;
|
|
private reserveRatio: number;
|
|
|
|
constructor(private bot: Player) {
|
|
this.random = new PseudoRandom(simpleHash(bot.id()));
|
|
this.attackRate = this.random.nextInt(40, 80);
|
|
this.attackTick = this.random.nextInt(0, this.attackRate);
|
|
this.triggerRatio = this.random.nextInt(60, 90) / 100;
|
|
this.reserveRatio = this.random.nextInt(30, 60) / 100;
|
|
}
|
|
|
|
activeDuringSpawnPhase(): boolean {
|
|
return false;
|
|
}
|
|
|
|
init(mg: Game) {
|
|
this.mg = mg;
|
|
this.bot.setTargetTroopRatio(0.7);
|
|
}
|
|
|
|
tick(ticks: number) {
|
|
if (ticks % this.attackRate !== this.attackTick) return;
|
|
|
|
if (!this.bot.isAlive()) {
|
|
this.active = false;
|
|
return;
|
|
}
|
|
|
|
if (this.behavior === null) {
|
|
this.behavior = new BotBehavior(
|
|
this.random,
|
|
this.mg,
|
|
this.bot,
|
|
this.triggerRatio,
|
|
this.reserveRatio,
|
|
);
|
|
}
|
|
|
|
this.behavior.handleAllianceRequests();
|
|
this.maybeAttack();
|
|
}
|
|
|
|
private maybeAttack() {
|
|
if (this.behavior === null) {
|
|
throw new Error("not initialized");
|
|
}
|
|
const toAttack = this.behavior.getNeighborTraitorToAttack();
|
|
if (toAttack !== null) {
|
|
const odds = this.bot.isFriendly(toAttack) ? 6 : 3;
|
|
if (this.random.chance(odds)) {
|
|
this.behavior.sendAttack(toAttack);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (this.neighborsTerraNullius) {
|
|
if (this.bot.sharesBorderWith(this.mg.terraNullius())) {
|
|
this.behavior.sendAttack(this.mg.terraNullius());
|
|
return;
|
|
}
|
|
this.neighborsTerraNullius = false;
|
|
}
|
|
|
|
this.behavior.forgetOldEnemies();
|
|
const enemy = this.behavior.selectRandomEnemy();
|
|
if (!enemy) return;
|
|
if (!this.bot.sharesBorderWith(enemy)) return;
|
|
this.behavior.sendAttack(enemy);
|
|
}
|
|
|
|
isActive(): boolean {
|
|
return this.active;
|
|
}
|
|
}
|