private SnakeSettings MakeSnakeSettings()
{
SnakeSettings snakeSettings = new SnakeSettings(ProgramSettings.GRID_ROWS, ProgramSettings.GRID_COLUMNS, ProgramSettings.SIDE_LENGTH,
ProgramSettings.POINTS_PER_FOOD_EATEN, ProgramSettings.RANDOM_GENERATOR);
return(snakeSettings);
}
/// <summary>
/// Initializes a new instance of the <see cref="PlaytestRecording"/> class. After instantiation
/// the class is ready for taking snapshots of a playtest simulation.
/// </summary>
/// <param name="agent"></param>
/// <param name="networkSettings"></param>
/// <param name="snakeSettings"></param>
public PlaytestRecording(Agent agent, NetworkSettings networkSettings, SnakeSettings snakeSettings)
{
Agent = agent;
NetworkSettings = networkSettings;
SnakeSettings = snakeSettings;
PlaytestRoundInfoList = new List <PlaytestRoundInfo>();
}
public SettingsGUI(GeneticSettings geneticSettings, NetworkSettings networkSettings, SnakeSettings snakeSettings)
{
this.geneticSettings = geneticSettings;
this.networkSettings = networkSettings;
this.snakeSettings = snakeSettings;
InitializeComponent();
}
/// <summary>
/// Initializes a new instance of the class <see cref="FitnessCalculatorRecording"/>
/// which is able to save information about a fitness calculation.
/// </summary>
/// <param name="agent"></param>
/// <param name="networkSettings"></param>
/// <param name="snakeSettings"></param>
public FitnessCalculatorRecording(Agent agent, NetworkSettings networkSettings, SnakeSettings snakeSettings)
{
Agent = agent;
originalEndGameInfo = agent.FitnessInfo as EndGameInfo;
NetworkSettings = networkSettings;
SnakeSettings = snakeSettings;
FitnessRoundInfoList = new List <FitnessRoundInfo>();
}
public static SnakeSettingsGUI ConvertSettingsLogicToGUI(SnakeSettings snakeSettings)
{
SnakeSettingsGUI snakeSettingsGUI = new SnakeSettingsGUI(snakeSettings.RowCount,
snakeSettings.ColumnCount,
snakeSettings.SideLengthGUI);
return(snakeSettingsGUI);
}
public static SnakeSettings ConvertSettingsGUIToLogic(SnakeSettingsGUI snakeSettings)
{
SnakeSettings snakeSettingsLogic = new SnakeSettings(snakeSettings.RowCount,
snakeSettings.ColumnCount,
snakeSettings.SideLength,
1,
new RandomNumberGenerator());
return(snakeSettingsLogic);
}
public SettingsGUI(SnakeAISettings snakeAISettings)
{
this.snakeAISettings = snakeAISettings;
this.geneticSettings = snakeAISettings.GeneticSettings;
this.networkSettings = snakeAISettings.NetworkSettings;
this.snakeSettings = snakeAISettings.SnakeSettings;
StartPosition = FormStartPosition.CenterScreen;
InitializeComponent();
}
/// <summary>
/// Show replay of the given agent.
/// </summary>
/// <param name="agentToShow"></param>
/// <param name="geneticSettings"></param>
public void ViewAgent(Agent agentToShow, GeneticSettings geneticSettings)
{
networkSettings = (geneticSettings.FitnessCalculator as SnakeFitnessCalculator).NetworkSettings;
snakeSettings = (geneticSettings.FitnessCalculator as SnakeFitnessCalculator).SnakeSettings;
SnakeFitnessCalculator fitnessCalculator = geneticSettings.FitnessCalculator as SnakeFitnessCalculator;
FitnessCalculatorRecording recording = fitnessCalculator.RecordCalculation(agentToShow);
MilisecondsForm milisecondsForm = new MilisecondsForm();
milisecondsForm.ShowDialog();
speedMS = milisecondsForm.speedMS;
ShowPlay(recording);
}
static void SnakeMenuLoad(IDrawningRectangle <SignConsole> location, Action startWithClose)
{
var menu = new KeyboardMenu <ButtonInConsole>("Snake");
var snakeMenu = new ConsolePrintMenu(location.Width, location.Height, location, menu);
location.Register((0, 0), snakeMenu, snakeMenu.GetCoordinates());
var printer = new BigPixelPrint(snakeMenu.Width, 5, snakeMenu, letters);
snakeMenu.Register((0, 1), printer, printer.GetCoordinates());
snakeMenu.SetWriter(printer);
void act()
{
snakeMenu.Load();
MenuKeySet(menu, new bool[] { false, false, true });
}
var buttons = MenuInicialisation(menu, snakeMenu, new string[] { "Start", "Mode", "Settings", "Exit" });
var snakeSettings = new SnakeSettings();
buttons[0].IsPressed += () =>
{
snakeMenu.Hide();
SnakeStart(location, snakeSettings, act);
KeyPress.SetControl("Menu");
snakeMenu.Load();
};
buttons[1].IsPressed += () =>
{
snakeMenu.Hide();
SnakeMode(location, act, snakeSettings);
};
buttons[2].IsPressed += () =>
{
snakeMenu.Hide();
SnakeSettings(location, act);
};
buttons[3].IsPressed += () => {
snakeMenu.Close();
location.CancelRegistration(snakeMenu);
MenuKeyClose();
startWithClose?.Invoke();
};
act();
}
private GeneticSettings MakeGeneticSettings(NetworkSettings networkSettings, SnakeSettings snakeSettings)
{
GeneticSettings geneticSettings = new GeneticSettings(ProgramSettings.POPULATION_SIZE,
networkSettings.numberOfWeights,
ProgramSettings.SELECTION_SIZE,
ProgramSettings.MUTATION_PROBABALITY_AGENT,
ProgramSettings.MUTATION_PROBABILITY_GENE,
ProgramSettings.RANDOM_GENERATOR,
new SnakeFitnessCalculator(networkSettings, snakeSettings),
ProgramSettings.MUTATION_METHOD,
ProgramSettings.SELECTION_METHOD,
ProgramSettings.CROSSOVER_METHOD,
ProgramSettings.AGENT_VIEWER,
ProgramSettings.TOP_K_AGENTS_COUNT);
return(geneticSettings);
}
public void Initialize(FieldBuilder builder, SnakeSettings settings)
{
this.settings = settings;
this.info = new FieldInfo()
{
Width = settings.Width,
Length = settings.Length,
};
this.builder = builder;
var bonusPrefabs = new Dictionary <Bonus, Transform>();
for (int i = 0; i < settings.Bonuses.Count; i++)
{
var b = settings.Bonuses[i];
bonusPrefabs.Add(b.type, b.prefab);
}
builder.SetBonusPrefabs(bonusPrefabs);
}
private void SaveLevelClicked()
{
SaveFileDialog saveFileDialog = new SaveFileDialog();
SnakeSettings snakeSettingsLogic = ConvertSettingsGUIToLogic(snakeSettings);
Field[,] logicFields = new Field[snakeSettings.RowCount, snakeSettings.ColumnCount];
for (int i = 0; i < snakeSettings.RowCount; i++)
{
for (int j = 0; j < snakeSettings.ColumnCount; j++)
{
if (fields[i, j] is WallGUI)
{
logicFields[i, j] = new Wall(fields[i, j].Point);
}
else if (fields[i, j] is EmptyGUI)
{
logicFields[i, j] = new Empty(fields[i, j].Point);
}
}
}
Grid savedGrid = new Grid(logicFields);
Grid grid = new Grid(snakeSettings.RowCount, snakeSettings.ColumnCount);
SnakeLevel savedLevel = new SnakeLevel(savedGrid, snakeSettingsLogic);
saveFileDialog.RestoreDirectory = true;
saveFileDialog.InitialDirectory = Path.GetFullPath(Path.Combine(Application.StartupPath, @"..\..\SavedLevels\"));
saveFileDialog.Title = "Save Snake level";
saveFileDialog.ShowHelp = true;
if (saveFileDialog.ShowDialog() == DialogResult.OK)
{
try {
storageManager.SaveObject(savedLevel, saveFileDialog.FileName);
}
catch (IOException) {
MessageBox.Show("ERROR! Could not save. Is file in use by another process?");
}
}
}
public static void InitializeWithScene()
{
var settingsGO = GameObject.Find("Settings");
if (settingsGO == null)
{
SceneManager.sceneLoaded += OnSceneLoaded;
return;
}
Settings = settingsGO?.GetComponent <SnakeSettings>();
if (!Settings)
{
return;
}
PlayerLook = GetLookFromPrototype("Snake");
FoodLook = GetLookFromPrototype("Food");
FoodSpawnSystem.SetupComponentData(World.Active.GetOrCreateManager <EntityManager>());
World.Active.GetOrCreateManager <UpdatePlayerHUD>().SetupGameObjects();
}
/// <summary>
/// Represents a class which is able to play a recording of a playtest.
/// </summary>
/// <param name="recording"></param>
public PlaytestReplay(PlaytestRecording recording)
{
this.recording = recording;
networkSettings = recording.NetworkSettings;
snakeSettings = recording.SnakeSettings;
}
public ListedSnakeSettingsGUI(SnakeSettings snakeSettings, bool canEdit) : base(canEdit)
{
this.snakeSettings = snakeSettings;
CreateItems();
AddSettingItems();
}
public Snake(SnakeSettings settings)
{
this.settings = settings;
stepTime = settings.StepTime;
}
public SnakeMovementBehaviour(GameManager gameManager, ISnake snake, SnakeSettings snakeSettings)
{
Snake = snake;
this.snakeSettings = snakeSettings;
this.gameManager = gameManager;
}
/// <summary>
/// Runs a play test simulation of the saved agent and returns the result.
/// </summary>
/// <param name="savedAgent"></param>
/// <param name="testType"></param>
/// <param name="record"></param>
/// <returns></returns>
public PlaytestResult RunSimulation(SavedAgent savedAgent, TestType testType, bool record)
{
int action = 0;
int movesTotal = 0;
int currentScore = 0;
int movesSincePoint = 0;
int maxStepsBeforeTerminating = 1000;
double averageMovesPerFood = 0;
bool isInBounds = true;
PlaytestRecording recorder = null;
TestResult testResult = TestResult.Failed;
NetworkSettings networkSettings = (savedAgent.geneticSettings.FitnessCalculator as SnakeFitnessCalculator).NetworkSettings;
SnakeSettings snakeSettings = (savedAgent.geneticSettings.FitnessCalculator as SnakeFitnessCalculator).SnakeSettings;
// Setup new snake game and neural network
NeuralNetwork neuralNetwork = new NeuralNetwork(networkSettings, savedAgent.agent.Chromosome.ToArray());
double[] input = new double[networkSettings.numberOfInputNeurons];
SnakeGame snakeGame = new SnakeGame(snakeLevel);
// Make recorder
if (record)
{
recorder = new PlaytestRecording(savedAgent.agent, networkSettings, snakeSettings);
recorder.TakeSnapShotInitial(snakeGame);
}
if (record) // Save round info.
{
recorder.TakeSnapShotRound(snakeGame);
}
// Check within bounds.
if (testType == TestType.WithinBounds)
{
if (snakeGame.Grid.PointWithinGrid(snakeGame.Snake.Head.Point))
{
testResult = TestResult.Passed;
}
else
{
testResult = TestResult.Failed;
isInBounds = false;
}
}
if (isInBounds)
{
do
{
input = ConvertGridToInput(snakeGame.Grid, snakeGame.Snake, snakeGame.Food);
action = neuralNetwork.CalculateOutput(input);
snakeGame.UpdateDirection(action);
// Check if got point
if (snakeGame.Score != currentScore)
{
movesSincePoint = 0;
currentScore = snakeGame.Score;
}
else
{
movesSincePoint++;
}
movesTotal++;
if (record) // Save round info.
{
recorder.TakeSnapShotRound(snakeGame);
}
// Test within bounds.
if (testType == TestType.WithinBounds)
{
if (snakeGame.Grid.PointWithinGrid(snakeGame.Snake.Head.Point))
{
testResult = TestResult.Passed;
}
else
{
testResult = TestResult.Failed;
isInBounds = false;
}
}
} while(snakeGame.Snake.IsAlive && movesSincePoint < maxStepsBeforeTerminating && isInBounds);
}
// Check if snake completed game.
if (testType == TestType.CanComplete)
{
if (snakeGame.MaxScore != snakeGame.Score)
{
testResult = TestResult.Failed;
}
else
{
testResult = TestResult.Passed;
}
}
// Get avg. moves per food.
if (snakeGame.FoodEaten != 0)
{
averageMovesPerFood = movesTotal / (double)snakeGame.FoodEaten;
}
EndTestInfo endTestInfo = new EndTestInfo(snakeGame, movesTotal);
if (record)
{
recorder.TakeSnapShotEndTest(endTestInfo);
}
PlaytestResult playtestResult = new PlaytestResult(testResult, recorder);
return(playtestResult);
}
public void UpdateSnakeSettings(SnakeSettings snakeSettings)
{
SnakeSettings = snakeSettings;
}
/// <summary>
/// Initializes a new instance of the class <see cref="SnakeFitnessCalculator"/>
/// which is able to calculate the fitness value of an agent using the specified settings.
/// </summary>
/// <param name="networkSettings"></param>
/// <param name="snakeSettings"></param>
public SnakeFitnessCalculator(NetworkSettings networkSettings, SnakeSettings snakeSettings)
{
this.NetworkSettings = networkSettings;
this.SnakeSettings = snakeSettings;
}
public SnakeAISettings(GeneticSettings geneticSettings, NetworkSettings networkSettings, SnakeSettings snakeSettings)
{
GeneticSettings = geneticSettings;
NetworkSettings = networkSettings;
SnakeSettings = snakeSettings;
}
static void SnakeMode(IDrawningRectangle <SignConsole> location, Action startWithClose, SnakeSettings settings)
{
var menu = new KeyboardMenu <ButtonInConsole>("Snake Mode");
var modeMenu = new ConsolePrintMenu(location.Width, location.Height, location, menu);
location.Register((0, 0), modeMenu, modeMenu.GetCoordinates());
var printer = new BigPixelPrint(modeMenu.Width, 5, modeMenu, letters);
modeMenu.Register((0, 1), printer, printer.GetCoordinates());
modeMenu.SetWriter(printer);
void act()
{
modeMenu.Load();
MenuKeySet(menu, new bool[] { false, false, false });
}
act();
var buttons = SetMobe(menu, modeMenu, new string[] { "Start speed", "Acceleration", "Multiplayer", "Special berries", "Few special berries " });
buttons[0].Value = SignConsole.GetSignConsoles(settings.StartSpeed.ToString());
buttons[1].Value = SignConsole.GetSignConsoles(settings.Acceleration.ToString());
buttons[2].Value = SignConsole.GetSignConsoles(settings.Multy.ToString());
buttons[3].Value = SignConsole.GetSignConsoles(settings.Event.ToString());
buttons[4].Value = SignConsole.GetSignConsoles(settings.EventMulty.ToString());
buttons[0].IsPressed += () =>
{
settings.StartSpeed = (SnakeStartSpeed)EnumValues.Next(settings.StartSpeed);
buttons[0].Value = SignConsole.GetSignConsoles(settings.StartSpeed.ToString());
};
buttons[1].IsPressed += () =>
{
settings.Acceleration = (SnakeAcceleration)EnumValues.Next(settings.Acceleration);
buttons[1].Value = SignConsole.GetSignConsoles(settings.Acceleration.ToString());
};
buttons[2].IsPressed += () =>
{
settings.Multy = !settings.Multy;
buttons[2].Value = SignConsole.GetSignConsoles(settings.Multy.ToString());
};
buttons[3].IsPressed += () =>
{
settings.Event = !settings.Event;
buttons[3].Value = SignConsole.GetSignConsoles(settings.Event.ToString());
};
buttons[4].IsPressed += () =>
{
settings.EventMulty = !settings.EventMulty;
buttons[4].Value = SignConsole.GetSignConsoles(settings.EventMulty.ToString());
};
var exit = new ButtonInConsoleSetter(6, 1, modeMenu, SignConsole.GetSignConsoles("Exit"));
modeMenu.Register((5, 8 + buttons.Length * 2), exit, exit.GetCoordinates());
menu.AddLastButton(exit);
exit.IsPressed += () =>
{
modeMenu.Close();
location.CancelRegistration(modeMenu);
MenuKeyClose();
startWithClose?.Invoke();
};
modeMenu.Load();
}
public SnakeEater(SnakeSettings snakeSettings, Snake snake)
{
_snakeSettings = snakeSettings;
_snake = snake;
}
static void SnakeStart(IDrawningRectangle <SignConsole> location, SnakeSettings settings, Action startWithClose)
{
settings.Event = true;
settings.EventChance = 0.50;
Action stop = default;
var GameDictionary = new Dictionary <GamesSquareValues, SignConsole>
{
{ GamesSquareValues.snake, new SignConsole(' ', ConsoleColor.White) },
{ GamesSquareValues.snakeBerry, new SignConsole(' ', ConsoleColor.Red) },
{ GamesSquareValues.snakeWall, new SignConsole('X', ConsoleColor.Black) },
{ GamesSquareValues.nothing, new SignConsole(' ', ConsoleColor.Black) },
{ GamesSquareValues.snakeEventBerry, new SignConsole(' ', ConsoleColor.Green) }
};
var gameField = new ConsoleGameField(location.Width, location.Height, location, GameDictionary);
location.Register((0, 0), gameField, gameField.GetCoordinates());
var snakeMove = new SnakeMove((int)settings.StartSpeed);
var snakeField = new SnakeField(gameField.Width, gameField.Height - 5, gameField);
gameField.Register((0, 5), snakeField, snakeField.GetCoordinates());
snakeField.Inicializated();
var bigChar = new Letters("First");
BigPixelPrint scoreField, scoreField2 = null;
Score score, score2 = null;
KeyPress.SetControl("Snake");
Snake snake, snake2 = null;
if (!settings.Multy)
{
snake = new Snake(snakeField);
scoreField = new BigPixelPrint(18, 5, location, bigChar);
location.Register((location.Width / 2 - 9, 0), scoreField, scoreField.GetCoordinates());
score = new Score(scoreField);
}
else
{
snake = new Snake(snakeField, (snakeField.Width / 3, snakeField.Height / 2), Direction.direction.up);
scoreField = new BigPixelPrint(18, 5, location, bigChar);
location.Register((location.Width / 2 - 20, 0), scoreField, scoreField.GetCoordinates());
score = new Score(scoreField);
snake2 = new Snake(snakeField, (snakeField.Width / 3 * 2, snakeField.Height / 2), Direction.direction.down);
scoreField2 = new BigPixelPrint(18, 5, location, bigChar);
location.Register((location.Width / 2 + 2, 0), scoreField2, scoreField2.GetCoordinates());
score2 = new Score(scoreField2);
Berry.RandomBerry(snakeField);
}
Berry.RandomBerry(snakeField);
snake.IsEat += (Snake) => Berry.RandomBerry(Snake.Location);
snake.IsEat += (Snake) => snakeMove.Acceleration(((double)settings.Acceleration) / 100.0);
snake.IsEat += (Snake) => score.Add();
if (settings.Event)
{
snake.IsVeryEat += (Snake) => snakeMove.Acceleration(((double)settings.Acceleration) / 100.0);
snake.IsVeryEat += (Snake) => score.Add(5);
snake.IsEat += (Snake) => EventBerry.RandomEventBerry(settings.EventMulty, snakeField, settings.EventChance, snakeMove, 50);
}
snake.Die += (Snake) => stop?.Invoke();
snakeMove.Add(snake.Move);
stop += () => snakeMove.Stop();
stop += () => KeyPress.ResetControl();
Keys[needOption.snakeUp].Set((obj, ar) => snake.Up());
Keys[needOption.snakeDown].Set((obj, ar) => snake.Down());
Keys[needOption.snakeLeft].Set((obj, ar) => snake.Left());
Keys[needOption.snakeRigh].Set((obj, ar) => snake.Right());
if (settings.Multy)
{
snake2.IsEat += (Snake) => Berry.RandomBerry(Snake.Location);
snake2.IsEat += (Snake) => snakeMove.Acceleration((double)settings.Acceleration / 100);
snake2.IsEat += (Snake) => score2.Add();
if (settings.Event)
{
snake2.IsVeryEat += (Snake) => snakeMove.Acceleration(((double)settings.Acceleration) / 100.0);
snake2.IsVeryEat += (Snake) => score2.Add(5);
}
snake2.Die += (Snake) => stop?.Invoke();
snakeMove.Add(snake2.Move);
Keys[needOption.secondSnakeUp].Set((obj, ar) => snake2.Up());
Keys[needOption.secondSnakeDown].Set((obj, ar) => snake2.Down());
Keys[needOption.secondSnakeLeft].Set((obj, ar) => snake2.Left());
Keys[needOption.secondSnakeRigh].Set((obj, ar) => snake2.Right());
}
Keys[needOption.snakePause].Set((obj, ar) =>
{
snakeMove.Pause();
void cont()
{
gameField.Load();
score.Add(0);
snakeMove.Continue();
KeyPress.SetControl("Snake");
}
Pause(location, cont, exit);
});
snakeMove.Start();
Keys[needOption.snakeUp].Set(null);
Keys[needOption.snakeDown].Set(null);
Keys[needOption.snakeLeft].Set(null);
Keys[needOption.snakeRigh].Set(null);
if (settings.Multy)
{
Keys[needOption.secondSnakeUp].Set(null);
Keys[needOption.secondSnakeDown].Set(null);
Keys[needOption.secondSnakeLeft].Set(null);
Keys[needOption.secondSnakeRigh].Set(null);
}
Console.ReadKey(true);
void exit()
{
snakeMove.Stop();
gameField.Close();
scoreField.Close();
scoreField2?.Close();
location.CancelRegistration(gameField);
startWithClose();
EventBerry.Clear(snakeField);
}
exit();
}
