Perry/OneNightDuel
1
0
Fork 0
Code Issues Pull requests Projects Releases 2 Packages Wiki Activity Actions

Oprava spawnování monster, optimalizace v CommandProcessor a EventProcessor. Přesunutí některých tříd do vlastních namespaců, pročištění kódu, úpravy formátování, odstranění nepoužívaných souborů a zakomentovaného kódu

Browse source
This commit is contained in:
Perry 2026-03-28 09:59:31 +01:00
parent e5d746d597
commit 243f071a43
62 changed files with 873 additions and 1217 deletions
Download patch file Download diff file Expand all files Collapse all files

70
ONDServer/CommandProcessor.cs
View file

@ -1,70 +0,0 @@
using ONDServer.Map;
using PacketLib;
namespace ONDServer;
public class CommandProcessor {
public static void Evaluate(PlayerCommand[] commands, int pid) {
ServerPlayer currentPlayer = Server.Players[pid];
foreach (var playerCommand in commands){
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:
bool monitorState = playerCommand.Args[0] == 1;
currentPlayer.state.monitorUp = monitorState;
Console.WriteLine($"C: Player {pid} toggled camera {(monitorState ? "on" : "off")}");
Server.SendUpdateToAll([GameEvent.TOGGLE_MONITOR(pid, monitorState)]);
break;
case 2:
bool doorState = playerCommand.Args[1] == 1;
currentPlayer.state.doorStates[playerCommand.Args[0]] = doorState;
TileConnector? officeDoor = MapManager.Get(currentPlayer.state.officeTileId).GetConnector(currentPlayer.state.neighbouringTiles[playerCommand.Args[0]]);
officeDoor.Blocked = doorState;
if (doorState){
GameLogic.PowerConsumers[officeDoor] = (GameLogic.OfficeDoorUsage, pid);
}
else{
GameLogic.PowerConsumers.Remove(officeDoor);
}
Console.WriteLine($"C: Player {pid} {(doorState ? "closed" : "opened")} door {playerCommand.Args[0]}");
Server.SendUpdateToAll([GameEvent.TOGGLE_DOOR_OFFICE(pid,playerCommand.Args[0] ,doorState)]);
break;
case 3:
TileConnector? door = MapManager.Get(playerCommand.Args[0]).GetConnector(playerCommand.Args[1]);
if(door == null) return;
door.Blocked = playerCommand.Args[2] == 1;
if (door.Blocked){
GameLogic.PowerConsumers[door] = (GameLogic.RemoteDoorUsage, pid);
}
else{
GameLogic.PowerConsumers.Remove(door);
}
Console.WriteLine($"C: Player {pid} {(door.Blocked ? "closed" : "opened")} door {(playerCommand.Args[0], playerCommand.Args[1])}");
Server.SendUpdateToAll([GameEvent.TOGGLE_DOOR_REMOTE(pid, (playerCommand.Args[0], playerCommand.Args[1]), door.Blocked)]);
break;
case 4:
bool lit = playerCommand.Args[1] == 1;
MapTile lightTile = MapManager.Get(playerCommand.Args[0]);
lightTile.Lit = lit;
if (lit){
GameLogic.PowerConsumers[lightTile] = (GameLogic.LightUsage, pid);
}
else{
GameLogic.PowerConsumers.Remove(lightTile);
}
Server.SendUpdateToAll([GameEvent.TOGGLE_LIGHT(pid, playerCommand.Args[0], lit)]);
break;
}
}
}
}

23
ONDServer/Enemies/DashEnemy.cs
View file

