source: branches/SimulationCore/HeuristicLab.SimulationCore.Samples/3.3/GameOfLifeDiscreteEventSimulation.cs @ 11100

using System;
using System.Collections.Generic;
using HeuristicLab.Analysis;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Optimization;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Random;

namespace HeuristicLab.SimulationCore.Samples {

  #region Model
  [StorableClass]
  public sealed class GameOfLifeModel : IModel {
    [Storable]
    public double CurrentTime { get; set; }
    [Storable]
    public bool[,] Grid { get; set; }

    private GameOfLifeModel(GameOfLifeModel original, Cloner cloner) {
      cloner.RegisterClonedObject(original, this);
      CurrentTime = original.CurrentTime;
      Grid = (bool[,])original.Grid.Clone();
    }
    public GameOfLifeModel(int width, int height) {
      Grid = new bool[height, width];
    }

    public object Clone() { return Clone(new Cloner()); }
    public IDeepCloneable Clone(Cloner cloner) {
      return new GameOfLifeModel(this, cloner);
    }
  }
  #endregion

  #region Simulation
  [Item("Game of Life (discrete event)", "A discrete event based implementation of the game of life simulation.")]
  [Creatable("Simulations")]
  public class GameOfLifeDiscreteEventSimulation : DiscreteEventSimulation<GameOfLifeModel> {
    public override Type ProblemType { get { return typeof(GameOfLifeScenario); } }

    private GameOfLifeScenario Scenario {
      get { return (GameOfLifeScenario)base.Problem; }
      set { base.Problem = value; }
    }

    private GameOfLifeDiscreteEventSimulation(GameOfLifeDiscreteEventSimulation original, Cloner cloner)
      : base(original, cloner) {
      RegisterScenarioEventHandlers();
    }
    public GameOfLifeDiscreteEventSimulation() {
      PrepareSimulation();
      Scenario = new GameOfLifeScenario();
      Parameterize();
      RegisterScenarioEventHandlers();
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new GameOfLifeDiscreteEventSimulation(this, cloner);
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      RegisterScenarioEventHandlers();
    }

    private void PrepareSimulation() {
      InitialAction = new InitializeGameOfLifeBoardAction();
      Activities = new IActivity<GameOfLifeModel>[] { new BoardActivity() };
      Reporters = new IReporter<GameOfLifeModel>[] { new GameOfLifeStateReporter() };
    }

    private void RegisterScenarioEventHandlers() {
      Scenario.WidthParameter.Value.ValueChanged += ParametersChanged;
      Scenario.HeightParameter.Value.ValueChanged += ParametersChanged;
      Scenario.AliveRateParameter.Value.ValueChanged += ParametersChanged;
    }

    protected override void OnProblemChanged() {
      base.OnProblemChanged();
      Parameterize();
      RegisterScenarioEventHandlers();
    }

    protected override void OnPrepared() {
      base.OnPrepared();
      PrepareSimulation();
    }

    private void ParametersChanged(object sender, EventArgs e) {
      Parameterize();
    }

    private void Parameterize() {
      Model = new GameOfLifeModel(Scenario.WidthParameter.Value.Value, Scenario.HeightParameter.Value.Value);
      ((InitializeGameOfLifeBoardAction)InitialAction).AliveRate = Scenario.AliveRateParameter.Value.Value;
    }
  }
  #endregion

  #region Activities
  [StorableClass]
  sealed class BoardActivity : Activity<GameOfLifeModel> {
    public override IEnumerable<Type> MonitoredActions {
      get { return new[] { typeof(InitializeGameOfLifeBoardAction), typeof(UpdateGameOfLifeBoardAction) }; }
    }

    [StorableConstructor]
    private BoardActivity(bool deserializing) : base(deserializing) { }
    private BoardActivity(BoardActivity original, Cloner cloner) : base(original, cloner) { }
    public BoardActivity() : base(new SortedListEventQueue<GameOfLifeModel>()) { }

