První 3 monstra z plánovaných pěti. Kompletní pathfinding i zrcadlení do clienta. Útoky implementované nejsou. Lurk a Neko jsou hardcoded aby útočili na P1.

FNAF_Server/CommandProcessor.cs

@@ -11,6 +11,7 @@ public class CommandProcessor {
             switch (playerCommand.ID){
                 case 0:
                     Console.WriteLine($"C: Player {pid} switched to camera {playerCommand.Args[0]}");
+                    currentPlayer.state.camera = playerCommand.Args[0];
                     Server.SendUpdateToAll([GameEvent.SWITCH_CAM(pid, playerCommand.Args[0])]);
                     break;
                 case 1:
@@ -20,8 +21,10 @@ public class CommandProcessor {
                     Server.SendUpdateToAll([GameEvent.TOGGLE_MONITOR(pid, monitorState)]);
                     break;
                 case 2:
-                    bool doorState = playerCommand.Args[1] == 1;
+                    bool doorState = playerCommand.Args[1] == 1; // TODO: block office doors
                     currentPlayer.state.doorStates[playerCommand.Args[0]] = doorState;
+                    MapManager.Get(currentPlayer.state.officeTileId).GetConnector(currentPlayer.state.neighbouringTiles[playerCommand.Args[0]]).Blocked = doorState;
+                    
                     Console.WriteLine($"C: Player {pid} {(doorState ? "closed" : "opened")} door {playerCommand.Args[0]}");
                     Server.SendUpdateToAll([GameEvent.TOGGLE_DOOR_OFFICE(pid,playerCommand.Args[0] ,doorState)]);
                     break;

FNAF_Server/Enemies/Enemy.cs

@@ -0,0 +1,26 @@
+using FNAF_Server.Map;
+using GlobalClassLib;
+
+namespace FNAF_Server.Enemies;
+
+public abstract class Enemy : GlobalEnemy<MapTile, TileConnector> {
+    protected Enemy(int difficulty) : base(difficulty) {
+    }
+
+    public abstract bool BlocksTile { get; set; }
+    public bool Spawned { get; set; }
+    
+    public virtual void SpawnSilent(MapTile location) {
+        Console.WriteLine($"!!! Silent spawn not implemented for enemy {TypeId} ({Name}), reverting to regular spawn");
+        Spawn(location);
+    }
+
+    public override void Spawn(MapTile location) {
+        base.Spawn(location);
+        Spawned = true;
+        // EnemyManager.AddEnemy(this);
+    }
+
+    public abstract void Reset();
+    public abstract void Attack(ServerPlayer player);
+}

FNAF_Server/Enemies/EnemyManager.cs

@@ -0,0 +1,29 @@
+using FNAF_Server.Map;
+
+namespace FNAF_Server.Enemies;
+
+public class EnemyManager {
+    private static Dictionary<int, Enemy> enemies = new();
+
+    public static void Update() {
+        foreach (var pair in enemies){
+            if (pair.Value.Spawned) pair.Value.Update();
+        }
+    }
+
+    public static Enemy AddEnemy(Enemy enemy) {
+        enemies.Add(enemy.Id, enemy);
+        return enemy;
+    }
+    
+    public static Enemy[] GetByLocation(MapTile tile) {
+        List<Enemy> output = new();
+        foreach (var e in enemies.Values){
+            if (e.Location == tile){
+                output.Add(e);
+            }
+        }
+
+        return output.ToArray();
+    }
+}

FNAF_Server/Enemies/LurkEnemy.cs

@@ -0,0 +1,118 @@
+using System.Diagnostics;
+using System.Reflection;
+using FNAF_Server.Map;
+using GlobalClassLib;
+using PacketLib;
+
+namespace FNAF_Server.Enemies;
+
+public class LurkEnemy : Enemy {
+    public override string Name{ get; } = "Lurk";
+    public override int TypeId{ get; } = (int)EnemyType.LURK;
+
+    public override bool BlocksTile{ get; set; } = true;
+
+    private LurkPathfinder pathfinder;
+    
+    // private int movementRollInterval = 5000;
+    // private static readonly double CHANCE_DENOMINATOR = 2 + Math.Pow(1.5f, 10); // d10 Lurk will have a 100% chance to move
+    // private double movementChance => (2 + Math.Pow(1.5f, Difficulty)) / CHANCE_DENOMINATOR; // chance scales exponentially using a constant multiplier
+    
+    private MovementOpportunity movementOpportunity;
+
+    public LurkEnemy(int difficulty) : base(difficulty) {
+        pathfinder = new LurkPathfinder(this, 1);
+    }
+    public override void Spawn(MapTile location) {
+        base.Spawn(location);
+        // stopwatch.Start();
+        movementOpportunity = new MovementOpportunity(5000, ((2 + Math.Pow(1.5f, Difficulty)) * Math.Sign(Difficulty)) / (2 + Math.Pow(1.5f, 10)));
+        movementOpportunity.Start();
+        pathfinder.takenPath.Add(Location);
+        Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(TypeId, Id, Difficulty, Location.Id)]);
+    }
+
+    public override void Reset() {
+        pathfinder.takenPath.Clear();
+        pathfinder.takenPath.Add(Location);
+        
+        MapTile[] resetLocations = new[]{MapManager.Get(7), MapManager.Get(12), MapManager.Get(17)}.Where(t => EnemyManager.GetByLocation(t).Length == 0).ToArray();
+        Location = resetLocations[new Random().Next(resetLocations.Length)];
+        Server.SendUpdateToAll([GameEvent.ENEMY_RESET(Id, Location.Id)]);
+    }
+
+    public override void Attack(ServerPlayer player) {
+        throw new NotImplementedException();
+    }
+
+
+    public override void Update() {
+        base.Update();
+
+        if (movementOpportunity.CheckAndRoll()){
+            Pathfinder.Decision decision = pathfinder.DecideNext(MapManager.Get(10));
+            switch (decision.type){
+                case Pathfinder.Decision.MoveType:
+                    Location = decision.nextTile!;
+                    Server.SendUpdateToAll([GameEvent.ENEMY_MOVEMENT(Id, Location.Id)]);
+                    Console.WriteLine($"Enemy {TypeId} ({Name}) moving to {Location.PositionAsString})");
+                    break;
+                case Pathfinder.Decision.AttackType:
+                    throw new NotImplementedException();
+                case Pathfinder.Decision.ResetType:
+                    Reset();
+                    break;
+                case Pathfinder.Decision.WaitType:
+                    break;
+            }
+        }
+    }
+    
+    private class LurkPathfinder : RoamingPathfinder {
+        // public override List<MapTile> FindPath(MapTile start, MapTile end) {
+        //     throw new NotImplementedException();
+        // }
+        
+        private Random random = new();
+
+        private int tolerance;
+        public List<MapTile> takenPath = new();
+
+        public LurkPathfinder(Enemy enemy, int tolerance) : base(enemy) {
+            this.tolerance = tolerance;
+        }
+        
+        public override Decision DecideNext(MapTile goal) {
+            Dictionary<MapTile, int> distances = Crawl(goal);
+            
+            List<MapTile> closerTiles = GetNeighbours(Enemy.Location,
+                c => !c.Blocked || c.Type == ConnectorType.DOOR_OFFICE, 
+                t => distances.ContainsKey(t) && distances[t] <= distances[Enemy.Location] + tolerance);
+            if (closerTiles.Contains(goal)){
+                if (Enemy.Location.GetConnector(goal)!.Blocked){
+                    return Decision.Reset();
+                }
+
+                return Decision.Attack(Server.P1); // TODO: un-hardcode this
+            }
+            
+            if (closerTiles.Count != 0 && closerTiles.All(t => takenPath.Contains(t))){
+                takenPath.Clear();
+                return DecideNext(goal);
+            }
+            closerTiles.RemoveAll(t => takenPath.Contains(t));
+            
+            closerTiles.ForEach(t => distances[t] += Enemy.Location.GetConnector(t)!.Value);
+            double roll = random.NextDouble() * closerTiles.Sum(t => 1.0 / distances[t]);
+            foreach (var tile in closerTiles){
+                if (roll <= 1.0 / distances[tile]){
+                    takenPath.Add(tile);
+                    return Decision.Move(tile);
+                }
+                roll -= 1.0 / distances[tile];
+            }
+
+            return Decision.Wait();
+        }
+    }
+}

FNAF_Server/Enemies/MovementOpportunity.cs

@@ -0,0 +1,60 @@
+using System.Diagnostics;
+
+namespace FNAF_Server.Enemies;
+
+public class MovementOpportunity {
+    public int Interval{ get; set; }
+    // public double ChanceDenominator;
+    public double MovementChance{ get; set; }
+
+    public bool Running => stopwatch.IsRunning;
+
+    public bool ConstantChance{ get; private set; }
+    
+    private Stopwatch stopwatch = new();
+    private int stopwatchOffset = 0;
+    
+    private Random random = new();
+
+    public MovementOpportunity(int intervalMs, double movementChance) {
+        Interval = intervalMs;
+        MovementChance = movementChance;
+        GuaranteeSuccess(false);
+        ConstantChance = true; // unused
+    }
+
+    public MovementOpportunity(int intervalMs) {
+        Interval = intervalMs;
+        GuaranteeSuccess(true);
+        MovementChance = 1;
+    }
+
+    public void Start() {
+        stopwatch.Start();
+    }
+    public void Stop() {
+        stopwatch.Stop();
+    }
+
+    public bool Check() {
+        if (stopwatch.ElapsedMilliseconds + stopwatchOffset >= Interval){
+            stopwatchOffset = (int)(stopwatch.ElapsedMilliseconds - Interval);
+            stopwatch.Restart();
+            return true;
+        }
+        return false;
+    }
+
+    public bool Roll() => roll();
+    private Func<bool> roll = () => true;
+    
+    public bool CheckAndRoll() {
+        if (Check()) return Roll();
+        return false;
+    }
+
+    public void GuaranteeSuccess(bool value) {
+        roll = value ? () => true : () => random.NextDouble() <= MovementChance;
+    }
+
+}

FNAF_Server/Enemies/NekoEnemy.cs

@@ -0,0 +1,106 @@
+using FNAF_Server.Map;
+using GlobalClassLib;
+using PacketLib;
+
+namespace FNAF_Server.Enemies;
+
+public class NekoEnemy : Enemy {
+    private MovementOpportunity movementOpportunity;
+    private NekoPathfinder pathfinder;
+    
+    public NekoEnemy(int difficulty) : base(difficulty) {
+        pathfinder = new NekoPathfinder(this, 1);
+    }
+    
+    public override string Name{ get; } = "Neko";
+    public override int TypeId{ get; } = 1;
+    public override bool BlocksTile{ get; set; } = true;
+    
+    
+    public override void Spawn(MapTile location) {
+        base.Spawn(location);
+        // stopwatch.Start();
+        movementOpportunity = new MovementOpportunity(5000, ((2 + Math.Pow(1.5f, Difficulty)) * Math.Sign(Difficulty)) / (2 + Math.Pow(1.5f, 10)));
+        movementOpportunity.Start();
+        pathfinder.takenPath.Add(Location);
+        Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(TypeId, Id, Difficulty, Location.Id)]);
+    }
+
+    public override void Reset() {
+        pathfinder.takenPath.Clear();
+        MapTile[] resetLocations = new[]{MapManager.Get(7), MapManager.Get(12), MapManager.Get(17)}.Where(t => EnemyManager.GetByLocation(t).Length == 0).ToArray();
+        Location = resetLocations[new Random().Next(resetLocations.Length)];
+        Server.SendUpdateToAll([GameEvent.ENEMY_RESET(Id, Location.Id)]);
+    }
+
+    public override void Attack(ServerPlayer player) {
+        throw new NotImplementedException();
+    }
+
+
+    public override void Update() {
+        base.Update();
+
+        if (movementOpportunity.CheckAndRoll()){
+            Pathfinder.Decision decision = pathfinder.DecideNext(MapManager.Get(10));
+            switch (decision.type){
+                case Pathfinder.Decision.MoveType:
+                    Location = decision.nextTile!;
+                    Server.SendUpdateToAll([GameEvent.ENEMY_MOVEMENT(Id, Location.Id)]);
+                    Console.WriteLine($"Enemy {TypeId} ({Name}) moving to {Location.PositionAsString})");
+                    break;
+                case Pathfinder.Decision.AttackType:
+                    throw new NotImplementedException();
+                case Pathfinder.Decision.ResetType:
+                    Reset();
+                    break;
+                case Pathfinder.Decision.WaitType:
+                    break;
+            }
+        }
+    }
+
+    private class NekoPathfinder : RoamingPathfinder {
+        private Random random = new();
+
+        private int tolerance;
+        public List<MapTile> takenPath = new();
+
+        public NekoPathfinder(Enemy enemy, int tolerance) : base(enemy) {
+            this.tolerance = tolerance;
+        }
+        
+        public override Decision DecideNext(MapTile goal) {
+            Dictionary<MapTile, int> distances = Crawl(goal);
+            
+            List<MapTile> closerTiles = GetNeighbours(Enemy.Location, 
+                c => !c.Blocked || c.Type == ConnectorType.DOOR_OFFICE, 
+                t => distances.ContainsKey(t) && distances[t] <= distances[Enemy.Location] + tolerance);
+            if (closerTiles.Contains(goal)){
+                if (Enemy.Location.GetConnector(goal)!.Blocked){
+                    return Decision.Reset();
+                }
+
+                return Decision.Attack(Server.P1); // TODO: un-hardcode this
+            }
+            
+            if (closerTiles.Count != 0 && closerTiles.All(t => takenPath.Contains(t))){
+                takenPath.Clear();
+                return DecideNext(goal);
+            }
+            closerTiles.RemoveAll(t => takenPath.Contains(t));
+            
+            closerTiles.ForEach(t => distances[t] += Enemy.Location.GetConnector(t)!.Value);
+            double roll = random.NextDouble() * closerTiles.Sum(t => 1.0 / distances[t]);
+            foreach (var tile in closerTiles){
+                if (roll <= 1.0 / distances[tile]){
+                    takenPath.Add(tile);
+                    return Decision.Move(tile);
+                }
+                roll -= 1.0 / distances[tile];
+            }
+
+            return Decision.Wait();
+        }
+    }
+}