@ -1,21 +1,19 @@
using System.Net.Mime;
using GlobalClassLib;
using ONDServer.Map;
using ONDServer.Net;
using PacketLib;
namespace ONDServer.Enemies;
public class DashEnemy : Enemy {
public DashEnemy(int difficulty) : base(difficulty, 5000) {
movementOpportunity = new(5000);
MovementOpportunity = new(5000);
SetDifficulty(difficulty);
}
public override string Name{ get; } = "Dash";
public override int TypeId{ get; } = (int)EnemyType.DASH;
public override EnemyType Type{ get; } = EnemyType.DASH;
public override bool BlocksTile{ get; set; } = false;
// private MovementOpportunity movementOpportunity;
private readonly (MapTile tile, Direction p1AttackDir, Direction p2AttackDir)[] positions =[
(MapManager.Get(7), Direction.EAST, Direction.WEST),
@ -34,11 +32,6 @@ public class DashEnemy : Enemy {
Server.SendUpdateToAll([GameEvent.ENEMY_RESET(Id, Location.Id)]);
}
// public override void SetDifficulty(int difficulty) {
// Difficulty = difficulty;
// movementOpportunity.MovementChance = (2 * Math.Sign(difficulty) + difficulty) / 12.0;
// }
public override void Spawn(MapTile location) {
currentPosIndex = positions.ToList().FindIndex(p => p.tile == location);
if (currentPosIndex == -1){
@ -47,16 +40,16 @@ public class DashEnemy : Enemy {
}
base.Spawn(location);
movementOpportunity.Start();
Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(TypeId, Id, Difficulty, Location.Id)]);
MovementOpportunity.Start();
Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(Type, Id, Difficulty, Location!.Id)]);
}
public override void Update() {
base.Update();
if (movementOpportunity.CheckAndRoll()){
bool attackP1 = !Server.P1.state.doorStates[(int)positions[currentPosIndex].p1AttackDir];
bool attackP2 = !Server.P2.state.doorStates[(int)positions[currentPosIndex].p2AttackDir];
if (MovementOpportunity.CheckAndRoll()){
bool attackP1 = !Server.P1.State.DoorStates[(int)positions[currentPosIndex].p1AttackDir];
bool attackP2 = !Server.P2.State.DoorStates[(int)positions[currentPosIndex].p2AttackDir];
if (attackP1 != attackP2){
if(attackP1) Attack(Server.P1);

25
ONDServer/Enemies/Enemy.cs
View file

@ -1,25 +1,25 @@
using GlobalClassLib;
using ONDServer.Map;
using ONDServer.Net;
using PacketLib;
namespace ONDServer.Enemies;
public abstract class Enemy : GlobalEnemy<MapTile, TileConnector> {
public int Difficulty { get; protected set; }
protected MovementOpportunity movementOpportunity;
protected Enemy(int difficulty, int movementInterval) {
movementOpportunity = new(movementInterval);
SetDifficulty(difficulty);
}
public abstract bool BlocksTile { get; set; }
public bool Spawned { get; set; }
protected OpportunityTimer MovementOpportunity;
protected Enemy(int difficulty, int movementInterval) {
MovementOpportunity = new(movementInterval);
SetDifficulty(difficulty);
}
// unused
public virtual void SpawnSilent(MapTile location) {
Console.WriteLine($"!!! Silent spawn not implemented for enemy {TypeId} ({Name}), reverting to regular spawn");
Console.WriteLine($"!!! Silent spawn not implemented for enemy {Type} ({Name}), reverting to regular spawn");
Spawn(location);
}
@ -31,12 +31,13 @@ public abstract class Enemy : GlobalEnemy<MapTile, TileConnector> {
public abstract void Reset();
public virtual void Attack(ServerPlayer player) {
Server.SendUpdateToAll([GameEvent.ENEMY_ATTACK(Id, player.state.pid)]);
Server.SendUpdateToAll([GameEvent.ENEMY_ATTACK(Id, player.State.Pid)]);
GameLogic.DeclareWinner(Server.OtherPlayer(player));
}
public virtual void SetDifficulty(int difficulty) {
if (difficulty > 10) return;
Difficulty = difficulty;
movementOpportunity.MovementChance = ((5 + Math.Pow(1.5f, Difficulty)) * Math.Sign(Difficulty)) / (5 + Math.Pow(1.5f, 10));
MovementOpportunity.MovementChance = ((5 + Math.Pow(1.5f, Difficulty)) * Math.Sign(Difficulty)) / (5 + Math.Pow(1.5f, 10));
}
}

2
ONDServer/Enemies/EnemyManager.cs
View file

@ -2,7 +2,7 @@ using ONDServer.Map;
namespace ONDServer.Enemies;
public class EnemyManager {
public static class EnemyManager {
private static Dictionary<int, Enemy> enemies = new();
public static void Update() {

88
ONDServer/Enemies/LurkEnemy.cs
View file

@ -2,41 +2,33 @@ using System.Diagnostics;
using System.Reflection;
using GlobalClassLib;
using ONDServer.Map;
using ONDServer.Net;
using PacketLib;
namespace ONDServer.Enemies;
public class LurkEnemy : Enemy {
public override string Name{ get; } = "Lurk";
public override int TypeId{ get; } = (int)EnemyType.LURK;
public override EnemyType Type{ get; } = 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
public ServerPlayer? Target{ get; set; }
private readonly RoamingPathfinder pathfinder;
public LurkEnemy(int difficulty) : base(difficulty, 5000) {
pathfinder = new LurkPathfinder(this, 1);
// movementOpportunity = new MovementOpportunity(5000);
Target = null;
// SetDifficulty(difficulty);
pathfinder = new RoamingPathfinder(this, 1);
Target = null;
}
public override void Spawn(MapTile location) {
base.Spawn(location);
// stopwatch.Start();
movementOpportunity.Start();
pathfinder.TakenPath.Add(Location);
Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(TypeId, Id, Difficulty, Location.Id)]);
MovementOpportunity.Start();
pathfinder.TakenPath.Add(Location!);
Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(Type, Id, Difficulty, Location!.Id)]);
}
public override void Reset() {
Target.state.power -= 80;
if (Target != null) Target.State.Power -= 80;
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)];
pathfinder.TakenPath.Clear();
@ -45,26 +37,23 @@ public class LurkEnemy : Enemy {
Server.SendUpdateToAll([GameEvent.ENEMY_RESET(Id, Location.Id)]);
}
// public override void SetDifficulty(int difficulty) {
// Difficulty = difficulty;
// movementOpportunity.MovementChance = ((5 + Math.Pow(1.5f, Difficulty)) * Math.Sign(Difficulty)) / (5 + Math.Pow(1.5f, 10));
// }
public override void Update() {
base.Update();
if (movementOpportunity.CheckAndRoll()){
if (Server.P1.state.power > Server.P2.state.power){
if(Location == null) return;
if (MovementOpportunity.CheckAndRoll()){
if (Server.P1.State.Power > Server.P2.State.Power){
Target = Server.P1;
}
else if (Server.P1.state.power < Server.P2.state.power){
else if (Server.P1.State.Power < Server.P2.State.Power){
Target = Server.P2;
}
else{
return;
}
Pathfinder.Decision decision = pathfinder.DecideNext(MapManager.Get(Target.state.officeTileId));
Pathfinder.Decision decision = pathfinder.DecideNext(MapManager.Get(Target.State.OfficeTileId));
switch (decision.type){
case Pathfinder.Decision.MoveType:
if (Location.GetConnector(decision.nextTile!)!.Type == ConnectorType.VENT){
@ -72,7 +61,7 @@ public class LurkEnemy : Enemy {
}
Location = decision.nextTile!;
Server.SendUpdateToAll([GameEvent.ENEMY_MOVEMENT(Id, Location.Id)]);
Console.WriteLine($"Enemy {TypeId} ({Name}) moving to {Location.PositionAsString})");
Console.WriteLine($"Enemy {Type} ({Name}) moving to {Location.IdAsString})");
break;
case Pathfinder.Decision.AttackType:
Attack(decision.attackTarget!);
@ -85,45 +74,4 @@ public class LurkEnemy : Enemy {
}
}
}
private class LurkPathfinder : RoamingPathfinder {
// private Random random = new();
public LurkPathfinder(Enemy enemy, int tolerance) : base(enemy, tolerance) {
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(((LurkEnemy)Enemy).Target);
// }
//
// 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();
// }
}
}

81
ONDServer/Enemies/MareEnemy.cs
View file

@ -1,5 +1,6 @@
using GlobalClassLib;
using ONDServer.Map;
using ONDServer.Net;
using PacketLib;
namespace ONDServer.Enemies;
@ -7,72 +8,60 @@ namespace ONDServer.Enemies;
public class MareEnemy : Enemy {
public override string Name{ get; } = "Mare";
public override int TypeId{ get; } = (int)EnemyType.MARE;
public override EnemyType Type{ get; } = EnemyType.MARE;
public override bool BlocksTile{ get; set; } = true;
private MarePathfinder pathfinder;
// private MovementOpportunity movementOpportunity;
private readonly RoamingPathfinder pathfinder;
public ServerPlayer? Target{ get; set; }
public MareEnemy(int difficulty) : base(difficulty, 6000) {
pathfinder = new MarePathfinder(this, 1);
// movementOpportunity = new MovementOpportunity(5000);
// SetDifficulty(difficulty);
pathfinder = new RoamingPathfinder(this, 1){ AdditionalConnectorFilter = c => c.Type != ConnectorType.VENT };
}
public override void Reset() {
pathfinder.TakenPath.Clear();
Target = Server.OtherPlayer(Target);
Pathfinder.Decision decision = pathfinder.DecideNext(MapManager.Get(Target.state.officeTileId));
Pathfinder.Decision decision = pathfinder.DecideNext(MapManager.Get(Target.State.OfficeTileId));
if (decision.type == Pathfinder.Decision.MoveType){
Location = decision.nextTile!;
}
Server.SendUpdateToAll([GameEvent.ENEMY_RESET(Id, Location.Id)]);
}
// public override void SetDifficulty(int difficulty) {
// Difficulty = difficulty;
// movementOpportunity.MovementChance =
// ((5 + Math.Pow(1.5f, Difficulty)) * Math.Sign(Difficulty)) / (5 + Math.Pow(1.5f, 10));
// }
public override void Spawn(MapTile location) {
base.Spawn(location);
// stopwatch.Start()
if (Server.P1.state.power > Server.P2.state.power){
if (Server.P1.State.Power > Server.P2.State.Power){
Target = Server.P2;
}
else if(Server.P1.state.power < Server.P2.state.power){
else if(Server.P1.State.Power < Server.P2.State.Power){
Target = Server.P1;
}
else{
Target = new Random().Next(2) == 0 ? Server.P1 : Server.P2;
}
movementOpportunity.Start();
MovementOpportunity.Start();
pathfinder.TakenPath.Add(Location);
Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(TypeId, Id, Difficulty, Location.Id)]);
Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(Type, Id, Difficulty, Location.Id)]);
}
public override void Update() {
base.Update();
if (movementOpportunity.CheckAndRoll()){
if (MovementOpportunity.CheckAndRoll()){
if (Location.Owner != null && Location.Lit){
Attack(Location.Owner);
}
if (Target == null) return;
Pathfinder.Decision decision = pathfinder.DecideNext(MapManager.Get(Target.state.officeTileId));
Pathfinder.Decision decision = pathfinder.DecideNext(MapManager.Get(Target.State.OfficeTileId));
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})");
Console.WriteLine($"Enemy {Type} ({Name}) moving to {Location.IdAsString})");
break;
case Pathfinder.Decision.AttackType:
Attack(decision.attackTarget!);
@ -85,48 +74,4 @@ public class MareEnemy : Enemy {
}
}
}
private class MarePathfinder : RoamingPathfinder {
// private Random random = new();
public MarePathfinder(Enemy enemy, int tolerance) : base(enemy, tolerance) {
this.tolerance = tolerance;
AdditionalConnectorFilter = c => c.Type != ConnectorType.VENT;
}
// 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(((MareEnemy)Enemy).Target);
// }
//
// 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();
// }
}
}

96
ONDServer/Enemies/NekoEnemy.cs
View file

@ -1,35 +1,29 @@
using GlobalClassLib;
using ONDServer.Map;
using ONDServer.Net;
using PacketLib;
namespace ONDServer.Enemies;
public class NekoEnemy : Enemy {
// private MovementOpportunity movementOpportunity;
private RoamingPathfinder pathfinder;
public override string Name{ get; } = "Neko";
public override EnemyType Type{ get; } = EnemyType.NEKO;
public override bool BlocksTile{ get; set; } = true;
public bool Aggressive = false;
public ServerPlayer? Target{ get; set; }
private readonly RoamingPathfinder pathfinder;
public NekoEnemy(int difficulty) : base(difficulty, 4000) {
pathfinder = new RoamingPathfinder(this, 1){AdditionalTileFilter = t => Aggressive || t.Owner == null || !t.Lit};
// movementOpportunity = new MovementOpportunity(5000);
// SetDifficulty(difficulty);
}
public override string Name{ get; } = "Neko";
public override int TypeId{ get; } = (int)EnemyType.NEKO;
public override bool BlocksTile{ get; set; } = true;
public bool Aggressive = false;
public ServerPlayer? Target{ get; set; }
public override void Spawn(MapTile location) {
base.Spawn(location);
// stopwatch.Start();
movementOpportunity.Start();
pathfinder.TakenPath.Add(Location);
Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(TypeId, Id, Difficulty, Location.Id)]);
MovementOpportunity.Start();
pathfinder.TakenPath.Add(Location!);
Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(Type, Id, Difficulty, Location!.Id)]);
}
public override void Reset() {
@ -38,29 +32,25 @@ public class NekoEnemy : Enemy {
pathfinder.TakenPath.Clear();
pathfinder.TakenPath.Add(Location);
Aggressive = false;
Target = Server.OtherPlayer(Target);
Target = Server.OtherPlayer(Target!);
Server.SendUpdateToAll([GameEvent.ENEMY_RESET(Id, Location.Id)]);
}
// public override void SetDifficulty(int difficulty) {
// Difficulty = difficulty;
// movementOpportunity.MovementChance =
// ((5 + Math.Pow(1.5f, Difficulty)) * Math.Sign(Difficulty)) / (5 + Math.Pow(1.5f, 10));
// }
public override void Update() {
base.Update();
if(Location == null) return;
if (Location.Owner != null && Location.Lit && !Aggressive){
Aggressive = true;
Server.SendUpdateToAll([GameEvent.NEKO_ANGERED(Location.Owner.state.pid, Id)]);
Server.SendUpdateToAll([GameEvent.NEKO_ANGERED(Location.Owner.State.Pid, Id)]);
}
if (Target == null){
if (Server.P1.state.power > Server.P2.state.power){
if (Server.P1.State.Power > Server.P2.State.Power){
Target = Server.P2;
}
else if (Server.P1.state.power < Server.P2.state.power){
else if (Server.P1.State.Power < Server.P2.State.Power){
Target = Server.P1;
}
else{
@ -71,9 +61,9 @@ public class NekoEnemy : Enemy {
}
}
bool succeed = movementOpportunity.CheckAndRoll();
bool succeed = MovementOpportunity.CheckAndRoll();
if (Target != null && (succeed || (Aggressive && GameLogic.NSecondUpdate))){
Pathfinder.Decision decision = pathfinder.DecideNext(MapManager.Get(Target.state.officeTileId));
Pathfinder.Decision decision = pathfinder.DecideNext(MapManager.Get(Target.State.OfficeTileId));
switch (decision.type){
case Pathfinder.Decision.MoveType:
if (Location.GetConnector(decision.nextTile!)!.Type == ConnectorType.VENT){
@ -81,7 +71,7 @@ public class NekoEnemy : Enemy {
}
Location = decision.nextTile!;
Server.SendUpdateToAll([GameEvent.ENEMY_MOVEMENT(Id, Location.Id)]);
Console.WriteLine($"Enemy {TypeId} ({Name}) moving to {Location.PositionAsString})");
Console.WriteLine($"Enemy {Type} ({Name}) moving to {Location.IdAsString})");
break;
case Pathfinder.Decision.AttackType:
Attack(decision.attackTarget!);
@ -95,48 +85,4 @@ public class NekoEnemy : Enemy {
}
}
}
private class NekoPathfinder : RoamingPathfinder {
// private Random random = new();
public NekoPathfinder(Enemy enemy, int tolerance) : base(enemy, tolerance) {
this.tolerance = tolerance;
AdditionalTileFilter = t => ((NekoEnemy)Enemy).Aggressive || t.Owner == null || !t.Lit;
}
// 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(((NekoEnemy)Enemy).Target);
// }
//
// 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();
// }
}
}

8
ONDServer/Enemies/MovementOpportunity.cs → ONDServer/Enemies/OpportunityTimer.cs
View file

@ -2,9 +2,8 @@ using System.Diagnostics;
namespace ONDServer.Enemies;
public class MovementOpportunity {
public class OpportunityTimer {
public int Interval{ get; set; }
// public double ChanceDenominator;
public double MovementChance{
get;
set{
@ -20,12 +19,12 @@ public class MovementOpportunity {
private Random random = new();
public MovementOpportunity(int intervalMs, double movementChance) {
public OpportunityTimer(int intervalMs, double movementChance) {
Interval = intervalMs;
MovementChance = movementChance;
}
public MovementOpportunity(int intervalMs) {
public OpportunityTimer(int intervalMs) {
Interval = intervalMs;
MovementChance = 1;
}
@ -41,7 +40,6 @@ public class MovementOpportunity {
if (stopwatch.ElapsedMilliseconds - stopwatchOffset >= Interval){
int overshoot = (int)(stopwatch.ElapsedMilliseconds - stopwatchOffset - Interval);
stopwatchOffset = stopwatch.ElapsedMilliseconds - overshoot;
// stopwatch.Restart();
return true;
}
return false;

2
ONDServer/Enemies/Pathfinder.cs
View file

@ -1,4 +1,5 @@
using ONDServer.Map;
using ONDServer.Net;
namespace ONDServer.Enemies;
@ -8,7 +9,6 @@ public abstract class Pathfinder {
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();

41
ONDServer/Enemies/RoamingPathfinder.cs
View file

@ -1,25 +1,19 @@
using GlobalClassLib;
using ONDServer.Map;
using ONDServer.Net;
namespace ONDServer.Enemies;
public class RoamingPathfinder : Pathfinder {
public class RoamingPathfinder(Enemy enemy, int tolerance) : Pathfinder(enemy) {
public Predicate<MapTile> AdditionalTileFilter{ get; set; } = _ => true;
public Predicate<TileConnector> AdditionalConnectorFilter{ get; set; } = _ => true;
protected int tolerance;
protected int Tolerance = tolerance;
public List<MapTile> TakenPath { get; } = new();
private Random random = new();
// private Queue<MapTile> tilesToCrawl = new();
// private Dictionary<MapTile, int> distances = new();
// private Func<TileConnector, MapTile, bool> defaultConnectorFilter;
public RoamingPathfinder(Enemy enemy, int tolerance) : base(enemy) {
this.tolerance = tolerance;
}
protected Dictionary<MapTile, int> Search(MapTile startingTile) {
Dictionary<MapTile, int> distances = new(){ [startingTile] = 0 };
Queue<MapTile> tilesToSearch = new();
@ -36,7 +30,7 @@ public class RoamingPathfinder : Pathfinder {
t =>
AdditionalTileFilter(t) &&
(!Enemy.BlocksTile || EnemyManager.GetByLocation(t).All(e => !e.BlocksTile || e == Enemy)) &&
Server.Players.All(p => p.Value.state.officeTileId != t.Id));
Server.Players.All(p => p.Value.State.OfficeTileId != t.Id));
neighbours.ForEach(t => {
distances[t] = distances[currentTile] + currentTile.GetConnector(t)!.Value;
@ -47,37 +41,20 @@ public class RoamingPathfinder : Pathfinder {
return distances;
}
// private void CrawlStep(MapTile tile) {
// List<MapTile> neighbours = GetNeighbours(tile,
// c =>
// AdditionalConnectorFilter(c) &&
// (!c.Blocked || c.Type == ConnectorType.DOOR_OFFICE) &&
// tile != Enemy.Location &&
// (!distances.ContainsKey(c.OtherTile(tile)) || distances[c.OtherTile(tile)] > distances[tile] + c.Value),
// t =>
// AdditionalTileFilter(t) &&
// (!Enemy.BlocksTile || EnemyManager.GetByLocation(t).All(e => !e.BlocksTile || e == Enemy)) &&
// Server.Players.All(p => p.Value.state.officeTileId != t.Id));
//
// neighbours.ForEach(t => distances[t] = distances[tile] + tile.GetConnector(t)!.Value);
//
// if (neighbours.Count != 0){
// neighbours.ForEach(t => CrawlStep(t));
// }
// }
public override Decision DecideNext(MapTile goal) {
if (Enemy.Location == null) return Decision.Wait();
Dictionary<MapTile, int> distances = Search(goal);
List<MapTile> closerTiles = GetNeighbours(Enemy.Location,
c => AdditionalConnectorFilter(c) && !c.Blocked || c.Type == ConnectorType.DOOR_OFFICE,
t => AdditionalTileFilter(t) && distances.ContainsKey(t) && distances[t] + t.GetConnector(Enemy.Location).Value <= distances[Enemy.Location] + tolerance);
t => AdditionalTileFilter(t) && distances.ContainsKey(t) && distances[t] + t.GetConnector(Enemy.Location)!.Value <= distances[Enemy.Location] + Tolerance);
if (closerTiles.Contains(goal)){
if (Enemy.Location.GetConnector(goal)!.Blocked){
return Decision.Reset();
}
IEnumerable<ServerPlayer> players = Server.Players.Values.Where(p => p.state.officeTileId == goal.Id);
IEnumerable<ServerPlayer> players = Server.Players.Values.Where(p => p.State.OfficeTileId == goal.Id);
if (players.Count() == 1){
return Decision.Attack(players.First());
}

35
ONDServer/Enemies/SpotEnemy.cs
View file

@ -1,5 +1,6 @@
using GlobalClassLib;
using ONDServer.Map;
using ONDServer.Net;
using PacketLib;
namespace ONDServer.Enemies;
@ -8,17 +9,14 @@ public class SpotEnemy : Enemy {
public SpotEnemy(int difficulty) : base(difficulty, 6000) {
path = [MapManager.Get(10), MapManager.Get(11), MapManager.Get(12), MapManager.Get(13), MapManager.Get(14)];
pathId = 2;
// movementOpportunity = new(6000);
// SetDifficulty(difficulty);
}
public override string Name{ get; } = "Spot";
public override int TypeId{ get; } = (int)EnemyType.SPOT;
public override EnemyType Type{ get; } = EnemyType.SPOT;
public override bool BlocksTile{ get; set; } = false;
public bool Active{ get; set; } = false;
// private MovementOpportunity movementOpportunity;
private MapTile[] path;
private int pathId;
@ -27,42 +25,37 @@ public class SpotEnemy : Enemy {
public override void Reset() {
if (Location.Owner != null){
Location.Owner.state.power -= 200;
Location.Owner.State.Power -= 200;
}
pathId = 2;
Location = path[pathId];
Server.SendUpdateToAll([GameEvent.ENEMY_RESET(Id, Location.Id)]);
}
// public override void SetDifficulty(int difficulty) {
// Difficulty = difficulty;
// movementOpportunity.MovementChance = (2 * Math.Sign(difficulty) + difficulty) / 12.0;
// }
public override void Update() {
if (GameLogic.NSecondUpdate){
if(!movementOpportunity.Running)
movementOpportunity.Start();
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++;
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 (MovementOpportunity.CheckAndRoll()){
if(!Active) {
Active = true;
movementOpportunity.Interval = 10_000;
movementOpportunity.GuaranteeSuccess(true);
MovementOpportunity.Interval = 10_000;
MovementOpportunity.GuaranteeSuccess(true);
Server.SendUpdateToAll([GameEvent.SPOT_SET_ACTIVE(Id, true)]);
}
else{
movementOpportunity.Interval = 6000;
movementOpportunity.GuaranteeSuccess(false);
movementOpportunity.Stop();
MovementOpportunity.Interval = 6000;
MovementOpportunity.GuaranteeSuccess(false);
MovementOpportunity.Stop();
if (p1WatchCounter > p2WatchCounter){
pathId++;
@ -94,7 +87,7 @@ public class SpotEnemy : Enemy {
public override void Spawn(MapTile location) {
base.Spawn(location);
Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(TypeId, Id, Difficulty, Location.Id)]);
Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(Type, Id, Difficulty, Location.Id)]);
}
}

127
ONDServer/GameLogic.cs
View file

@ -2,16 +2,17 @@ using System.Diagnostics;
using GlobalClassLib;
using ONDServer.Enemies;
using ONDServer.Map;
using ONDServer.Net;
using PacketLib;
namespace ONDServer;
public class GameLogic {
public static class GameLogic {
public const int START_CAMERA = 12;
private static MovementOpportunity secondCycleTimer = new(1000);
private static MovementOpportunity gamePhaseTimer = new(60_000);
private static readonly OpportunityTimer secondCycleTimer = new(1000);
private static readonly OpportunityTimer gamePhaseTimer = new(60_000);
public static bool NSecondUpdate{ get; private set; } = false;
public static MapTile P1Office;
@ -25,17 +26,12 @@ public class GameLogic {
private static List<List<Enemy>> spawnOrder;
private static int[] defaultSpawnPoints = [2, 22];
private static readonly int[] defaultSpawnPoints = [2, 22];
private static Random random = new();
private static bool unlimitedPower = false; // Debug
private static bool noPhases = true; // Debug
private static readonly Random random = new();
// public const int POWER_MAX = 1000;
// public static int P1Power{ get; set; } = Power.MAX_POWER_VALUE;
// public static int P2Power{ get; set; } = Power.MAX_POWER_VALUE;
// public static int[] PowerValues =>[P1Power, P2Power];
private const bool UNLIMITED_POWER = false; // Debug
private const bool NO_PHASES = false; // Debug
public static Dictionary<object, (int usage, int pid)> PowerConsumers{ get; set; } = new();
@ -44,10 +40,6 @@ public class GameLogic {
MapManager.InitMap();
P1Office = MapManager.Get(10);
P2Office = MapManager.Get(14);
//
// foreach (var player in Server.Players.Values){
// player.state.power = Power.MAX_POWER_VALUE;
// }
//Send map to client
TileConnector[] connectors = MapManager.GetAllConnectors();
@ -56,7 +48,7 @@ public class GameLogic {
connectorsConverted[i * 4] = connectors[i].Tiles.tile1.Id;
connectorsConverted[i * 4 + 1] = connectors[i].Tiles.tile2.Id;
connectorsConverted[i * 4 + 2] = (int)connectors[i].Type;
connectorsConverted[i * 4 + 3] = connectors[i].Owner == null ? -1 : connectors[i].Owner.state.pid;
connectorsConverted[i * 4 + 3] = connectors[i].Owner == null ? -1 : connectors[i].Owner!.State.Pid;
}
List<int> p1Tiles = new();
@ -68,25 +60,26 @@ public class GameLogic {
else if(tile.Owner == Server.P2) p2Tiles.Add(tile.Id);
}
Server.SendPacket(new MapInitPacket{Connectors = connectorsConverted, UpsideDown = false, YourTiles = p1Tiles.ToArray(), OpponentTiles = p2Tiles.ToArray(), LitTiles = neutralTiles.ToArray()}, Server.P1.peer);
Server.SendPacket(new MapInitPacket{Connectors = connectorsConverted, UpsideDown = true, YourTiles = p2Tiles.ToArray(), OpponentTiles = p1Tiles.ToArray(), LitTiles = neutralTiles.ToArray()}, Server.P2.peer);
Server.SendPacket(new MapInitPacket{Connectors = connectorsConverted, UpsideDown = false, YourTiles = p1Tiles.ToArray(), OpponentTiles = p2Tiles.ToArray(), LitTiles = neutralTiles.ToArray()}, Server.P1.Peer);
Server.SendPacket(new MapInitPacket{Connectors = connectorsConverted, UpsideDown = true, YourTiles = p2Tiles.ToArray(), OpponentTiles = p1Tiles.ToArray(), LitTiles = neutralTiles.ToArray()}, Server.P2.Peer);
spawnOrder = [[new SpotEnemy(3), new MareEnemy(3)], [new DashEnemy(6)], [new LurkEnemy(3), new NekoEnemy(3)]];
// Enemy test = new SpotEnemy(3);
spawnOrder.ForEach(l => l.ForEach(e => EnemyManager.AddEnemy(e)));
Thread.Sleep(3000);
secondCycleTimer.Start();
gamePhaseTimer.Start();
Server.SendUpdateToAll([GameEvent.GAME_START()]);
// debug
// EnemyManager.AddEnemy(new SpotEnemy(10)).Spawn(MapManager.Get(12));
// EnemyManager.AddEnemy(new LurkEnemy(10)).Spawn(MapManager.Get(12));
EnemyManager.AddEnemy(new NekoEnemy(7)).Spawn(MapManager.Get(2));
// EnemyManager.AddEnemy(new NekoEnemy(7)).Spawn(MapManager.Get(2));
// EnemyManager.AddEnemy(new DashEnemy(10)).Spawn(MapManager.Get(12));
// EnemyManager.AddEnemy(new MareEnemy(10)).Spawn(MapManager.Get(22));
// EnemyManager.AddEnemy(new LurkEnemy(4)).Spawn(MapManager.Get(2));
// EnemyManager.AddEnemy(new NekoEnemy(4)).Spawn(MapManager.Get(22));
EnemyManager.AddEnemy(new LurkEnemy(4)).Spawn(MapManager.Get(2));
EnemyManager.AddEnemy(new NekoEnemy(4)).Spawn(MapManager.Get(22));
}
public static void Update() {
@ -94,24 +87,23 @@ public class GameLogic {
if (NSecondUpdate){
(int p1, int p2) powerUsage = CalculatePowerUsage();
Server.P1.state.power -= powerUsage.p1;
Server.P2.state.power -= powerUsage.p2;
Server.P1.State.Power -= powerUsage.p1;
Server.P2.State.Power -= powerUsage.p2;
foreach (var player in Server.Players.Values){
if (player.state.power < 0){
player.state.poweredOut = true;
player.state.power = 0;
if (player.State.Power < 0){
player.State.PoweredOut = true;
player.State.Power = 0;
PowerOut(player);
}
// Server.SendUpdateToAll([GameEvent.POWER_OUT(player.state.pid)]);
}
if (unlimitedPower){ // Debug
Server.P1.state.power = Power.MAX_POWER_VALUE;
Server.P2.state.power = Power.MAX_POWER_VALUE;
if (UNLIMITED_POWER){ // Debug
Server.P1.State.Power = Power.MAX_POWER_VALUE;
Server.P2.State.Power = Power.MAX_POWER_VALUE;
}
Server.SendUpdateToAll([GameEvent.POWER_TICK(Server.P1.state.pid, Server.P1.state.power), GameEvent.POWER_TICK(Server.P2.state.pid, Server.P2.state.power)]);
Server.SendUpdateToAll([GameEvent.POWER_TICK(Server.P1.State.Pid, Server.P1.State.Power), GameEvent.POWER_TICK(Server.P2.State.Pid, Server.P2.State.Power)]);
if (gamePhaseTimer.Check()){
NextPhase();
@ -125,8 +117,8 @@ public class GameLogic {
public static void DeclareWinner(ServerPlayer player) {
if (Server.Players.Count == 2){
Server.SendUpdateToAll([GameEvent.PLAYER_WIN(player.state.pid)]);
Console.WriteLine("Player " + player.state.pid + " won!");
Server.SendUpdateToAll([GameEvent.PLAYER_WIN(player.State.Pid)]);
Console.WriteLine("Player " + player.State.Pid + " won!");
}
Thread.Sleep(1000);
Server.Stop();
@ -141,10 +133,10 @@ public class GameLogic {
int p2Usage = 0;
foreach (var consumer in PowerConsumers){
if (consumer.Value.pid == Server.P1.state.pid){
if (consumer.Value.pid == Server.P1.State.Pid){
p1Usage += consumer.Value.usage;
}
else if (consumer.Value.pid == Server.P2.state.pid){
else if (consumer.Value.pid == Server.P2.State.Pid){
p2Usage += consumer.Value.usage;
}
}
@ -159,53 +151,60 @@ public class GameLogic {
foreach (var tile in MapManager.GetAllTiles().Where(t => t.Owner == player)){
tile.Lit = false;
}
PowerConsumers.Where(c => c.Value.pid == player.state.pid).ToList().ForEach(c => PowerConsumers.Remove(c.Key));
Server.SendUpdateToAll([GameEvent.POWER_OUT(player.state.pid)]);
PowerConsumers.Where(c => c.Value.pid == player.State.Pid).ToList().ForEach(c => PowerConsumers.Remove(c.Key));
Server.SendUpdateToAll([GameEvent.POWER_OUT(player.State.Pid)]);
}
private static void NextPhase() {
if(noPhases) return;
if(NO_PHASES) return;
PhaseCounter++;
Server.SendUpdateToAll([GameEvent.NEXT_PHASE()]);
int roll = spawnOrder.Count > 0 ? random.Next(3) : random.Next(1,3);
switch (roll){
case 0:
int spawnRoll = random.Next(spawnOrder[0].Count);
SpawnNext(spawnOrder[0][spawnRoll]);
int roll = spawnOrder.Count == 0 ? random.Next(1, 3) : random.Next(3);
if (roll == 0){
int spawnRoll = random.Next(spawnOrder[0].Count);
if (SpawnNext(spawnOrder[0][spawnRoll])){
spawnOrder[0].RemoveAt(spawnRoll);
if (spawnOrder[0].Count == 0){
spawnOrder.RemoveAt(0);
}
break;
case 1:
Enemy[] allEnemies = EnemyManager.GetAll();
for (int i = 0; i < 2; i++){
Enemy enemy = allEnemies[random.Next(allEnemies.Length)];
enemy.SetDifficulty(enemy.Difficulty + 2);
}
break;
case 2:
Enemy[] enemies = EnemyManager.GetAll();
for (int i = 0; i < enemies.Length; i++){
enemies[i].SetDifficulty(enemies[i].Difficulty + 1);
}
break;
}
else{
roll = random.Next(1, 3);
}
}
if (roll == 1){
Enemy[] allEnemies = EnemyManager.GetAll().Where(e => e.Difficulty <= 10).ToArray();
if (allEnemies.Length == 0) return;
for (int i = 0; i < 2; i++){
Enemy enemy = allEnemies[random.Next(allEnemies.Length)];
enemy.SetDifficulty(enemy.Difficulty + 2);
}
}
else if (roll == 2){
Enemy[] enemies = EnemyManager.GetAll();
for (int i = 0; i < enemies.Length; i++){
enemies[i].SetDifficulty(enemies[i].Difficulty + 1);
}
}
}
private static void SpawnNext(Enemy enemy) {
if ((EnemyType)enemy.TypeId == EnemyType.NEKO || (EnemyType)enemy.TypeId == EnemyType.LURK || (EnemyType)enemy.TypeId == EnemyType.MARE){
private static bool SpawnNext(Enemy enemy) {
if (enemy.Type == EnemyType.NEKO || enemy.Type == EnemyType.LURK || enemy.Type == EnemyType.MARE){
MapTile[] spawnLocations = defaultSpawnPoints.Select(i => MapManager.Get(i)).Where(t => EnemyManager.GetByLocation(t).All(e => !e.BlocksTile)).ToArray();
if (spawnLocations.Length == 0){
return;
return false;
}
enemy.Spawn(spawnLocations[random.Next(spawnLocations.Length)]);
return true;
}
else if ((EnemyType)enemy.TypeId == EnemyType.SPOT || (EnemyType)enemy.TypeId == EnemyType.DASH){
if (enemy.Type == EnemyType.SPOT || enemy.Type == EnemyType.DASH){
enemy.Spawn(MapManager.Get(12));
return true;
}
return false;
}
}

24
ONDServer/Map/MapManager.cs
View file

@ -1,4 +1,5 @@
using GlobalClassLib;
using ONDServer.Net;
namespace ONDServer.Map;
@ -10,9 +11,16 @@ public static class MapManager {
public static MapTile Get((int x, int y) coords) => map[coords.x, coords.y];
public static MapTile Get(int tileId) => Get(IdToCoords(tileId));
public static MapTile? TryGet(int tileId) {
try{
return Get(tileId);
}
catch (Exception){
return null;
}
}
private static Dictionary<(int x1, int y1), (int x2, int y2, int value, ConnectorType type)[]> halfConnectors = new(){
private static readonly Dictionary<(int x1, int y1), (int x2, int y2, int value, ConnectorType type)[]> halfConnectors = new(){
[(0, 0)] =[(1, 0, 1, ConnectorType.HALL), (0, 1, 1, ConnectorType.DOOR_REMOTE)],
[(1, 0)] =[(2, 0, 1, ConnectorType.DOOR_OFFICE), (1, 1, 1, ConnectorType.DOOR_REMOTE)],
[(3, 0)] =[(2, 0, 1, ConnectorType.DOOR_OFFICE), (4, 0, 1, ConnectorType.HALL), (3, 1, 1, ConnectorType.DOOR_REMOTE)],
@ -23,14 +31,14 @@ public static class MapManager {
[(3, 1)] =[(3, 2, 1, ConnectorType.DOOR_REMOTE), (4, 1, 1, ConnectorType.HALL)]
};
private static Dictionary<(int x1, int y1), (int x2, int y2, int value)[]> mainHallwayConnectors = new(){
private static readonly Dictionary<(int x1, int y1), (int x2, int y2, int value)[]> mainHallwayConnectors = new(){
[(0,2)] = [(1,2,1)],
[(1,2)] = [(2,2,1)],
[(2,2)] = [(3,2,1)],
[(3,2)] = [(4,2,1)]
};
private static (int x, int y)[] ventTiles =[(0, 1), (4, 1), (2, 2), (0, 3), (4, 3)];
private static readonly (int x, int y)[] ventTiles =[(0, 1), (4, 1), (2, 2), (0, 3), (4, 3)];
public static void InitMap() {
for (int i = 0; i < 5; i++){
@ -94,10 +102,10 @@ public static class MapManager {
return tiles.ToArray();
}
public const int ID_X_OFFSET = 5; // map grid height
public static int CoordsToId(int x, int y) => x * ID_X_OFFSET + y;
public static (int, int) IdToCoords(int id) => (id / ID_X_OFFSET, id % ID_X_OFFSET);
private const int MAP_SIDE_LENGTH_X = 5;
public static int CoordsToId(int x, int y) => x * MAP_SIDE_LENGTH_X + y;
public static (int, int) IdToCoords(int id) => (id / MAP_SIDE_LENGTH_X, id % MAP_SIDE_LENGTH_X);
public static TileConnector[] GetDoors() => doors.ToArray();
public static TileConnector[] GetDoors(ServerPlayer player) => player == Server.P1 ? doorsP1.ToArray() : doorsP2.ToArray();

38
ONDServer/Map/MapTile.cs
View file

@ -1,43 +1,9 @@
using System.Net.Security;
using GlobalClassLib;
using ONDServer.Net;
namespace ONDServer.Map;
public class MapTile : GlobalMapTile<TileConnector, MapTile> {
public class MapTile(int id) : GlobalMapTile<TileConnector, MapTile>(id, MapManager.IdToCoords(id)) {
public ServerPlayer? Owner{ get; set; }
public MapTile(int id) : base(id, MapManager.IdToCoords(id)) {
}
// public int Id { get; private set; }
// public ServerPlayer Owner { get; private set; }
// public bool Lit { get; set; } = false;
//
// private List<TileConnector> connectors = new();
//
// public MapTile(int id, ServerPlayer owner) {
// Id = id;
// Owner = owner;
// }
// public void AddConnector(MapTile tile, TileConnector.ConnectorType type, int value) {
// connectors.Add(new TileConnector(this, tile, type, value));
// tile.connectors.Add(new TileConnector(tile, this, type, value));
//
//
// }
//
// public void AddConnectors((MapTile tile, TileConnector.ConnectorType type, int value)[] connectors) =>
// Array.ForEach(connectors, c => AddConnector(c.tile, c.type, c.value));
//
// public override string ToString() => $"{PositionAsString} -> {string.Join(", ", connectors.Select(c => c.Tiles.Item2.PositionAsString))}";
// public string PositionAsString => $"[{Id}]"; // for debug purposes
//
// public TileConnector? GetConnector(int id) {
// foreach (var con in connectors){
// if (con.Tiles.Item2.Id == id) return con;
// }
//
// return null;
// }
}

29
ONDServer/Map/TileConnector.cs
View file

@ -1,4 +1,5 @@
using GlobalClassLib;
using ONDServer.Net;
namespace ONDServer.Map;
@ -13,33 +14,5 @@ public class TileConnector : GlobalTileConnector<MapTile,TileConnector> {
Value = value;
}
// private readonly MapTile _tile1;
// private readonly MapTile _tile2;
//
// public TileConnector(MapTile tile1, MapTile tile2, TileConnector.ConnectorType type, int value) {
// _tile1 = tile1;
// _tile2 = tile2;
// Type = type;
// Value = value;
// }
//
// public (MapTile, MapTile) Tiles => (tile1: _tile1, tile2: _tile2);
//
// public ConnectorType Type { get; set; }
// public bool Blocked { get; set; } = false;
// public int Value{ get; set; }
//
// public MapTile OtherTile(MapTile tile) => Tiles.Item1 == tile ? Tiles.Item2 : Tiles.Item1;
//
// public override string ToString() => $"Con ({Tiles.Item1.PositionAsString} -> {Tiles.Item2.PositionAsString})";
// public enum ConnectorType {
// HALL,
// DOOR_REMOTE,
// DOOR_OFFICE,
// VENT
// }
public override TileConnector Clone() => new(Tiles.tile1, Tiles.tile2, Type, Value){Owner = Owner};
}

139
ONDServer/Net/CommandProcessor.cs Normal file
View file

@ -0,0 +1,139 @@
using ONDServer.Map;
using PacketLib;
namespace ONDServer.Net;
public static class CommandProcessor {
private static readonly Dictionary<int, Action<ServerPlayer, PlayerCommand>> commandHandlers = new(){
[0] = (p, c) => SwitchCamera(p, c.Args[0]),
[1] = (p, c) => SetMonitorState(p, c.Args[0] == 1),
[2] = (p, c) => SetDoorStateOffice(p, c.Args[0], c.Args[1] == 1),
[3] = (p, c) => SetDoorStateRemote(p.State.Pid, (c.Args[0], c.Args[1]), c.Args[2] == 1),
[4] = (p, c) => SetLightState(p, c.Args[0], c.Args[1] == 1)
};
public static void Evaluate(PlayerCommand[] commands, int pid) {
ServerPlayer currentPlayer = Server.Players[pid];
foreach (var playerCommand in commands){
commandHandlers[playerCommand.Id](currentPlayer, playerCommand);
// 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:
// bool monitorState = playerCommand.Args[0] == 1;
// currentPlayer.state.monitorUp = monitorState;
// Console.WriteLine($"C: Player {pid} toggled camera {(monitorState ? "on" : "off")}");
// Server.SendUpdateToAll([GameEvent.TOGGLE_MONITOR(pid, monitorState)]);
// break;
// case 2:
// bool doorState = playerCommand.Args[1] == 1;
// currentPlayer.state.doorStates[playerCommand.Args[0]] = doorState;
// TileConnector? officeDoor = MapManager.Get(currentPlayer.state.officeTileId).GetConnector(currentPlayer.state.neighbouringTiles[playerCommand.Args[0]]);
// officeDoor.Blocked = doorState;
//
// if (doorState){
// GameLogic.PowerConsumers[officeDoor] = (GameLogic.OfficeDoorUsage, pid);
// }
// else{
// GameLogic.PowerConsumers.Remove(officeDoor);
// }
//
// Console.WriteLine($"C: Player {pid} {(doorState ? "closed" : "opened")} door {playerCommand.Args[0]}");
// Server.SendUpdateToAll([GameEvent.TOGGLE_DOOR_OFFICE(pid,playerCommand.Args[0] ,doorState)]);
// break;
// case 3:
// TileConnector? door = MapManager.Get(playerCommand.Args[0]).GetConnector(playerCommand.Args[1]);
// if(door == null) return;
//
// door.Blocked = playerCommand.Args[2] == 1;
// if (door.Blocked){
// GameLogic.PowerConsumers[door] = (GameLogic.RemoteDoorUsage, pid);
// }
// else{
// GameLogic.PowerConsumers.Remove(door);
// }
//
// Console.WriteLine($"C: Player {pid} {(door.Blocked ? "closed" : "opened")} door {(playerCommand.Args[0], playerCommand.Args[1])}");
// Server.SendUpdateToAll([GameEvent.TOGGLE_DOOR_REMOTE(pid, (playerCommand.Args[0], playerCommand.Args[1]), door.Blocked)]);
// break;
// case 4:
// bool lit = playerCommand.Args[1] == 1;
// MapTile lightTile = MapManager.Get(playerCommand.Args[0]);
// lightTile.Lit = lit;
// if (lit){
// GameLogic.PowerConsumers[lightTile] = (GameLogic.LightUsage, pid);
// }
// else{
// GameLogic.PowerConsumers.Remove(lightTile);
// }
//
// Server.SendUpdateToAll([GameEvent.TOGGLE_LIGHT(pid, playerCommand.Args[0], lit)]);
// break;
// }
}
}
private static void SwitchCamera(ServerPlayer currentPlayer, int cameraId) {
if (MapManager.TryGet(cameraId) == null || Server.Players.Values.Any(p => p.State.OfficeTileId == cameraId)) return;
Console.WriteLine($"C: Player {currentPlayer.State.Pid} switched to camera {cameraId}");
currentPlayer.State.Camera = cameraId;
Server.SendUpdateToAll([GameEvent.SWITCH_CAM(currentPlayer.State.Pid, cameraId)]);
}
private static void SetMonitorState(ServerPlayer currentPlayer, bool monitorState) {
currentPlayer.State.MonitorUp = monitorState;
Console.WriteLine($"C: Player {currentPlayer.State.Pid} toggled camera {(monitorState ? "on" : "off")}");
Server.SendUpdateToAll([GameEvent.TOGGLE_MONITOR(currentPlayer.State.Pid, monitorState)]);
}
private static void SetDoorStateOffice(ServerPlayer currentPlayer, int doorId, bool doorState) {
if (doorId < 0 || currentPlayer.State.DoorStates.Length <= doorId) return;
currentPlayer.State.DoorStates[doorId] = doorState;
TileConnector? officeDoor = MapManager.Get(currentPlayer.State.OfficeTileId).GetConnector(currentPlayer.State.NeighbouringTiles[doorId]);
if (officeDoor == null) return;
officeDoor.Blocked = doorState;
if (doorState){
GameLogic.PowerConsumers[officeDoor] = (GameLogic.OfficeDoorUsage, currentPlayer.State.Pid);
}
else{
GameLogic.PowerConsumers.Remove(officeDoor);
}
Console.WriteLine($"C: Player {currentPlayer.State.Pid} {(doorState ? "closed" : "opened")} door {doorId}");
Server.SendUpdateToAll([GameEvent.TOGGLE_DOOR_OFFICE(currentPlayer.State.Pid, doorId ,doorState)]);
}
private static void SetDoorStateRemote(int pid, (int tile1, int tile2) doorId, bool state) {
TileConnector? door = MapManager.Get(doorId.tile1).GetConnector(doorId.tile2);
if(door == null) return;
door.Blocked = state;
if (door.Blocked){
GameLogic.PowerConsumers[door] = (GameLogic.RemoteDoorUsage, pid);
}
else{
GameLogic.PowerConsumers.Remove(door);
}
Console.WriteLine($"C: Player {pid} {(door.Blocked ? "closed" : "opened")} door {doorId}");
Server.SendUpdateToAll([GameEvent.TOGGLE_DOOR_REMOTE(pid, doorId, door.Blocked)]);
}
public static void SetLightState(ServerPlayer currentPlayer, int tileId, bool state) {
MapTile lightTile = MapManager.Get(tileId);
lightTile.Lit = state;
if (state){
GameLogic.PowerConsumers[lightTile] = (GameLogic.LightUsage, currentPlayer.State.Pid);
}
else{
GameLogic.PowerConsumers.Remove(lightTile);
}
Server.SendUpdateToAll([GameEvent.TOGGLE_LIGHT(currentPlayer.State.Pid, tileId, state)]);
}
}

79
ONDServer/Server.cs → ONDServer/Net/Server.cs
View file

@ -1,35 +1,32 @@
using System;
using System.Collections;
using System.Diagnostics;
using System.Threading;
using ONDServer.Map;
using GlobalClassLib;
using LiteNetLib;
using LiteNetLib.Utils;
using PacketLib;
namespace ONDServer;
namespace ONDServer.Net;
public class Server {
public static class Server {
public static ServerPlayer P1;
public static ServerPlayer P2;
public static readonly Dictionary<int, ServerPlayer> Players = new();
public static ServerPlayer OtherPlayer(ServerPlayer player) => player.state.pid == P1.state.pid ? P2 : P1;
public static ServerPlayer OtherPlayer(ServerPlayer player) => player.State.Pid == P1.State.Pid ? P2 : P1;
public static bool AutoStop{ get; set; } = true;
private static EventBasedNetListener listener;
private static NetManager server;
private const int TargetTickRate = 30;
private const double TargetDeltaTime = 1.0 / TargetTickRate;
private const long TargetTickTimeMs = 1000 / TargetTickRate;
private const int TARGET_TICK_RATE = 30;
private const double TARGET_DELTA_TIME = 1.0 / TARGET_TICK_RATE;
private const long TARGET_TICK_TIME_MS = 1000 / TARGET_TICK_RATE;
private static NetDataWriter writer;
private static NetPacketProcessor processor;
private static bool isRunning;
// AI generated
public static void Start(int port) {
writer = new NetDataWriter();
processor = new NetPacketProcessor();
@ -61,9 +58,7 @@ public class Server {
OnNetworkReceive(peer, reader, method);
};
listener.PeerDisconnectedEvent += (peer, info) => {
OnPeerDisconnected(peer, info);
};
listener.PeerDisconnectedEvent += OnPeerDisconnected;
server.Start(port);
@ -78,58 +73,50 @@ public class Server {
}
}
public static void SendPacket<T>(T packet, int pid, DeliveryMethod deliveryMethod = DeliveryMethod.ReliableOrdered) where T : class, new() {
SendPacket(packet, Players[pid].peer, deliveryMethod);
SendPacket(packet, Players[pid].Peer, deliveryMethod);
}
public static void SendPacketToAll<T>(T packet, DeliveryMethod deliveryMethod = DeliveryMethod.ReliableOrdered) where T : class, new() {
foreach (var player in Players.Values){
SendPacket(packet, player.peer, deliveryMethod);
SendPacket(packet, player.Peer, deliveryMethod);
}
}
public static void SendUpdate(GameEvent[] gevents, int pid) {
// SendPacket(new UpdatePlayerPacket{eventQueue = new EventQueue{Events = events}}, pid);
SendPacket(new UpdatePlayerPacket{events = gevents}, pid);
SendPacket(new UpdatePlayerPacket{Events = gevents}, pid);
}
public static void SendUpdateToAll(GameEvent[] gevents) {
// SendPacketToAll(new UpdatePlayerPacket{eventQueue = new EventQueue{Events = events}});
SendPacketToAll(new UpdatePlayerPacket{events = gevents});
SendPacketToAll(new UpdatePlayerPacket{Events = gevents});
}
public static void OnJoinReceived(JoinPacket packet, NetPeer peer) {
Console.WriteLine($"Received join from {packet.username} (pid: {(uint)peer.Id})");
Console.WriteLine($"Received join from {packet.Username} (pid: {(uint)peer.Id})");
ServerPlayer newPlayer = (Players[peer.Id] = new ServerPlayer {
peer = peer,
state = new PlayerState {
pid = peer.Id,
camera = GameLogic.START_CAMERA,
doorStates = [false, false, false],
power = Power.MAX_POWER_VALUE,
poweredOut = false
},
username = packet.username
Peer = peer,
State = new PlayerState(peer.Id, GameLogic.START_CAMERA, [false, false, false],
Power.MAX_POWER_VALUE, false),
Username = packet.Username
});
if (Players.Count == 1){
newPlayer.state.officeTileId = 10;
newPlayer.state.neighbouringTiles = [5, 11, 15];
SendPacket(new JoinAcceptPacket { state = newPlayer.state }, peer);
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];
newPlayer.State.OfficeTileId = 14;
newPlayer.State.NeighbouringTiles = [19, 13, 9];
SendPacket(new JoinAcceptPacket { state = newPlayer.state }, peer);
SendPacket(new JoinAcceptPacket { State = newPlayer.State }, peer);
P2 = newPlayer;
SendPacket(new OpponentInitPacket{state = newPlayer.state, username = newPlayer.username}, P1.peer);
SendPacket(new OpponentInitPacket{state = P1.state, username = P1.username}, P2.peer);
SendPacket(new OpponentInitPacket{State = newPlayer.State, Username = newPlayer.Username}, P1.Peer);
SendPacket(new OpponentInitPacket{State = P1.State, Username = P1.Username}, P2.Peer);
GameLogic.Init();
}
@ -141,7 +128,7 @@ public class Server {
public static void OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo) {
if (Players.Count == 2){
GameLogic.DeclareWinner(OtherPlayer(Players.Values.First(p => Equals(p.peer, peer))));
GameLogic.DeclareWinner(OtherPlayer(Players.Values.First(p => Equals(p.Peer, peer))));
}
Players.Remove(peer.Id);
@ -151,15 +138,15 @@ public class Server {
}
public static void OnCommandReceived(PlayerCommandPacket packet, NetPeer peer) {
CommandProcessor.Evaluate(packet.commands, peer.Id);
CommandProcessor.Evaluate(packet.Commands, peer.Id);
}
public static void Update() {
server.PollEvents();
// Console.WriteLine("update");
GameLogic.Update();
}
// AI generated
public static void Run(CancellationToken cancellationToken = default)
{
isRunning = true;
@ -171,26 +158,26 @@ public class Server {
long currentTicks = stopwatch.ElapsedMilliseconds;
long elapsed = currentTicks - previousTicks;
if (elapsed >= TargetTickTimeMs)
if (elapsed >= TARGET_TICK_TIME_MS)
{
Update();
previousTicks = currentTicks;
if (elapsed > TargetTickTimeMs * 2)
if (elapsed > TARGET_TICK_TIME_MS * 2)
{
Console.WriteLine($"Warning: Tick took {elapsed}ms (target: {TargetTickTimeMs}ms)");
Console.WriteLine($"Warning: Tick took {elapsed}ms (target: {TARGET_TICK_TIME_MS}ms)");
}
}
else
{
int sleepTime = (int)(TargetTickTimeMs - elapsed - 2);
int sleepTime = (int)(TARGET_TICK_TIME_MS - elapsed - 2);
if (sleepTime > 0)
{
Thread.Sleep(sleepTime);
}
while (stopwatch.ElapsedMilliseconds - previousTicks < TargetTickTimeMs){
while (stopwatch.ElapsedMilliseconds - previousTicks < TARGET_TICK_TIME_MS){
Thread.SpinWait(1);
}
}

10
ONDServer/Net/ServerPlayer.cs Normal file
View file

@ -0,0 +1,10 @@
using LiteNetLib;
using PacketLib;
namespace ONDServer.Net;
public class ServerPlayer {
public NetPeer Peer;
public PlayerState State;
public string Username;
}

3
ONDServer/Program.cs
View file

@ -1,8 +1,9 @@
using System.Diagnostics;
using ONDServer.Net;
namespace ONDServer;
public class Program {
public static class Program {
public static void Main(string[] args) {
if (args.Contains("--persistent")){
Server.AutoStop = false;

10
ONDServer/ServerPlayer.cs
View file

@ -1,10 +0,0 @@
using LiteNetLib;
using PacketLib;
namespace ONDServer;
public class ServerPlayer {
public NetPeer peer;
public PlayerState state;
public string username;
}