/// <summary>
/// Creates a new PopulationData class that can be used to report data and
/// update a status LED.
/// </summary>
/// <param name="reportDirectory">A directory to write out reports to.</param>
/// <param name="reportData">Should data be reported to the server.</param>
/// <param name="led">An LED used to indicate status.</param>
public PopulationData(string reportDirectory, Boolean reportData, TerrariumLed led)
{
this.reportDirectory = reportDirectory;
this.reportDataToServer = reportData;
this.led = led;
ResetData();
}
internal TeleportWorkItem(NetworkEngine engine, string address, object state, int httpPort, int networkTimeoutMsec, TerrariumLed led)
{
this.engine = engine;
this.address = address;
this.state = state;
this.httpPort = httpPort;
this.peerConnectionLed = led;
this.networkTimeoutMsec = networkTimeoutMsec;
}
internal TeleportWorkItem(NetworkEngine engine, string address, object state, int httpPort,
int networkTimeoutMsec, TerrariumLed led)
{
_engine = engine;
_address = address;
_state = state;
_httpPort = httpPort;
_peerConnectionLed = led;
_networkTimeoutMsec = networkTimeoutMsec;
}
/// <summary>
/// Creates a new game engine that can be used for a Terrarium game. Terrarium
/// games aren't networked and can load any creatures.
/// </summary>
/// <param name="dataPath">The path where the Terrarium game will be stored.</param>
/// <param name="fileName">The path to the serialized Terrarium.</param>
/// <param name="leds">A series of leds to be used for state reporting.</param>
public static void NewTerrariumGame(string dataPath, string fileName, TerrariumLed[] leds)
{
if (_engine != null)
{
_engine.StopGame(false);
}
_engine = new GameEngine(dataPath, false, false, fileName, false, leds, true);
}
/// <summary>
/// Creates a new game engine that can be used to play an EcoSystem game.
/// </summary>
/// <param name="dataPath">The path where the Terrarium game will be stored.</param>
/// <param name="fileName">The path to the serialized Terrarium.</param>
/// <param name="leds">A series of leds to be used for state reporting.</param>
public static void NewEcosystemGame(string dataPath, string fileName, TerrariumLed[] leds)
{
if (_engine != null)
{
_engine.StopGame(false);
}
_engine = new GameEngine(dataPath, true, false, dataPath + fileName, true, leds, true);
// Start the network after Current is set on GameEngine because the network
// needs a current gameengine to receive teleportations
if (_engine._usingNetwork)
{
_engine._networkEngine.InitializeNetwork("EcoSystem", leds);
}
_engine._ecosystemMode = true;
}
/// <summary>
/// Constructs a new game engine.
/// </summary>
/// <param name="dataPath">The path to save game directory.</param>
/// <param name="useNetwork">Controls the usage of the network engine.</param>
/// <param name="deserializeState">Controls if the state is deserialized or not.</param>
/// <param name="fileName">The path to the state file.</param>
/// <param name="reportData">Determines if data should be reported.</param>
/// <param name="leds">Provides a listing of game leds that can be used.</param>
/// <param name="trackLastRun">Controls whether the PAC keeps track of the last run creature for blacklisting.</param>
private GameEngine(string dataPath, bool useNetwork, bool deserializeState, string fileName, bool reportData,
TerrariumLed[] leds, bool trackLastRun)
{
_ledIndicators = leds;
_currentStateFileName = fileName;
// test to make sure we're not violating any constraints by current
// physics settings in the engine.
EngineSettings.EngineSettingsAsserts();
// Calculate quanta and worldsize if we haven't done so yet
if (_reloadSettings)
CalculateWorldSize();
_pac = new PrivateAssemblyCache(dataPath, fileName, true, trackLastRun);
// Reset the appdomain policy since we changed the location of the organism dlls
// This must be done before any animals are loaded in any way. Make sure this call stays
// as soon as possible
AppDomain.CurrentDomain.SetAppDomainPolicy(SecurityUtils.MakePolicyLevel(_pac.AssemblyDirectory));
_usingNetwork = useNetwork;
_populationData = new PopulationData(reportData, leds[(int) LedIndicators.ReportWebService]);
// Should only happen if an exception prevented a previous attempt to start a game
if (AppMgr.CurrentScheduler != null)
{
AppMgr.DestroyScheduler();
}
// Create a scheduler that manages giving the creatures timeslices
_scheduler = AppMgr.CreateSameDomainScheduler(this);
_scheduler.Quantum = _organismQuanta;
if (useNetwork)
{
// Required to start up the network listeners
_networkEngine = new NetworkEngine();
}
WorldState currentState;
Boolean successfulDeserialization = false;
if (deserializeState && File.Exists(fileName))
{
try
{
if (_pac.LastRun.Length != 0)
{
// The process was killed while an organism was being run, blacklist it
// Since this potentially means the animal hung the game.
_pac.BlacklistAssemblies(new string[] {_pac.LastRun});
}
this.deserializeState(fileName);
currentState = CurrentVector.State;
_scheduler.CurrentState = currentState;
_scheduler.CompleteOrganismDeserialization();
successfulDeserialization = true;
}
catch (Exception e)
{
ErrorLog.LogHandledException(e);
}
}
if (successfulDeserialization) return;
// Set up initial world state
currentState = new WorldState(GridWidth, GridHeight);
currentState.TickNumber = 0;
currentState.StateGuid = Guid.NewGuid();
currentState.Teleporter = new Teleporter(AnimalCount/EngineSettings.NumberOfAnimalsPerTeleporter);
currentState.MakeImmutable();
WorldVector vector = new WorldVector(currentState);
CurrentVector = vector;
_scheduler.CurrentState = currentState;
}
internal void ShutdownNetwork()
{
if (announceThread != null)
{
announceThread.Abort();
}
// Stop Listening
StopHttpNamespaceManager();
_discoveryLed = null;
_peerConnectionLed = null;
}
internal void InitializeNetwork(string peerChannel, TerrariumLed[] leds)
{
// Set up the LEDs
_discoveryLed = leds[(int) LedIndicators.DiscoveryWebService];
_peerConnectionLed = leds[(int) LedIndicators.PeerConnection];
_receivedPeerConnectionLed = leds[(int) LedIndicators.PeerReceivedConnection];
// Start listening on HTTP
_peerChannel = peerChannel;
//GlobalProxySelection.Select = GlobalProxySelection.GetEmptyWebProxy();
WebRequest.DefaultWebProxy = null;
SetHostIPInformation();
StartHttpNamespaceManager();
// Start our announcement thread
announceThread = new Thread(AnnounceAndRegisterPeer) {Name = "Peer Discovery Thread"};
announceThread.Start();
}
private DataTable _totalsTable; // One row per tick, One row per species, current population, min and max
#endregion Fields
#region Constructors
/// <summary>
/// Creates a new PopulationData class that can be used to report data and
/// update a status LED.
/// </summary>
/// <param name="reportData">Should data be reported to the server.</param>
/// <param name="led">An LED used to indicate status.</param>
public PopulationData(bool reportData, TerrariumLed led)
{
_reportDataToServer = reportData;
_led = led;
ResetData();
}