FNAF_Server/Enemies/Pathfinder.cs

@@ -0,0 +1,36 @@
+using FNAF_Server.Map;
+
+namespace FNAF_Server.Enemies;
+
+public abstract class Pathfinder {
+    public Enemy Enemy;
+    public Pathfinder(Enemy enemy) {
+        Enemy = enemy;
+    }
+    public abstract Decision DecideNext(MapTile goal);
+    // protected abstract Dictionary<MapTile, int> Crawl(MapTile tile); // fill Distances with all reachable tiles
+
+    protected virtual List<MapTile> GetNeighbours(MapTile tile, Predicate<TileConnector> connectorFilter, Predicate<MapTile> tileFilter) {
+        return tile.GetAllConnectors().Where(c => connectorFilter(c)).Select(c => c.OtherTile(tile)).Where(t => tileFilter(t)).ToList();
+    }
+    
+    public class Decision {
+        public int type;
+        
+        public MapTile? nextTile;
+        public ServerPlayer? attackTarget;
+
+        private Decision() { }
+        
+        public static Decision Move(MapTile tile) => new() { type = MoveType, nextTile = tile };
+        public static Decision Attack(ServerPlayer player) => new(){ type = AttackType, attackTarget = player };
+        public static Decision Reset() => new(){ type = ResetType };
+        public static Decision Wait() => new(){ type = WaitType };
+
+        public const int MoveType = 0;
+        public const int AttackType = 1;
+        public const int ResetType = 2;
+        public const int WaitType = 3;
+
+    }
+}

