feat: predecessors

Author: Sciator

ui/src/logic/game/game.ts

@@ -14,7 +14,7 @@ export type GameSettings = {
   },
   game: {
     playerSize: number,
-    maxGameLength: number,
+    // maxGameLength: number,
   },
   map: {
     size: number,
@@ -77,7 +77,7 @@ export type GameState = {
   bullets: GameStateBullet[],
   /** index of game winner, if -1 game isn't over yet -2 if game is draw */
   winner: number,
-  timeRemaining: number,
+  // timeRemaining: number,
 };
 
 export type SensorPoint = { point: Vector, type: "none" | "unknown" | EGameStateObjectType };
@@ -125,7 +125,7 @@ export class Game {
     },
     game: {
       playerSize: 10,
-      maxGameLength: 10_000,
+      // maxGameLength: 10_000,
     },
     simulation: {
       delta: 32,
@@ -142,11 +142,14 @@ export class Game {
     this.applyInput(userInput);
 
     const delta = deltaOveride || deltaSettings;
-    this.gameState.timeRemaining -= delta;
+    // this.gameState.timeRemaining -= delta;
+
+    // if (this.gameState.timeRemaining <= 0) {
+    //   players.forEach(x => x.health = 0);
+    // }
+
+    players.forEach(x => { x.health -= .002; });
 
-    if (this.gameState.timeRemaining <= 0) {
-      players.forEach(x => x.health = 0);
-    }
 
     Engine.update(engine, delta);
 
@@ -176,11 +179,9 @@ export class Game {
         let vec = Vector.rotate(Vector.create(1, 0), body.angle);
         vec = Vector.mult(vec, 5);
         Body.setVelocity(body, vec);
-        player.health -= .0005;
       }
       if (x.rotate !== 0) {
         Body.setAngularVelocity(body, x.rotate * .3);
-        player.health -= Math.abs(x.rotate) * .005;
       }
       if (x.use) {
         this.use(player);
@@ -206,9 +207,10 @@ export class Game {
       World.remove(world, x.p.body);
     });
 
-    if (alivePlayers.length === 1) {
+    if (alivePlayers.length === 1 && alivePlayers[0].p.health >= .05) {
       this.gameState.winner = alivePlayers[0].i;
     } else if (alivePlayers.length === 0) {
+      deadPlayers.forEach(x => x.p.health = 0);
       this.gameState.winner = -2;
     }
   }
@@ -237,8 +239,8 @@ export class Game {
     const { body: { position, angle }, item } = player;
     const { gameState: { bullets }, settings: { game: { playerSize } } } = this;
 
-    if (item.cooldown !== 0){
-      player.health -= .2;
+    if (item.cooldown !== 0) {
+      // player.health -= .2;
       return;
     }
     item.cooldown = itemCooldown;
@@ -260,6 +262,7 @@ export class Game {
       health: 1,
       body,
     });
+    // player.health -= .1;
   }
 
   // todo: move all sensor related things into GameAI folder
@@ -331,7 +334,7 @@ export class Game {
     World.add(world, players);
 
     this.gameState = {
-      walls: walls.map(x=>({body:x, health:Infinity, type:EGameStateObjectType.wall})),
+      walls: walls.map(x => ({ body: x, health: Infinity, type: EGameStateObjectType.wall })),
       players: players.map((body) =>
       ({
         type: EGameStateObjectType.player,
@@ -342,7 +345,7 @@ export class Game {
       ),
       bullets: [],
       winner: -1,
-      timeRemaining: settings.game.maxGameLength,
+      // timeRemaining: settings.game.maxGameLength,
     };
 
     Events.on(this.engine, "collisionStart", this.onCollision.bind(this));

ui/src/logic/gameAi/GameAiEval.ts

@@ -1,6 +1,6 @@
 import { Vector } from "matter-js";
 import { IANNInitParams, NeuralNet } from "../ai/nn/nn";
-import { EGameStateObjectType, Game, GameInputPlayer, GameSettings, SensorPoint } from "../game/game";
+import { EGameStateObjectType, Game, GameInputPlayer, GameSettings, GameState, SensorPoint } from "../game/game";
 
 
 export type InitializeRandomBotParams = {
@@ -53,7 +53,9 @@ export class GameAiEval {
   public static NN_OUTPUTS = 4;
   /** returns number of nn inputs for given sensors array */
   public static NN_INPUTS_GET({ sensors }: { sensors: number[] | { length: number } }) {
-    return (sensors.length * 2 + 1) * 2;
+    return (sensors.length * 2 + 1) * 2
+      // health + cooldown
+      + 2;
   }
 
   public static initializeRandomBot(params: InitializeRandomBotParams): NeuralNet {
@@ -65,9 +67,9 @@ export class GameAiEval {
     });
   }
 
-  private sensorAsNumbers(playerIndex: number, points: SensorPoint[]): number[] {
+  private botInputs(playerIndex: number, points: SensorPoint[]): number[] {
     const { gameState: { players } } = this.game;
-    const { body: { position } } = players[playerIndex];
+    const { body: { position }, health, item: { cooldown } } = players[playerIndex];
 
     const numbers: number[] = [];
 
@@ -76,6 +78,8 @@ export class GameAiEval {
       numbers.push(dist(point, position), numFromType(type));
     }
 
+    numbers.push(health, cooldown);
+
     return numbers;
   }
 
@@ -100,7 +104,7 @@ export class GameAiEval {
   public calculateBotResponse() {
     const { game } = this;
     const { gameState: { players } } = this.game;
-    const sensorsResults = players.map((_, i) => this.sensorAsNumbers(i, game.sensor(i)));
+    const sensorsResults = players.map((_, i) => this.botInputs(i, game.sensor(i)));
     const botsNNResults = sensorsResults.map((x, i) => this.playerNNs[i].predict(x));
     const botsActions = botsNNResults.map(x => this.inputFromNN(x));
 

ui/src/logic/gameAi/GameAiLiveTrain.ts

@@ -16,6 +16,8 @@ export type Bot = {
   wins: number,
   lastGame: number,
   nn: NeuralNet,
+  children: number,
+  predecessors: number[],
 };
 
 
@@ -26,7 +28,7 @@ export class GameAiLiveTrain {
     /** for how many games has bot healths */
     healthMultiplier: 4,
     /** how many hp will player get after game when survives */
-    healthGrowAfterGame: .2,
+    healthGrowAfterGame: 1.4,
     sensors: [Math.PI * 1 / 4, Math.PI * 1 / 8, Math.PI * 1 / 32],
   };
 
@@ -36,7 +38,9 @@ export class GameAiLiveTrain {
     const bots = this.bots;
 
     const selectedIndex: number[] = math.pickRandom(
-      range(bots.length), 2, bots.map(x => Math.max(1, (x.lastGame - 1000) ** 3 - x.games + x.bonus + x.wins ** 2))
+      range(bots.length), 2, bots.map(x => Math.max(1,
+        ((1 - x.health) * 10) ** 2 + x.lastGame - x.games - x.bonus + (x.wins) ** 2
+      ))
     ) as any;
 
     const selected = selectedIndex.map(x => bots[x]);
@@ -75,10 +79,9 @@ export class GameAiLiveTrain {
     const resHealth = evaler.game.gameState.players.map(x => x.health);
     resHealth.forEach((x, i) => {
       const bot = selected[i];
-      bot.health += x / healthMultiplier;
-      if (x > 0) bot.health += healthGrowAfterGame/healthMultiplier;
+      bot.health += healthGrowAfterGame * x / healthMultiplier;
 
-      const exceedingHealth = (bot.health - healthMultiplier)*healthMultiplier;
+      const exceedingHealth = (bot.health - healthMultiplier) * healthMultiplier;
       if (exceedingHealth > 0) {
         bot.health = this.params.healthMultiplier;
         const bonusMultiplier =
@@ -101,8 +104,14 @@ export class GameAiLiveTrain {
 
     selected.forEach(x => { x.lastGame = 0; x.games++; });
 
-    if (populationToMaxFrac > .9) {
-      bots.map(x => x.bonus += .05);
+    if (populationToMaxFrac > .75) {
+      bots.forEach(x => {
+        x.bonus = Math.min(x.bonus * 5 + populationToMaxFrac, 2)
+      });
+    };
+
+    if (populationToMaxFrac > .8) {
+      bots.map(x => x.bonus += .01 * populationToMaxFrac);
     }
 
     if (bots.length < 10)
@@ -124,9 +133,11 @@ export class GameAiLiveTrain {
       const bot = bots[i];
       if (bot.bonus < 1) continue;
 
+      const ci = bot.children++;
+      const predecessors = bot.predecessors.concat(ci);
       console.log("new bot created");
       bot.bonus--;
-      bots.push({ bonus: 0, games: 0, wins: 0, health: this.params.healthMultiplier, lastGame: 0, nn: bot.nn.mutate(.01) });
+      bots.push({ bonus: 0, games: 0, wins: 0, health: 1, lastGame: 0, nn: bot.nn.mutate(.01), children: 0, predecessors });
     }
   }
 
@@ -136,13 +147,15 @@ export class GameAiLiveTrain {
     const { hiddens } = constructorParams;
     const { sensors } = params;
 
-    this.bots = range(params.maxPop).map(() => ({
+    this.bots = range(params.maxPop).map((i) => ({
       bonus: 0,
-      health: params.healthMultiplier,
+      health: 1,
       games: 0,
       wins: 0,
       lastGame: 0,
       nn: GameAiEval.initializeRandomBot({ hiddens, sensors }),
+      children: 0,
+      predecessors: [i],
     }));
   }
 }

ui/src/views/MainPage.tsx

@@ -1,5 +1,5 @@
 import { Card, Row, Col } from "antd";
-import React, { useState } from "react";
+import React, { useCallback, useState } from "react";
 import { PlayPage } from "./Play";
 import { RunAI } from "./RunAI";
 import { NeuralNet } from "../logic/ai/nn/nn";
@@ -19,6 +19,8 @@ export const MainPage: React.FC<TMainPageProps> = () => {
   // const [aiSettings, setAiSettings] = useState<TSettingState>(defaultInitParams as any);
   const [snapshot, setSnapshot] = useState<NeuralNet[] | undefined>(undefined);
 
+  const callback = useCallback((e: NeuralNet[]) => setSnapshot(e), []);
+
   return <>
     <Card>
       <Row gutter={[8, 0]}>
@@ -29,7 +31,7 @@ export const MainPage: React.FC<TMainPageProps> = () => {
         {/* <Col sm={8}> */}
         <Row gutter={[8, 8]}>
           <Col sm={8}>
-            <RunAI onSnapshot={(e) => setSnapshot(e)} />
+            <RunAI onSnapshot={callback} />
           </Col>
           <Col sm={16}>
             <PlayPage snapshot={snapshot} />

ui/src/views/RunAI.tsx

@@ -16,7 +16,7 @@ const targetDeltaTime = 1_000 / fps;
 
 type BotSnapshot = { bots: Bot[], popsize: number };
 const createBotSnapshot = (bots: Bot[], samples: number): BotSnapshot => {
-  return { bots: bots.slice(0, samples).map(x => ({ ...x })), popsize: bots.length };
+  return { bots: bots.slice(0, samples).map(x => ({ ...x, predecessors: x.predecessors.slice() })), popsize: bots.length };
 };
 
 
@@ -28,11 +28,14 @@ const BotData = ({ popsize, bots, calculations }: BotSnapshot & { calculations:
   </Row>
   <Row gutter={[0, 12]}>
     {
-      bots.map(({ bonus, games, health, lastGame, wins }) => {
+      bots.map(({ bonus, games, health, lastGame, wins, children, predecessors }) => {
         return <Col sm={24}>
           <Card>
             <Row>
               <Col sm={18}>
+                <Row>
+                  {predecessors.map(x => x.toString(16).padStart(4, "0")).join("-")}
+                </Row>
                 <Row>
                   <Progress percent={bonus * 100} status={"active"} strokeColor={"#f4f711"} format={() => ""}></Progress>
                 </Row>
@@ -43,13 +46,16 @@ const BotData = ({ popsize, bots, calculations }: BotSnapshot & { calculations:
               <Col sm={6}>
                 <Row>
                   {games.toLocaleString().padStart(5, " ")} : Games
-            </Row>
+                </Row>
                 <Row>
                   {wins.toLocaleString().padStart(5, " ")} : Wins
-            </Row>
+                </Row>
+                <Row>
+                  {children.toLocaleString().padStart(5, " ")} : children
+                </Row>
                 <Row>
                   {lastGame.toLocaleString().padStart(5, " ")} : last
-            </Row>
+                </Row>
               </Col>
             </Row>
           </Card>
@@ -68,6 +74,8 @@ const fakeSnapshot: BotSnapshot = {
     games: randInt(1000),
     lastGame: randInt(1000),
     nn: undefined as any,
+    children: randInt(1000),
+    predecessors: range(randInt(1, 5)).map(() => randInt(100)),
   })), popsize: 100,
 };
 
@@ -108,7 +116,7 @@ export const RunAI: React.FC<TRunProps> = ({ onSnapshot }) => {
 
     setTimeout(() => {
       setLastUpdate(Date.now());
-    });
+    }, 15);
   }, [lastUpdate, setLastUpdate, running, onSnapshot]);