public void engEngine_EvalFitnessForProgramEvent(BaseProgram progProgram,
BaseEngine sender)
{
if (progBestProgramInPreviousGeneration == null)
{
progBestProgramInPreviousGeneration = sender.Population[0][0];
}
float dAbsoluteFitness = 0;
// Attempt to gather from 10 different tests.
float dWorstCaseScenario = 99999999;
for (int nTestNum = 0; nTestNum < 5; nTestNum++)
{
float dFitness = RunnerEvolution.ProgramRunner(m_cWorld, progProgram,
null, false);
if (dFitness < dWorstCaseScenario)
{
dWorstCaseScenario = dFitness;
}
/* dAbsoluteFitness += RunnerEvolution.ProgramRunner(m_cWorld, progProgram,
* null, false);*/
}
progProgram.Fitness = 1000000 - dWorstCaseScenario;
}
private void createServer()
{
if (serverThread == null)
{
CreateServerThreadArguments args = new CreateServerThreadArguments();
CanCreate = false;
BaseEngine server = null;
WcfEngineHost binaryHelper = new WcfEngineHost();
waitHandle = new ManualResetEvent(false);
switch (SelectedGame)
{
case ServerGame.FiveCardDraw: server = new FiveGameDrawServer(binaryHelper); break;
case ServerGame.TexasHoldem: server = new TexasHoldemServer(binaryHelper); break;
case ServerGame.SevenCardStud: server = new SevenCardStudServer(binaryHelper); break;
case ServerGame.OmahaHoldem: server = new OmahaHoldemServer(binaryHelper); break;
}
binaryHelper.Initialize(server, SelectedGame, Port, waitHandle);
if (multiplayer.IsChecked.Value)
{
server.GameStarted += new DataEventHandler <IEnumerable <Player> >(server_GameStarted);
}
playerLimit = server.MaximalPlayersLimit;
args.game = server;
NewServerConfiguration config = ConfigurationAccess.Current.NewServerConfiguration;
config.TournamentMode = server.TournamentMode = TournamentMode;
config.AcceptsNewPlayers = server.AcceptPlayersAfterGameStart = AcceptsNewPlayers;
config.Ante = server.Ante = Ante;
config.SmallRaise = server.SmallRaise = SmallRaise;
config.RaiseLimit = server.RaiseLimit = RaiseLimit;
config.StartingMoney = server.StartingMoney = StartingMoney;
config.PlayerTimeLimit = server.ActionTimeout = TimeLimit;
config.AutoRaiseOnHand = server.AutoIncreaseOnHandDivider = AutoRaiseOnHand;
config.SelectedGame = args.gameMode = SelectedGame;
config.BotCount = args.botCount = BotCount;
config.Port = args.port = Port;
ServerAddress = "localhost";
ServerPort = Port;
waitHandle.Reset();
serverThread = new Thread(new ParameterizedThreadStart(StartServer));
serverThread.Start(args);
serverThread.Name = "Game Server Thread";
serverThread.IsBackground = true;
if (multiplayer.IsChecked.Value)
{
binaryHelper.PlayerConnected += new DataEventHandler <Player>(client_NewUserConnected);
}
}
}
void server_GameStarted(object sender, DataEventArgs <IEnumerable <Player> > e)
{
BaseEngine server = (BaseEngine)sender;
server.GameStarted -= new DataEventHandler <IEnumerable <Player> >(server_GameStarted);
waitHandle.Reset();
// the wait handle was passed to the gui helper, don't set it anymore
waitHandle = null;
}
void engEngine_EvalFitnessForProgramEvent(BaseProgram progProgram,
BaseEngine sender)
{
progProgram.Fitness = 0;
Hashtable hsVariables = progProgram.GetVariables();
Variable varX = (Variable)hsVariables["X"];
Variable varY = (Variable)hsVariables["Y"];
for (int nY = 0;
nY < fstBitmap.Height;
nY += nSkippedPixelsInImage)
{
for (int nX = 0;
nX < fstBitmap.Width;
nX += nSkippedPixelsInImage)
{
varX.Value = (float)nX / fstBitmap.Width;
varY.Value = (float)nY / fstBitmap.Height;
Color clrPixel = fstBitmap.GetPixel(nX, nY);
byte nGrayScaleColor = (byte)((clrPixel.R + clrPixel.G + clrPixel.B) / 3);
float fExpectedResult = (float)((nGrayScaleColor / 128.0) - 1);
progProgram.Run();
float fActualResult = progProgram.Result;
float fDifference = Math.Abs(fExpectedResult - fActualResult);
progProgram.Fitness += fDifference;
byte nActualGrayScaleColor = (byte)((fActualResult + 1) * 128.0);
}
}
// @debug 6.2.2013 : in each generation, we select different pixels.
/*for (int nY = 0;
* nY < fstBitmap.Height;
* nY ++)
* {
* for (int nX = (sender.GenerationNum % nSkippedPixelsInImage);
* nX < fstBitmap.Width;
* nX += nSkippedPixelsInImage)
* {
* varX.Value = (float)nX / fstBitmap.Width;
* varY.Value = (float)nY / fstBitmap.Height;
* Color clrPixel = fstBitmap.GetPixel(nX, nY);
* byte nGrayScaleColor = (byte)((clrPixel.R + clrPixel.G + clrPixel.B) / 3);
* float fExpectedResult = (float)((nGrayScaleColor / 128.0) - 1);
* progProgram.Run();
* float fActualResult = progProgram.Result;
* float fDifference = Math.Abs(fExpectedResult - fActualResult);
* progProgram.Fitness += fDifference;
* byte nActualGrayScaleColor = (byte)((fActualResult + 1) * 128.0);
* }
* }*/
}
void engEngine_GenerationIsCompleteEvent(Statistics stsStatistics, BaseEngine sender)
{
this.strLabelString = "Generation number " + stsStatistics.GenerationNumber
+ " : min fitness = " + stsStatistics.MinFitnessProgram.Fitness
+ ", Total nodes = " + stsStatistics.TotalNodes;
try
{
Graphics g = this.CreateGraphics();
((TreeProgram)stsStatistics.MinFitnessProgram).Draw(g, this.Width, this.Height, this);
}
catch (System.Exception ex)
{
}
}
public static void Start()
{
var assetManager = AssetManager.GetAssetManager(EngineId.Ultima);
Asset = assetManager.GetAssetPack(null).Result;
Data = assetManager.GetDataPack(null).Result;
Engine = new UltimaEngine(assetManager, Asset, Data, null);
var scale = ConvertUtils.ExteriorCellSideLengthInMeters;
//Engine.SpawnPlayerAndUpdate(PlayerPrefab, new Vector3(4 * scale, 20, 25 * scale));
//Engine.SpawnPlayerAndUpdate(PlayerPrefab, new Vector3(15 * scale, 20, 25 * scale));
Engine.SpawnPlayerAndUpdate(PlayerPrefab, new Vector3(11 * scale, 10, 29 * scale));
}
public VehicleStats(GunDetailed gun, BaseTurretWithTraverse turret, BaseEngine engine, BaseSuspension tracks, BaseVehicle vehicle, CamoInfo camo)
{
Camo = camo;
var profile = vehicle.default_profile;
int weight = profile.hull_weight + gun.weight + turret.weight + engine.weight + tracks.weight;
Weight = weight / 1000.0;
HorsePower = engine.power;
HorsePowerToTonRatio = HorsePower / Weight;
TraverseSpeed = tracks.traverse_speed * ((double)engine.power / profile.engine.power) * (profile.weight / (double)weight);
SpeedForward = profile.speed_forward;
SpeedBackward = profile.speed_backward;
//var gunShells = API.GUNS[profile.gun_id]
//Shells = gunShells.ToDictionary(s => s.type, s => new ShellInfo(s));
//DefaultShell = gunShells[0];
Info = new VehicleInfo(vehicle);
SignalRange = profile.signal_range;
TurretArmor = new ArmorStats();
HullArmor = new ArmorStats(profile.armor.hull);
FireChance = engine.fire_chance;
LoadLimit = tracks.load_limit;
AmmoCapacity = profile.max_ammo;
Hitpoints = profile.hull_hp + turret.hp;
Dispersion = gun.dispersion;
AimTime = gun.aim_time;
ClipCapacity = gun.clip_capacity;
GunElevation = gun.move_up_arc;
GunDepression = gun.move_down_arc;
ReloadTime = gun.reload_time;
GunTraverseSpeed = gun.traverse_speed;
ClipReloadTime = gun.clip_reload_time;
FireRate = gun.fire_rate;
DamagePerMinute = FireRate * DefaultShell.damage;
AdvDamagePerMinute = (FireRate + 1) * DefaultShell.damage;
ViewRange = turret.view_range;
GunArcLeft = turret.traverse_left_arc;
GunArcRight = turret.traverse_right_arc;
TurretTraverseSpeed = turret.traverse_speed;
ModulesInfo = new Dictionary <ModuleType, BaseModule>(4);
ModulesInfo.Add(ModuleType.vehicleEngine, engine);
ModulesInfo.Add(ModuleType.vehicleGun, gun);
ModulesInfo.Add(ModuleType.vehicleTurret, turret);
ModulesInfo.Add(ModuleType.vehicleChassis, tracks);
ModulesInfo.Add(ModuleType.vehicleHull, new BaseModule(vehicle.name, profile.hull_weight, vehicle.tier));
}
public void engEngine_GenerationIsCompleteEvent(Statistics stsStatistics,
BaseEngine sender)
{
strLabelString = "Generation num = " + stsStatistics.GenerationNumber + ", Min fitness = " +
stsStatistics.MinFitnessProgram.Fitness + ", Min fitness nodes = " + stsStatistics.MinFitnessProgram.Size;
((TreeProgram)stsStatistics.MinFitnessProgram).Draw(pnlDrawProgram.CreateGraphics(), pnlDrawProgram.Width, pnlDrawProgram.Height, this);
if (((stsStatistics.GenerationNumber % 10) == 0) && (stsStatistics.GenerationNumber != 0))
{
for (int i = 0; i < 5; i++)
{
RunnerEvolution.ProgramRunner(m_cWorld, stsStatistics.MinFitnessProgram,
pnlWorldView.CreateGraphics(), true);
}
}
// Show statistics about the islands. Make a graph about the islands fitnesses.
progBestProgramInPreviousGeneration = stsStatistics.MinFitnessProgram;
float dMinimalFitnessInPopulation = stsStatistics.MinFitnessProgram.Fitness;
float dMaxMinFitnessInIslands = 0;
for (int i = 0; i < sender.NumberOfIslands; i++)
{
BaseProgram cMinFitnessProgramForIsland = stsStatistics.GetMinFitnessProgramForIsland(i);
if (cMinFitnessProgramForIsland.Fitness > dMaxMinFitnessInIslands)
{
dMaxMinFitnessInIslands = cMinFitnessProgramForIsland.Fitness;
}
}
int ISLAND_BAR_WIDTH = (int)(pnlViewIslands.Width / sender.NumberOfIslands);
Graphics g = pnlViewIslands.CreateGraphics();
g.Clear(Color.Black);
for (int i = 0; i < sender.NumberOfIslands; i++)
{
float dIslandFitness = stsStatistics.GetMinFitnessProgramForIsland(i).Fitness;
float dPrecentageOfMinFitness = (dIslandFitness - dMinimalFitnessInPopulation) / (dMaxMinFitnessInIslands - dMinimalFitnessInPopulation);
g.FillRectangle(Brushes.RoyalBlue, i * ISLAND_BAR_WIDTH, pnlViewIslands.Height - (pnlViewIslands.Height * dPrecentageOfMinFitness), ISLAND_BAR_WIDTH, pnlViewIslands.Height);
}
// Write the max and min fitnesses value on the graph.
g.DrawString(dMaxMinFitnessInIslands.ToString(), new Font("Times New Roman", 12.0f), Brushes.Red, 0, 0);
g.DrawString(dMinimalFitnessInPopulation.ToString(), new Font("Times New Roman", 12.0f), Brushes.Red, 0, pnlViewIslands.Height - 20);
}
public void engEngine_EvalFitnessForProgramEvent(BaseProgram progProgram,
BaseEngine sender)
{
if (progBestProgramInPreviousGeneration == null)
{
progBestProgramInPreviousGeneration = sender.Population[0][0];
}
float dAbsoluteFitness = 0;
// Attempt to gather from 20 different tests.
for (int nTestNum = 0; nTestNum < 5; nTestNum++)
{
dAbsoluteFitness += CAEvolution.ProgramRunner(progProgram,
progBestProgramInPreviousGeneration, null, false);
}
progProgram.Fitness = 100000 - dAbsoluteFitness;
}
public static void Start()
{
var assetUri = "game://Morrowind/Morrowind.bsa";
var dataUri = "game://Morrowind/Morrowind.esm";
//var assetUri = "game://Oblivion/Oblivion*";
//var dataUri = "game://Oblivion/Oblivion.esm";
var assetManager = AssetManager.GetAssetManager(EngineId.Tes);
Asset = assetManager.GetAssetPack(assetUri).Result;
Data = assetManager.GetDataPack(dataUri).Result;
Engine = new BaseEngine(assetManager, Asset, Data);
// engine
Engine.SpawnPlayer(PlayerPrefab, new Vector3(-137.94f, 2.30f, -1037.6f)); // new Vector3Int(-2, -9)
// engine - oblivion
//Engine.SpawnPlayer(PlayerPrefab, new Vector3Int(0, 0, 60), new Vector3(0, 0, 0));
}
private async void InitAsync()
{
TheCDEngines.MyContentEngine?.RegisterEvent(eEngineEvents.PreShutdown, OnPreShutdown);
await TheBaseEngine.WaitForEnginesStartedAsync();
await TheBaseEngine.WaitForStorageReadinessAsync(true);
TheBaseAssets.MyCmdArgs.TryGetValue("SafSearchPath", out var searchPath);
if (TheBaseAssets.MyCmdArgs.TryGetValue("SafUserBasePath", out var userBasePath) && !Path.IsPathRooted(userBasePath))
{
userBasePath = Path.Combine(TheBaseAssets.MyServiceHostInfo.BaseDirectory, "ClientBin", userBasePath);
}
_serviceHost = new ServiceHost(InstallInfrastructureServices, searchPath, userBasePath);
_isInitialized = true;
TheThing.StatusLevel = 1;
TheThing.LastMessage = "Plug-in initialized";
FireEvent(eThingEvents.Initialized, TheThing, true, false);
BaseEngine.ProcessInitialized();
}
public void engEngine_GenerationIsCompleteEvent(Statistics stsStatistics,
BaseEngine sender)
{
strLabelString = "Generation num = " + stsStatistics.GenerationNumber + ", Min fitness = " +
stsStatistics.MinFitnessProgram.Fitness + ", Min fitness nodes = " + stsStatistics.MinFitnessProgram.Size;
((TreeProgram)stsStatistics.MinFitnessProgram).Draw(pnlDrawProgram.CreateGraphics(), pnlDrawProgram.Width, pnlDrawProgram.Height, this);
if ((stsStatistics.GenerationNumber % 20) == 0)
{
CAEvolution.ProgramRunner(stsStatistics.MinFitnessProgram,
progBestProgramInPreviousGeneration, pnlMatrixDisplay.CreateGraphics(), true);
CAEvolution.ProgramRunner(stsStatistics.MinFitnessProgram,
progBestProgramInPreviousGeneration, pnlMatrixDisplay.CreateGraphics(), true);
CAEvolution.ProgramRunner(stsStatistics.MinFitnessProgram,
progBestProgramInPreviousGeneration, pnlMatrixDisplay.CreateGraphics(), true);
}
progBestProgramInPreviousGeneration = stsStatistics.MinFitnessProgram;
}
public async Task <List <Tuple <string, string> > > GetPositionNumber(List <string> in_lstEngineSelected,
string in_strKeyWords,
string in_strDomainUR,
int in_iWithin
)
{
List <Tuple <string, string> > res = new List <Tuple <string, string> >();
EngineFactory factory = new EngineFactory();
foreach (var item in in_lstEngineSelected)
{
BaseEngine engine = factory.GetEngine(item.ToLower());
engine.SetDomainURL(in_strDomainUR);
engine.SetKeyWords(in_strKeyWords);
engine.SetWithinNumber(in_iWithin);
res.Add(new Tuple <string, string>(item, await engine.GetPositionNumber()));
}
return(res);
}
private void StartServer(object threadArguments)
{
try
{
CreateServerThreadArguments args = (CreateServerThreadArguments)threadArguments;
BaseEngine server = args.game;
server.Initialize();
Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(serverInitialized));
if (args.botCount > 0)
{
spawBots(args.botCount, args.gameMode, args.port);
}
Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(serverIsUp));
server.Run();
}
catch
{
}
finally
{
serverThread = null;
}
}
public BaseGameImpl(string name, BaseEngine <TGame, TPlayer, TRoom, TContainer, TThing> engine)
{
this.Name = name;
this.Engine = engine;
this.Engine.Game = this;
}
/// <summary>
/// Initializes the helper with the required parameters
/// </summary>
/// <param name="engine">The engine which runs the game</param>
/// <param name="game">The running game</param>
public void Initialize(BaseEngine engine, ServerGame game)
{
this.owner = engine;
this.game = game;
}
BaseEngine m_engEngine; // The engine
#endregion
#region Constructor
/// <summary>
/// Consturct a new statistics from an Engine class
/// </summary>
/// <param name="engEngine">The engine</param>
public Statistics(BaseEngine engEngine)
{
this.m_engEngine = engEngine;
}
public MTCPClientEngine(BaseEngine engine) : base(engine)
{
}
void engEngine_GenerationIsCompleteEvent(Statistics stsStatistics,
BaseEngine sender)
{
this.strLabelString = "Generation number " + stsStatistics.GenerationNumber
+ " : min fitness = " + stsStatistics.MinFitnessProgram.Fitness
+ " skipped pixels : " + nSkippedPixelsInImage
+ ", Total nodes = " + stsStatistics.TotalNodes;
BaseProgram progMinFitness = stsStatistics.MinFitnessProgram;
// If the generation is between 10-20, 40-50, 60-70 and so forth,
// Make 10 generations of "tree minimizing which should minimize its fitness
// According to tree size.
/*
* if (((stsStatistics.GenerationNumber / 50) % 2) == 1)
* {
* float fMinFitness = progMinFitness.Fitness;
* foreach (BaseProgram[] islIsland in sender.Population)
* {
* foreach (BaseProgram progProgram in islIsland)
* {
* TreeProgram treProgram = (TreeProgram)progProgram;
* if (treProgram.Fitness <= fMinFitness)
* {
* treProgram.Fitness = fMinFitness * (1 - ((float)1 / treProgram.Depth));
* }
* }
* }
* }*/
FastBitmap fstOutputBitmap = null;
if ((stsStatistics.GenerationNumber % 1) == 0)
{
fstOutputBitmap =
new FastBitmap(fstBitmap.Width * 6, fstBitmap.Height * 6);
Hashtable hsVariables = progMinFitness.GetVariables();
Variable varX = (Variable)hsVariables["X"];
Variable varY = (Variable)hsVariables["Y"];
for (int nY = 0;
nY < fstOutputBitmap.Height;
nY++)
{
for (int nX = 0;
nX < fstOutputBitmap.Width;
nX++)
{
varX.Value = (float)nX / fstOutputBitmap.Width;
varY.Value = (float)nY / fstOutputBitmap.Height;
progMinFitness.Run();
float fActualResult = progMinFitness.Result;
byte nActualGrayScaleColor = (byte)((fActualResult + 1.0F) * 127.0F);
fstOutputBitmap.SetPixel(nX, nY,
nActualGrayScaleColor, nActualGrayScaleColor, nActualGrayScaleColor);
}
}
fstOutputBitmap.Draw(this.CreateGraphics(), 0, 0,
this.Width, this.Height);
}
/*else
* {
* fstOutputBitmap =
* new FastBitmap(fstBitmap.Width * 6, fstBitmap.Height * 6);
* }*/
// try
// {
// Graphics g = this.CreateGraphics();
// stsStatistics.MinFitnessProgram.Draw(g, this.Width, this.Height, this);
// }
// catch (System.Exception ex)
// {
// }
}
/// <summary>
/// Initializes the host with all of the required information. This method must be called prior to the call to
/// <see cref="BaseEngine.Run"/> method
/// </summary>
/// <param name="owner">The owning engine which configures the environment</param>
/// <param name="game">The running game</param>
/// <param name="port">The port in which the server will listen</param>
/// <param name="waitHandle">The wait handle which is used to communicate with the engine helper</param>
public void Initialize(BaseEngine owner, ServerGame game, int port, WaitHandle waitHandle)
{
concreteHelper.Initialize(owner, game);
this.port = port;
this.waitHandle = waitHandle;
}
public MTCPServerEngine(BaseEngine engine) : base(engine)
{
}
/// <summary>
/// The console application entry class
/// </summary>
/// <param name="args">
/// The command line arguments.
/// </param>
static void Main(string[] args)
{
try
{
// print the command line usage if the arguments do not match
if (args.Length < 2)
{
Console.WriteLine("Usage: <server address | Game Mode> <port>");
Console.WriteLine("server address: ip or dns");
Console.WriteLine("Game Mode: texas,five,seven,omaha");
Console.WriteLine("port: the port in which the server runs");
}
else
{
int port = -1;
string serverIp = string.Empty;
ServerGame game = ServerGame.FiveCardDraw;
port = int.Parse(args[1]);
// test to see if the game mode is recognized
if (args[0] == "texas")
{
game = ServerGame.TexasHoldem;
}
else if (args[0] == "five")
{
game = ServerGame.FiveCardDraw;
}
else if (args[0] == "seven")
{
game = ServerGame.SevenCardStud;
}
else if (args[0] == "omaha")
{
game = ServerGame.OmahaHoldem;
}
else // assume the argument is an ip or dns
{
serverIp = args[0];
}
// found a match to the game
if (serverIp == string.Empty)
{
BaseEngine server = null;
WcfEngineHost binaryHelper = new WcfEngineHost();
switch (game)
{
case ServerGame.FiveCardDraw: server = new FiveGameDrawServer(binaryHelper); break;
case ServerGame.TexasHoldem: server = new TexasHoldemServer(binaryHelper); break;
case ServerGame.SevenCardStud: server = new SevenCardStudServer(binaryHelper); break;
case ServerGame.OmahaHoldem: server = new OmahaHoldemServer(binaryHelper); break;
}
System.Threading.ManualResetEvent waitHandle = new System.Threading.ManualResetEvent(false);
binaryHelper.Initialize(server, game, port, waitHandle);
// initialize the server and run until the game is over
server.Initialize();
Console.WriteLine("Press enter to stop the registration");
Console.ReadLine();
waitHandle.Set();
server.Run();
waitHandle.Close();
}
else
{
// if the arguments count is higher than 2 assume the process started will be played by an AI engine.
bool useAi = args.Length > 2;
// this is the base client which will hold the connected game
ClientHelperBridge clientBridge = new ClientHelperBridge();
RulesInterpreterBridge rulesBridge = new RulesInterpreterBridge();
BaseWcfClient client = new BaseWcfClient(clientBridge);
clientBridge.ClientHelper = new ConsoleClientHelper(rulesBridge);
ServerDetails result = client.Initialize(serverIp, port);
// check the result of the connection
if (result.CanConnect)
{
IClientHelper outerClient = null;
if (useAi)
{
switch (result.Game)
{
case ServerGame.FiveCardDraw: outerClient = new FiveGameDrawClient(new AiFiveCardDrawClient(new ConsoleFiveGameDrawClient(rulesBridge), rulesBridge)); break;
case ServerGame.OmahaHoldem: outerClient = new OmahaHoldemClient(new AiClientHelper(new ConsoleTexasHoldemClient(rulesBridge, 4), rulesBridge)); break;
case ServerGame.SevenCardStud: outerClient = new GameClient <SevenCardStudGame>(new AiClientHelper(new ConsoleClientHelper(rulesBridge), rulesBridge)); break;
case ServerGame.TexasHoldem: outerClient = new GameClient <TexasHoldem>(new AiClientHelper(new ConsoleTexasHoldemClient(rulesBridge), rulesBridge)); break;
}
}
else
{
switch (result.Game)
{
case ServerGame.FiveCardDraw: outerClient = new FiveGameDrawClient(new ConsoleFiveGameDrawClient(rulesBridge)); break;
case ServerGame.OmahaHoldem: outerClient = new OmahaHoldemClient(new ConsoleTexasHoldemClient(rulesBridge, 4)); break;
case ServerGame.SevenCardStud: outerClient = new GameClient <SevenCardStudGame>(new ConsoleClientHelper(rulesBridge)); break;
case ServerGame.TexasHoldem: outerClient = new GameClient <TexasHoldem>(new ConsoleTexasHoldemClient(rulesBridge)); break;
}
}
IRulesInterpreter interpreter = (IRulesInterpreter)outerClient;
rulesBridge.Interpreter = interpreter;
if (result.Game == ServerGame.FiveCardDraw)
{
clientBridge.FiveCardHelper = (IFiveCardClientHelper)outerClient;
}
else
{
clientBridge.ClientHelper = outerClient;
}
client.Connect();
// run until the game is over
client.Run();
client.Disconnect();
}
else
{
Console.WriteLine("Game is in progress. Server refused connection");
}
}
}
}
catch (Exception e)
{
// an error occured. print an unfriendly message
Console.WriteLine("Uh oh, I did bad");
// when a debugger is attached, break it so you can learn of the error.
if (System.Diagnostics.Debugger.IsAttached)
{
Console.WriteLine(e.Message);
System.Diagnostics.Debugger.Break();
}
}
}
internal MTCPNetworkEngine(BaseEngine engine) : base(engine)
{
}