FNAF_Server/Enemies/RoamingPathfinder.cs

@@ -0,0 +1,29 @@
+using FNAF_Server.Map;
+using GlobalClassLib;
+
+namespace FNAF_Server.Enemies;
+
+public abstract class RoamingPathfinder : Pathfinder{
+    protected RoamingPathfinder(Enemy enemy) : base(enemy) {
+    }
+    
+    protected Dictionary<MapTile, int> Crawl(MapTile tile) {
+        Dictionary<MapTile, int> distances = new(){ [tile] = 0 };
+        CrawlStep(tile, distances);
+        return distances;
+    }
+        
+    private void CrawlStep(MapTile tile, Dictionary<MapTile, int> distances) {
+        List<MapTile> neighbours = GetNeighbours(tile, 
+            c => (!c.Blocked || c.Type == ConnectorType.DOOR_OFFICE) && tile != Enemy.Location,
+            t => 
+                (!distances.ContainsKey(t) || distances[t] > distances[tile]) && 
+                (!Enemy.BlocksTile || EnemyManager.GetByLocation(t).All(e => !e.BlocksTile || e == Enemy)));
+            
+        neighbours.ForEach(t => distances[t] = distances[tile] + tile.GetConnector(t)!.Value);
+            
+        if (neighbours.Count != 0){
+            neighbours.ForEach(t => CrawlStep(t, distances));
+        }
+    }
+}

