// snake game commands
public void SnakeGame_OnSnakeMove(SnakePlayer snake)
{
_playedMoves++;
UpdateFitness(snake);
var directions = Enum.GetValues(typeof(Direction)).OfType <Direction>().Where(d => d != Direction.none).OrderBy(d => (int)d).ToList();
//var avoidRates = directions.Select((d, i) => (dir: d, rate: WallAwareness[i] / 100 * (MAX_DISTANCE[(int)d] - snake.GetWallDistance(d)) * AvoidLevel / 100));
//var eagerRates = directions.Select((d, i) => (dir: d, rate: FoodAwareness[i] / 100 * (MAX_DISTANCE[(int)d] - snake.GetFoodDistance(d)) * EagerLevel / 100));
var eagerRates = directions.Select((d, i) => (dir: d, rate: FoodAwareness[i] / 100 * (100d * snake.GetFoodDistance(d) / MAX_DISTANCE[(int)d]) * EagerLevel / 100));
// implement random factor to adjust rates randomly
//var randomFactor = new []
//{
// RandomData.GetInt(0, Convert.ToInt32(AvoidLevel * 100)),
// RandomData.GetInt(0, Convert.ToInt32(EagerLevel * 100)),
//};
//var avoidRateAvg = avoidRates.Average(e => e.rate); // MIN values are the best to take...
var eagerRateAvg = eagerRates.Average(e => e.rate); // MAX values are the best to take...
//var result = eagerRateAvg > avoidRateAvg
// ? eagerRates.OrderByDescending(e => e.rate)
// : avoidRates.OrderBy(e => e.rate);
var result = eagerRates.Where(e => e.rate > 0).OrderBy(e => e.rate);
//var notAllowedDirection = GetOppositeDirection(snake.Direction);
//var maxRate = result.First(e => e.dir != notAllowedDirection);
var maxRate = result.Any() ? result.First() : eagerRates.OrderBy(e => e.rate).First();
snake.SetDirection(maxRate.dir);
ShowDebugData(maxRate.dir, snake, eagerRates.Select(i => i.rate), eagerRates.Select(i => i.rate));
}
public Board(float Xsize, float Ysize, Interface parent)
{
playerList = new SnakePlayer[2];
playerList[0] = new SnakePlayer(5, 10, GameObject.Find("Player1"), parent.player1Tail, this);
playerList[1] = new SnakePlayer(15, 10, GameObject.Find("Player2"), parent.player2Tail, this);
powerupList = new List <PowerUp>();
maxX = Xsize;
maxY = Ysize;
this.parent = parent;
GameObject border;
border = new GameObject("BorderBottom", typeof(SpriteRenderer));
border.GetComponent <Transform>().position = new Vector3(0, 0, -50);
border.GetComponent <SpriteRenderer>().sprite = parent.playborder;
border.GetComponent <SpriteRenderer>().drawMode = SpriteDrawMode.Tiled;
border.GetComponent <SpriteRenderer>().size = new Vector2(Xsize, 0.5f);
border = new GameObject("BorderLeft", typeof(SpriteRenderer));
border.GetComponent <Transform>().position = new Vector3(0, 0, -50);
border.GetComponent <Transform>().Rotate(0, 0, 90);
border.GetComponent <SpriteRenderer>().sprite = parent.playborder;
border.GetComponent <SpriteRenderer>().drawMode = SpriteDrawMode.Tiled;
border.GetComponent <SpriteRenderer>().size = new Vector2(Ysize, 0.5f);
border = new GameObject("BorderRight", typeof(SpriteRenderer));
border.GetComponent <Transform>().position = new Vector3(Xsize, 0, -50);
border.GetComponent <Transform>().Rotate(0, 0, 90);
border.GetComponent <SpriteRenderer>().sprite = parent.playborder;
border.GetComponent <SpriteRenderer>().drawMode = SpriteDrawMode.Tiled;
border.GetComponent <SpriteRenderer>().size = new Vector2(Ysize, 0.5f);
border = new GameObject("BorderTop", typeof(SpriteRenderer));
border.GetComponent <Transform>().position = new Vector3(0, Ysize, -50);
border.GetComponent <SpriteRenderer>().sprite = parent.playborder;
border.GetComponent <SpriteRenderer>().drawMode = SpriteDrawMode.Tiled;
border.GetComponent <SpriteRenderer>().size = new Vector2(Xsize, 0.5f);
}
public PCSnakeAI(SnakePlayer player) : base(player)
{
m_player = player as SnakePlayer;
m_context = GameManager.Instance.Context;
RandomDirection();
}
static void Main(string[] args)
{
InitialSetup.InitializeWindow();
SnakePlayer snakePlayer = new SnakePlayer("Nikolay");
AppleHandler appleHandler = new AppleHandler();
Timer timer = new Timer(x => appleHandler.GenerateApple(), null, 1000, 3000);
Print.PrintWindow(snakePlayer);
while (true)
{
if (!snakePlayer.IsAlive)
{
Print.PrintEndGame(snakePlayer);
break;
}
Print.ClearSnake(snakePlayer);
if (!Console.KeyAvailable)
{
snakePlayer.Move(appleHandler);
}
else
{
ConsoleKeyInfo keyPressed = Console.ReadKey();
snakePlayer.Move(keyPressed, appleHandler);
}
Print.PrintApples(appleHandler);
Print.PrintSnake(snakePlayer);
Thread.Sleep(100);
}
}
private void ShowDebugData(Direction direction, SnakePlayer snake, IEnumerable <double> avoidRates, IEnumerable <double> eagerRates)
{
var directions = Enum.GetValues(typeof(Direction)).OfType <Direction>().Where(d => d != Direction.none).ToList();
var wallAwareness = WallAwareness.Select(v => v.ToString("F1")).Aggregate((a, b) => $"{a}, {b}");
var wallDistances = directions.Select(d => snake.GetWallDistance(d).ToString("F1")).Aggregate((a, b) => $"{a}, {b}");
var avoidRatesDbg = directions.Select(d => avoidRates.ElementAt((int)d).ToString("F1")).Aggregate((a, b) => $"{a}, {b}");
var foodAwareness = FoodAwareness.Select(v => v.ToString("F1")).Aggregate((a, b) => $"{a}, {b}");
var foodDistances = directions.Select(d => snake.GetFoodDistance(d).ToString("F1")).Aggregate((a, b) => $"{a}, {b}");
var eagerRatesDbg = directions.Select(d => eagerRates.ElementAt((int)d).ToString("F1")).Aggregate((a, b) => $"{a}, {b}");
var debug = string.Concat(
$"Gen. #{_generationId:00} / Snake #{_individualId:00} - {Fitness:F} pts", Environment.NewLine, Environment.NewLine,
"Wall Aware: ", wallAwareness, Environment.NewLine,
"Food Aware: ", foodAwareness, Environment.NewLine,
"Avoid. Lvl: ", AvoidLevel.ToString("F"), Environment.NewLine,
"Eager Lvl: ", EagerLevel.ToString("F"), Environment.NewLine, Environment.NewLine,
"Wall Dist.: ", wallDistances, Environment.NewLine,
"Avoid Rate: ", avoidRatesDbg, Environment.NewLine,
"Food Dist.: ", foodDistances, Environment.NewLine,
"Eager Rate: ", eagerRatesDbg, Environment.NewLine, Environment.NewLine,
"Dir. Taken: ", direction
);
Program.NotifyDebugData(debug);
}
public static void PrintEndGame(SnakePlayer player)
{
string endMessage = "Game Over! Score: " + player.Score;
Console.SetCursorPosition((Window.Width - endMessage.Length - 2) / 2, Window.Height / 2);
Console.Write(endMessage);
Console.SetCursorPosition((Window.Width - endMessage.Length - 2) / 2, (Window.Height / 2) + 1);
}
public Form1()
{
InitializeComponent();
rand = new Random();
player = new SnakePlayer(1000, rand);
player.Init();
game = new SnakeGame(rand, 20);
game.Init();
}
public void ShouldReportCurrentDirection()
{
var snake = new SnakePlayer("id", "name", 0, new []
{
new MapCoordinate(1, 0),
new MapCoordinate(0, 0),
});
Assert.Equal(Direction.Right, snake.CurrentDirection);
}
private void ReleasePlayerAt(int index)
{
if (index >= 0)
{
SnakePlayer player = m_listPlayer[index];
m_listPlayer.RemoveAt(index);
player.Release();
}
}
public void Hurt(Interface parent, SnakePlayer n)
{
lifecount[Array.IndexOf(playboard.playerList, n)]--;
if (lifecount[0] == 0 && lifecount[1] == 0)
{
parent.winner = 0;
playboard.GameEnd();
parent.State(Interface.Screen.Over);
}
}
private void ReleasePlayerAt(int index)
{
if (index >= 0)
{
SnakePlayer player = playerList[index];
playerList.RemoveAt(index);
player.Release();
}
}
public string GetPlayerScore()
{
uint m_mainPlayerId = 1;
string result = "0";
SnakePlayer mainPlayer = GameManager.Instance.GetPlayer(m_mainPlayerId);
if (mainPlayer != null)
{
result = mainPlayer.Data.Score.ToString();
}
return(result);
}
public static void ClearSnake(SnakePlayer player)
{
//foreach (Point bodyPart in player.Body)
//{
// Console.SetCursorPosition(bodyPart.X, bodyPart.Y);
// Console.Write(" ");
//}
Point tail = player.Body[player.Body.Count() - 1];
Console.SetCursorPosition(tail.X, tail.Y);
Console.Write(" ");
}
public void GetResultOfDirection_ReturnsExpectedResult(Direction direction, DirectionalResult result)
{
var snake = new SnakePlayer("bestsnake", String.Empty, 0, new[]
{
new MapCoordinate(0, 0),
new MapCoordinate(0, 1),
new MapCoordinate(1, 1),
new MapCoordinate(1, 2)
});
var map = new Map(5, 5, 1, snake, new[] { snake }, new[] { new MapCoordinate(1, 0) }, new[] { new MapCoordinate(0, 0) });
Assert.Equal(result, map.GetResultOfDirection("bestsnake", direction));
}
public void AbleToUseDirectionReturnsValidResult(Direction direction, bool expectedResult)
{
var snake = new SnakePlayer("bestsnake", String.Empty, 0, new[]
{
new MapCoordinate(0, 0),
new MapCoordinate(0, 1),
new MapCoordinate(1, 1),
new MapCoordinate(1, 2)
});
var map = new Map(5, 5, 1, snake, new[] { snake }, new[] { new MapCoordinate(1, 0) }, new[] { new MapCoordinate(0, 0) });
Assert.Equal(expectedResult, map.AbleToUseDirection("bestsnake", direction));
}
void Update()
{
if (GameManager.Instance.IsRunning)
{
SnakePlayer player = GameManager.Instance.GetPlayer(FocusPlayerId);
if (player != null)
{
Vector3 targetPos = player.Head.Position();
targetPos = m_context.EntityToViewPoint(targetPos);
Vector3 pos = this.transform.position;
pos.x = targetPos.x;
pos.y = targetPos.y;
this.transform.position = pos;
}
}
}
public void CheckCameraZoom()
{
SnakePlayer mainPlayer = GameManager.Instance.GetPlayer(1);
if (mainPlayer != null)
{
float vs = mainPlayer.Data.snakeData.length / 250f;
if (vs < 1)
{
vs = 1;
}
//zoom out camera if the snake becomes large
if (Camera.main.orthographicSize < 720)
{
Camera.main.orthographicSize = vs * 240;
}
}
}
//==================================================================
internal void CreatePlayer(uint playerId)
{
PlayerData data = m_mapPlayerData[playerId];
SnakePlayer player = new SnakePlayer();
Vector3 mapSize = m_context.mapSize;
Vector3 posMax = mapSize * 0.7f;
Vector3 posMin = mapSize - posMax;
Vector3 pos = new Vector3();
pos.x = m_context.random.Range(posMin.x, posMax.x);
pos.y = m_context.random.Range(posMin.y, posMax.y);
pos.z = m_context.random.Range(posMin.z, posMax.z);
pos.z = 0;
player.Create(data, pos);
m_listPlayer.Add(player);
}
public void CheckCameraZoom()
{
SnakePlayer mainPlayer = GameManager.Instance.GetPlayer(GameCamera.FocusPlayerId);
if (mainPlayer != null)
{
float vs = mainPlayer.Data.score / 250f;
//zoom out camera if the snake becomes large
if (vs > 1)
{
if (Camera.main.orthographicSize < 720)
{
Camera.main.orthographicSize = vs * 240;
}
}
}
}
private bool FindEnemies()
{
List <SnakePlayer> listSnake = GameManager.Instance.GetPlayerList();
int testDistance = m_player.SnakeData.size * 4;
for (int j = 0; j < listSnake.Count; j++)
{
SnakePlayer other = listSnake[j];
if (m_player != other)
{
if (m_player.HitTest(other, testDistance))
{
return(true);
}
}
}
return(false);
}
public string GetPlayerScore()
{
string result = "0";
List <SnakePlayer> playerList = GameManager.Instance.GetPlayerList();
uint userID = UserManager.Instance.MainUserData.id;
foreach (SnakePlayer tempPlayer in playerList)
{
if (tempPlayer.Data.userId == userID)
{
m_mainPlayerId = tempPlayer.Id;
}
}
SnakePlayer mainPlayer = GameManager.Instance.GetPlayer(m_mainPlayerId);
if (mainPlayer != null)
{
result = mainPlayer.Data.Score.ToString();
}
return(result);
}
//======================================================================
public void InputVKey(int vkey, float arg, uint playerId)
{
if (playerId == 0)
{
//handle other VKey, global Vkey like GameExit, CreatePlayer
HandleOtherVKey(vkey, arg, playerId);
}
else
{
SnakePlayer player = GetPlayer(playerId);
if (player != null)
{
player.InputVKey(vkey, arg);
}
else
{
//handle other Vkey
HandleOtherVKey(vkey, arg, playerId);
}
}
}
public static void PrintSnake(SnakePlayer player)
{
//int bodyCount = 0;
//foreach (Point bodyPart in player.Body)
//{
// Console.SetCursorPosition(bodyPart.X, bodyPart.Y);
// if (bodyCount == 0)
// {
// Console.Write(player.HeadSymbol);
// }
// else
// {
// Console.Write(player.BodySymbol);
// }
// bodyCount++;
//}
Console.SetCursorPosition(player.HeadPosition.X, player.HeadPosition.Y);
Console.Write(player.HeadSymbol);
Console.SetCursorPosition(player.Body[1].X, player.Body[1].Y);
Console.Write(player.BodySymbol);
}
//======================================================================
public void InputVKey(int vkey, float arg, uint playerId)
{
if (playerId == 0)
{
//处理其它VKey，全局性的VKey
HandleOtherVKey(vkey, arg, playerId);
}
else
{
SnakePlayer player = GetPlayer(playerId);
if (player != null)
{
player.InputVKey(vkey, arg);
}
else
{
//处理其它Vkey
HandleOtherVKey(vkey, arg, playerId);
}
}
}
public PlayerComponent(SnakePlayer player)
{
}
public void Effect(SnakePlayer n)
{
;
}
public Game()
{
Input.LastDirection = Input.Direction;
Coords = new List<Coord> {new Coord(10, 10), new Coord(10, 10), new Coord(10, 10), new Coord(10, 10) };
Apple.SetAppleOnField();
var timer = new Stopwatch();
timer.Start();
while (!State.GameOver)
{
Input.CheckInput();
if (State.Paused) continue;
if (timer.ElapsedMilliseconds < 100) continue;
timer.Restart();
Player = new SnakePlayer();
switch (Input.Direction)
{
case 0:
Player.NewHeadCoord.Y--;
break;
case 1:
Player.NewHeadCoord.X++;
break;
case 2:
Player.NewHeadCoord.Y++;
break;
default:
Player.NewHeadCoord.X--;
break;
}
if (Player.NewHeadCoord.X < 0 || Player.NewHeadCoord.X >= BoardW)
State.GameOver = true;
else if (Player.NewHeadCoord.Y < 0 || Player.NewHeadCoord.Y >= BoardH)
State.GameOver = true;
if (Player.NewHeadCoord.X == AppleCoord.X && Player.NewHeadCoord.Y == AppleCoord.Y)
{
if (Coords.Count + 1 >= BoardW * BoardH)
// No more room to place apples -- game over.
State.GameOver = true;
else
{
Apple.SetAppleOnField();
}
}
if (!State.AppleEaten)
{
Coords.RemoveAt(0);
foreach (var x in Coords)
if (x.X == Player.NewHeadCoord.X && x.Y == Player.NewHeadCoord.Y)
{
// Death by accidental self-cannibalism.
State.GameOver = true;
break;
}
}
if (State.GameOver) continue;
DrawChar(Player.HeadCoord, '0');
if (!State.AppleEaten)
{
DrawChar(Player.TailCoord, ' ');
}
else
{
Apple.DrawApple();
State.AppleEaten = false;
}
Coords.Add(Player.NewHeadCoord);
DrawChar(Player.NewHeadCoord, '@');
Input.LastDirection = Input.Direction;
}
}
public void Hurt(Interface parent, SnakePlayer n)
{
;
}
//===========================================================================
public void EnterFrame(int frameIndex)
{
if (!m_isRunning)
{
return;
}
if (frameIndex < 0)
{
m_context.currentFrameIndex++;
}
else
{
m_context.currentFrameIndex = frameIndex;
}
EntityFactory.ClearReleasedObjects();
for (int i = 0; i < m_listPlayer.Count; ++i)
{
m_listPlayer[i].EnterFrame(frameIndex);
}
List <uint> listDiePlayerId = new List <uint>();
for (int i = 0; i < m_listPlayer.Count; i++)
{
SnakePlayer player = m_listPlayer[i];
if (player.TryHitBound(m_context))
{
listDiePlayerId.Add(player.Id);
ReleasePlayerAt(i);
i--;
continue;
}
if (player.TryHitEnemies(m_listPlayer))
{
listDiePlayerId.Add(player.Id);
ReleasePlayerAt(i);
i--;
continue;
}
for (int j = 0; j < m_listFood.Count; j++)
{
EntityObject food = m_listFood[j];
if (player.TryEatFood(food))
{
RemoveFoodAt(j);
j--;
}
}
}
if (m_map != null)
{
m_map.EnterFrame(frameIndex);
}
if (onPlayerDie != null)
{
for (int i = 0; i < listDiePlayerId.Count; ++i)
{
onPlayerDie(listDiePlayerId[i]);
}
}
}
public override void Release()
{
m_player = null;
}
public static void PrintWindow(SnakePlayer player)
{
Console.CursorVisible = false;
PrintInfo(player.Name, player.Score);
PrintFrame();
}