    public override void ManageEvents(GameOfLifeModel model, IAction<GameOfLifeModel> lastAction) {
      EventQueue.Push(model.CurrentTime + 1, new UpdateGameOfLifeBoardAction());
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new BoardActivity(this, cloner);
    }
  }
  #endregion

  #region Reporters
  [StorableClass]
  sealed class GameOfLifeStateReporter : Reporter<GameOfLifeModel> {

    [StorableConstructor]
    private GameOfLifeStateReporter(bool deserializing) : base(deserializing) { }
    private GameOfLifeStateReporter(GameOfLifeStateReporter original, Cloner cloner) : base(original, cloner) { }
    public GameOfLifeStateReporter() { }

    public override void UpdateReporting(GameOfLifeModel model, ResultCollection results) {
      var heatmap = new HeatMap(model.Grid.GetLength(0), model.Grid.GetLength(1));
      for (var i = 0; i < heatmap.Rows; i++)
        for (var j = 0; j < heatmap.Columns; j++)
          heatmap[i, j] = model.Grid[i, j] ? 1 : 0;

      if (!results.ContainsKey("Visualization"))
        results.Add(new Result("Visualization", heatmap));
      else results["Visualization"].Value = heatmap;
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new GameOfLifeStateReporter(this, cloner);
    }
  }
  #endregion

  #region Actions
  [StorableClass]
  sealed class InitializeGameOfLifeBoardAction : Action<GameOfLifeModel> {
    [Storable]
    public double AliveRate { get; set; }

    private InitializeGameOfLifeBoardAction(InitializeGameOfLifeBoardAction original, Cloner cloner)
      : base(original, cloner) {
      AliveRate = original.AliveRate;
    }
    public InitializeGameOfLifeBoardAction() {
      AliveRate = 0.2;
    }

    public override void Execute(GameOfLifeModel model) {
      var random = new FastRandom();
      var rows = model.Grid.GetLength(0);
      var cols = model.Grid.GetLength(1);
      for (var i = 0; i < rows; i++)
        for (var j = 0; j < cols; j++) {
          if (random.NextDouble() < AliveRate) model.Grid[i, j] = true;
        }
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new InitializeGameOfLifeBoardAction(this, cloner);
    }
  }

  [StorableClass]
  sealed class UpdateGameOfLifeBoardAction : Action<GameOfLifeModel> {
    private UpdateGameOfLifeBoardAction(UpdateGameOfLifeBoardAction original, Cloner cloner) : base(original, cloner) { }
    public UpdateGameOfLifeBoardAction() { }

    public override void Execute(GameOfLifeModel model) {
      var rows = model.Grid.GetLength(0);
      var cols = model.Grid.GetLength(1);
      var newGrid = new bool[rows, cols];
      for (var i = 0; i < rows; i++)
        for (var j = 0; j < cols; j++) {
          var neighbors = 0;
          if (i > 0 && j > 0 && model.Grid[i - 1, j - 1]) neighbors++;
          if (i > 0 && model.Grid[i - 1, j]) neighbors++;
          if (i > 0 && j < cols - 1 && model.Grid[i - 1, j + 1]) neighbors++;
          if (j > 0 && model.Grid[i, j - 1]) neighbors++;
          if (j < cols - 1 && model.Grid[i, j + 1]) neighbors++;
          if (i < rows - 1 && j > 0 && model.Grid[i + 1, j - 1]) neighbors++;
          if (i < rows - 1 && model.Grid[i + 1, j]) neighbors++;
          if (i < rows - 1 && j < cols - 1 && model.Grid[i + 1, j + 1]) neighbors++;
          if ((model.Grid[i, j] && neighbors == 2) || neighbors == 3) newGrid[i, j] = true;
        }
      model.Grid = newGrid;
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new UpdateGameOfLifeBoardAction(this, cloner);
    }
  }
  #endregion
}