FNAF_Server/Enemies/SpotEnemy.cs

@@ -0,0 +1,95 @@
+using FNAF_Server.Map;
+using GlobalClassLib;
+using PacketLib;
+
+namespace FNAF_Server.Enemies;
+
+public class SpotEnemy : Enemy {
+    public SpotEnemy(int difficulty) : base(difficulty) {
+        path = [MapManager.Get(10), MapManager.Get(11), MapManager.Get(12), MapManager.Get(13),  MapManager.Get(14)];
+        pathId = 2;
+        movementOpportunity = new(6000, (2 * Math.Sign(difficulty) + difficulty) / 12.0);
+    }
+
+    public override string Name{ get; } = "Spot";
+    public override int TypeId{ get; } = (int)EnemyType.SPOT;
+    public override bool BlocksTile{ get; set; } = false;
+
+    public bool Active{ get; set; } = false;
+    
+    private MovementOpportunity movementOpportunity;
+    private MapTile[] path;
+    private int pathId;
+
+    private int p1WatchCounter = 0;
+    private int p2WatchCounter = 0;
+    
+    public override void Reset() {
+        pathId = 2;
+        Location = path[pathId];
+        Server.SendUpdateToAll([GameEvent.ENEMY_RESET(Id, Location.Id)]);
+    }
+
+    public override void Attack(ServerPlayer player) {
+        throw new NotImplementedException();
+    }
+
+    public override void Update() {
+        if (GameLogic.NSecondUpdate){
+            if(!movementOpportunity.Running) 
+                movementOpportunity.Start();
+            
+            if (Active){
+                if (Server.P1.state.monitorUp && Server.P1.state.camera == Location.Id) p1WatchCounter++;
+                if (Server.P2.state.monitorUp && Server.P2.state.camera == Location.Id) p2WatchCounter++;
+
+                Console.WriteLine($"P1: {p1WatchCounter} | P2: {p2WatchCounter}");
+            }
+        }
+        
+        if (movementOpportunity.CheckAndRoll()){
+            if(!Active) {
+                Active = true;
+                movementOpportunity.Interval = 12_000;
+                movementOpportunity.GuaranteeSuccess(true);
+                Server.SendUpdateToAll([GameEvent.SPOT_SET_ACTIVE(Id, true)]);
+            }
+            else{
+                movementOpportunity.Interval = 6000;
+                movementOpportunity.GuaranteeSuccess(false);
+                movementOpportunity.Stop();
+                
+                if (p1WatchCounter > p2WatchCounter){
+                    pathId++;
+                    if (Location.GetConnector(path[pathId])!.Blocked){
+                        Reset();
+                    }
+                    else if (pathId == path.Length - 1){
+                        Attack(Server.P1);
+                    }
+                }
+                else if (p2WatchCounter > p1WatchCounter){
+                    pathId--;
+                    if (Location.GetConnector(path[pathId])!.Blocked){
+                        Reset();
+                    }
+                    else if (pathId == 0){
+                        Attack(Server.P2);
+                    }
+                }
+                
+                Location = path[pathId];
+                Active = false;
+                p1WatchCounter = 0;
+                p2WatchCounter = 0;
+                Server.SendUpdateToAll([GameEvent.ENEMY_MOVEMENT(Id, Location.Id), GameEvent.SPOT_SET_ACTIVE(Id, false)]);
+            }
+        }
+    }
+
+    public override void Spawn(MapTile location) {
+        base.Spawn(location);
+        Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(TypeId, Id, Difficulty, Location.Id)]);
+
+    }
+}

FNAF_Server/GameLogic.cs

@@ -1,3 +1,5 @@
+using System.Diagnostics;
+using FNAF_Server.Enemies;
 using FNAF_Server.Map;
 using GlobalClassLib;
 using PacketLib;
@@ -7,10 +9,19 @@ namespace FNAF_Server;
 public class GameLogic {
     
     public const int START_CAMERA = 12;
+    
+    private static MovementOpportunity secondCycleTimer = new(1000);
+    public static bool NSecondUpdate{ get; private set; } = false;
 
+    public static MapTile P1Office;
+    public static MapTile P2Office;
+    public static MapTile[] Offices =>[P1Office, P2Office];
+    
     public static void Init() {
         // Create map
         MapManager.InitMap();
+        P1Office = MapManager.Get(10);
+        P2Office = MapManager.Get(14);
 
         //Send map to client
         TileConnector[] connectors = MapManager.GetAllConnectors();
@@ -20,13 +31,21 @@ public class GameLogic {
             connectorsConverted[i * 3 + 1] = connectors[i].Tiles.tile2.Id;
             connectorsConverted[i * 3 + 2] = (int)connectors[i].Type;
         }
-        Server.SendPacket(new MapInitPacket{Connectors = connectorsConverted, UpsideDown = true}, Server.P1.peer);
-        Server.SendPacket(new MapInitPacket{Connectors = connectorsConverted, UpsideDown = false}, Server.P2.peer);
+        Server.SendPacket(new MapInitPacket{Connectors = connectorsConverted, UpsideDown = false}, Server.P1.peer);
+        Server.SendPacket(new MapInitPacket{Connectors = connectorsConverted, UpsideDown = true}, Server.P2.peer);
         
+        // EnemyManager.AddEnemy(new LurkEnemy(0)).Spawn(MapManager.Get(12));
+        EnemyManager.AddEnemy(new NekoEnemy(10)).Spawn(MapManager.Get(2));
+        EnemyManager.AddEnemy(new SpotEnemy(0)).Spawn(MapManager.Get(12));
+        
+        secondCycleTimer.Start();
     }
     public static void Update() {
+        if(secondCycleTimer.Check()) NSecondUpdate = true;
         
+        EnemyManager.Update();
+        
+        NSecondUpdate = false;
     }
     
-    
 }

FNAF_Server/Server.cs

@@ -107,18 +107,26 @@ public class Server {
             },
             username = packet.username
         });
-
-        SendPacket(new JoinAcceptPacket { state = newPlayer.state }, peer);
-
+        
+        
         if (Players.Count == 1){
+            newPlayer.state.officeTileId = 10;
+            newPlayer.state.neighbouringTiles = [5, 11, 15];
+            SendPacket(new JoinAcceptPacket { state = newPlayer.state }, peer);
             P1 = newPlayer;
         }
         else{
+            newPlayer.state.officeTileId = 14;
+            newPlayer.state.neighbouringTiles = [19, 13, 9];
+
+            SendPacket(new JoinAcceptPacket { state = newPlayer.state }, peer);
             P2 = newPlayer;
+
             SendPacket(new OpponentInitPacket{state = newPlayer.state}, P1.peer);
             SendPacket(new OpponentInitPacket{state = P1.state}, P2.peer);
-            GameLogic.Init(); // TODO: move this to the condition above to wait for the other player
+            GameLogic.Init();
         }
+        
     }
     
     public static void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) {
@@ -133,29 +141,12 @@ public class Server {
 
     public static void OnCommandReceived(PlayerCommandPacket packet, NetPeer peer) {
         CommandProcessor.Evaluate(packet.commands, peer.Id);
-        
-        // PlayerCommand[] commands = packet.commands;
-
-        // foreach (var playerCommand in commands){
-        //     switch (playerCommand.ID){
-        //         case 0:
-        //             Console.WriteLine($"C: Player {peer.Id} switched to camera {playerCommand.Args[0]}");
-        //             SendUpdateToAll([GameEvent.SWITCH_CAM(peer.Id, playerCommand.Args[0])]);
-        //             break;
-        //         case 1:
-        //             bool newState = !Players[(uint)peer.Id].state.monitorUp;
-        //             Players[(uint)peer.Id].state.monitorUp = newState;
-        //             Console.WriteLine($"C: Player {peer.Id} toggled camera {(newState ? "on" : "off")}");
-        //             SendUpdateToAll([GameEvent.TOGGLE_MONITOR(peer.Id, newState)]);
-        //             break;
-        //     }
-        // }
     }
     
     public static void Update() {
         server.PollEvents();
         // Console.WriteLine("update");
-        GameLogic.Update(); // TODO: add a parameter for player input
+        GameLogic.Update();
     }
     
     public static void Run(CancellationToken cancellationToken = default)