protected override void ProcessOFF(TokenMessage msg) { base.ProcessOFF(msg); this.parent.Invoke( new VoidDelegate( delegate { this.parent.Close(); })); }
public static void CreateMapFromMDF(TokenMessage msg, Game game) { TokenMessage msgProvinces = msg.SubMessages[2]; TokenMessage msgSupplyCenterProvinces = msgProvinces.SubMessages[0]; foreach(TokenMessage message in msgSupplyCenterProvinces.SubMessages) { for (int index = 1; index < message.SubMessages.Count; ++index) { Province province = GetProvince(message.SubMessages[index].Tokens[0], game); foreach(Token powerToken in message.SubMessages[0].Tokens) { Power power = GetPower(powerToken, game); if (power != null) { power.HomeProvinces.Add(province); } } } } //Adjacencies TokenMessage msgAdjacencies = msg.SubMessages[3]; foreach(TokenMessage msgAdjacency in msgAdjacencies.SubMessages) { Province fromProvince = game.Map.Provinces[msgAdjacency.Tokens[0].ToString()]; for (int index = 1; index < msgAdjacency.SubMessages.Count; ++index) { TokenMessage msgUnitAndAdj = msgAdjacency.SubMessages[index]; Location fromLocation; UnitType unitType; if (msgUnitAndAdj.SubMessages.Count == 0) { fromLocation = GetOrCreateLocation(fromProvince, msgUnitAndAdj); unitType = GetUnitType(msgUnitAndAdj.Tokens[0]); } else { fromLocation = GetOrCreateLocation(fromProvince, msgUnitAndAdj.SubMessages[0]); unitType = GetUnitType(msgUnitAndAdj.SubMessages[0].Tokens[0]); } for (int ii = 1; ii < msgUnitAndAdj.SubMessages.Count; ++ii) { Location toLocation = GetOrCreateLocation(unitType, msgUnitAndAdj.SubMessages[ii], game); Trace.WriteLineIf(mySwitch.Enabled, string.Format(CultureInfo.InvariantCulture, ErrorMessages.Util_Trace_NewAdjacency, fromLocation.ToString(), toLocation.ToString()), traceCategory); fromLocation.AdjacentLocations.Add(toLocation); } } } game.Map.FinalSetup(); }
protected override void ProcessNOW(TokenMessage msg) { switch( this.Game.Turn.Phase ) { case Phase.Spring: OrderMoves(); break; case Phase.Summer: OrderRetreats(); break; case Phase.Fall: OrderMoves(); break; case Phase.Autumn: OrderRetreats(); break; case Phase.Winter: OrderBuildsAndDisbands(); break; } SubmitOrders(); }
/// <summary>Submits the <see cref="CurrentOrders"/> to the server. /// </summary> protected void SubmitOrders() { if( this.orders.Count == 0 ) { return; } TokenMessage msg = new TokenMessage(Token.SUB); foreach( Order order in this.orders ) { TokenMessage msgOrder = new TokenMessage(); //object[] parameters = order.GetOrderParameters(); switch (order.OrderType) { case OrderType.Build : { BuildOrder o = order as BuildOrder; //Debug.Assert(parameters.Length == 0); msgOrder.Add( Util.ToOrderFormat(o.Unit).MessageEnclosed ); msgOrder.Add( Token.BLD ); break; } case OrderType.Convey : { ConveyOrder o = order as ConveyOrder; //Debug.Assert(parameters.Length == 2); //Debug.Assert(parameters[0] is Unit); //Debug.Assert(parameters[1] is Location); msgOrder.Add( Util.ToOrderFormat(o.Unit).MessageEnclosed ); msgOrder.Add( Token.CVY ); msgOrder.Add( Util.ToOrderFormat(o.ConveyedUnit).MessageEnclosed ); msgOrder.Add( Token.CTO ); msgOrder.Add( Util.ToOrderFormat(o.TargetProvince) ); break; } case OrderType.Disband : { DisbandOrder o = order as DisbandOrder; //Debug.Assert(parameters.Length == 0); msgOrder.Add( Util.ToOrderFormat(o.Unit).MessageEnclosed ); msgOrder.Add( Token.DSB ); break; } case OrderType.Hold : { HoldOrder o = order as HoldOrder; //Debug.Assert(parameters.Length == 0); msgOrder.Add( Util.ToOrderFormat(o.Unit).MessageEnclosed ); msgOrder.Add( Token.HLD ); break; } case OrderType.Move : { MoveOrder o = order as MoveOrder; //Debug.Assert(parameters.Length == 1); //Debug.Assert(parameters[0] is Location); msgOrder.Add( Util.ToOrderFormat(o.Unit).MessageEnclosed ); msgOrder.Add( Token.MTO ); msgOrder.Add( Util.ToOrderFormat(o.TargetLocation) ); break; } case OrderType.MoveByConvoy : { MoveByConvoyOrder o = order as MoveByConvoyOrder; //Debug.Assert(parameters.Length == 1); //Debug.Assert(parameters[0] is Route); //Route route = parameters[0] as Route; msgOrder.Add( Util.ToOrderFormat(o.Unit).MessageEnclosed ); msgOrder.Add( Token.CTO ); msgOrder.Add( Util.ToOrderFormat(o.Route.End) ); msgOrder.Add( Token.VIA ); TokenMessage via = new TokenMessage(); foreach (Province province in o.Route.Via.Provinces) { via.Add( Util.ToOrderFormat(province) ); } msgOrder.Add( via.MessageEnclosed ); break; } case OrderType.Remove : { RemoveOrder o = order as RemoveOrder; //Debug.Assert(parameters.Length == 0); msgOrder.Add( Util.ToOrderFormat(o.Unit).MessageEnclosed ); msgOrder.Add( Token.REM ); break; } case OrderType.Retreat : { RetreatOrder o = order as RetreatOrder; //Debug.Assert(parameters.Length == 1); //Debug.Assert(parameters[0] is Location); msgOrder.Add( Util.ToOrderFormat(o.Unit).MessageEnclosed ); msgOrder.Add( Token.RTO ); msgOrder.Add( Util.ToOrderFormat(o.RetreatLocation) ); break; } case OrderType.SupportHold : { SupportHoldOrder o = order as SupportHoldOrder; //Debug.Assert(parameters.Length == 1); //Debug.Assert(parameters[0] is Unit); msgOrder.Add( Util.ToOrderFormat(o.Unit).MessageEnclosed ); msgOrder.Add( Token.SUP ); msgOrder.Add( Util.ToOrderFormat(o.SupportedUnit).MessageEnclosed ); break; } case OrderType.SupportMove : { SupportMoveOrder o = order as SupportMoveOrder; //Debug.Assert(parameters.Length == 2); //Debug.Assert(parameters[0] is Unit); //Debug.Assert(parameters[1] is Province); msgOrder.Add( Util.ToOrderFormat(o.Unit).MessageEnclosed ); msgOrder.Add( Token.SUP ); msgOrder.Add( Util.ToOrderFormat(o.SupportedUnit).MessageEnclosed ); msgOrder.Add( Token.MTO ); msgOrder.Add( Util.ToOrderFormat(o.TargetProvince) ); break; } case OrderType.WaiveBuild : { WaiveBuildOrder o = order as WaiveBuildOrder; //Debug.Assert(parameters.Length == 1); //Debug.Assert(parameters[0] is Power); msgOrder.Add( Util.ToOrderFormat(o.Power) ); msgOrder.Add( Token.WVE ); break; } default : throw new InvalidOperationException( string.Format(CultureInfo.InvariantCulture, ErrorMessages.Basebot_Exception_UnknownOrderType, order.OrderType.ToString())); } msg.Add(msgOrder.MessageEnclosed); } this.connection.Send(msg); }
/// <summary>Processes an unexpected YES message. /// The default version sends the message to the log. /// </summary> /// <param name="msg">The YES message.</param> /// <param name="confirmedMessage">The message that was unexpected.</param> protected virtual void ProcessYES_Unexpected(TokenMessage msg, TokenMessage confirmedMessage) { Trace.WriteLineIf(baseBotSwitch.Enabled, string.Format(CultureInfo.InvariantCulture, ErrorMessages.Basebot_Trace_UnexpectedMessage, "YES", msg.ToString()), traceCategory); }
/// <summary>Processes a TME message (Indicates the number of seconds until the next deadline). /// The default version does nothing. /// </summary> /// <param name="msg">The TME message.</param> protected virtual void ProcessTME(TokenMessage msg) { }
/// <summary>Processes a SVE message (Save the game). /// The default version does responds with a YES message (but does not save the game). /// </summary> /// <param name="msg">The SVE message.</param> protected virtual void ProcessSVE(TokenMessage msg) { this.connection.Send(Token.YES & msg); }
/// <summary>Processes an unexpected REJ message. /// The default version sends the message to the log. /// </summary> /// <param name="msg">The REJ message.</param> /// <param name="rejectMessage">The message that was unexpected.</param> protected virtual void ProcessREJ_Unexpected(TokenMessage msg, TokenMessage rejectMessage) { Trace.WriteLineIf( baseBotSwitch.Enabled, string.Format(CultureInfo.InvariantCulture, ErrorMessages.Basebot_Trace_UnexpectedMessage, "REJ", msg.ToString()), traceCategory); Debug.Assert(false); }
/// <summary>Processes an OFF message (Turn off). /// The default version sets the <see cref="EndOfGameCause"/> to <see cref="FinishingCause.Off"/>. /// </summary> /// <param name="msg">The OFF message.</param> protected virtual void ProcessOFF(TokenMessage msg) { this.finishingCause = FinishingCause.Off; }
private void PreProcessSCO(TokenMessage msg) { Util.UpdateGameFromSCO(msg, this.game); ProcessSCO(msg); }
private void PreProcessREJ_NOT(TokenMessage msg, TokenMessage rejectMessage) { Token command = rejectMessage.SubMessages[1].Tokens[0]; switch( command.ToString().ToUpper(CultureInfo.InvariantCulture) ) { case "DRW": ProcessREJ_NOT_DRW(msg, rejectMessage); break; case "GOF": ProcessREJ_NOT_GOF(msg, rejectMessage); break; default: ProcessREJ_NOT_Unexpected(msg, rejectMessage); break; } }
private void PreProcessREJ(TokenMessage msg) { TokenMessage rejectMessage = msg.SubMessages[1]; switch( rejectMessage.Tokens[0].ToString().ToUpper(CultureInfo.InvariantCulture) ) { case "ADM": ProcessREJ_ADM(msg, rejectMessage); break; case "DRW": ProcessREJ_DRW(msg, rejectMessage); break; case "GOF": ProcessREJ_GOF(msg, rejectMessage); break; case "HLO": ProcessREJ_HLO(msg, rejectMessage); break; case "HST": ProcessREJ_HST(msg, rejectMessage); break; case "IAM": ProcessREJ_IAM(msg, rejectMessage); break; case "NME": ProcessREJ_NME(msg, rejectMessage); break; case "NOT": PreProcessREJ_NOT(msg, rejectMessage); break; case "NOW": ProcessREJ_NOW(msg, rejectMessage); break; case "ORD": ProcessREJ_ORD(msg, rejectMessage); break; case "SCO": ProcessREJ_SCO(msg, rejectMessage); break; case "SND": ProcessREJ_SND(msg, rejectMessage); break; case "SUB": ProcessREJ_SUB(msg, rejectMessage); break; case "TME": ProcessREJ_TME(msg, rejectMessage); break; default: ProcessREJ_Unexpected(msg, rejectMessage); break; } }
private void PreProcessOUT(TokenMessage msg) { //TODO: Press check. ProcessOUT(msg); }
private void PreProcessORD(TokenMessage msg) { //Util.UpdateGameFromORD(msg, this.game); ProcessORD(msg); }
private void PreProcessNOW(TokenMessage msg) { BeforeNewTurn(); Util.UpdateGameFromNOW(msg, this.game); this.orders.Clear(); ProcessNOW(msg); }
/// <summary>Processes a NOT CCD message (the specified country is not in civil disorder). /// The default version does nothing. /// </summary> /// <param name="msg">The NOT message.</param> /// <param name="messageParameters">The CCD message.</param> /// <param name="newReconnection">Set to true if the indicated power is newly reconnected.</param> protected virtual void ProcessNOT_CCD(TokenMessage msg, TokenMessage messageParameters, bool newReconnection) { }
/// <summary>Processes a NOT TME message (Specifies that the deadline timer has stopped). /// The default version does nothing. /// </summary> /// <param name="msg">The NOT message.</param> /// <param name="messageParameters">The TME message.</param> protected virtual void ProcessNOT_TME(TokenMessage msg, TokenMessage messageParameters) { }
private void PreProcessSLO(TokenMessage msg) { this.finishingCause = FinishingCause.Solo; ProcessSLO(msg); }
/// <summary>Processes a REJ TME message (a rejected TME message). /// The default version sends the message to the log. /// </summary> /// <param name="msg">The REJ message.</param> /// <param name="rejectMessage">The TME message.</param> protected virtual void ProcessREJ_TME(TokenMessage msg, TokenMessage rejectMessage) { Trace.WriteLineIf( baseBotSwitch.Enabled, string.Format(CultureInfo.InvariantCulture, ErrorMessages.Basebot_Trace_MessageRejected, msg.ToString()), traceCategory); }
private void PreProcessYES(TokenMessage msg) { TokenMessage confirmedMessage = msg.SubMessages[1]; switch( confirmedMessage.Tokens[0].ToString().ToUpper(CultureInfo.InvariantCulture) ) { case "DRW": ProcessYES_DRW(msg, confirmedMessage); break; case "GOF": ProcessYES_GOF(msg, confirmedMessage); break; case "IAM": ProcessYES_IAM(msg, confirmedMessage); break; case "NME": ProcessYES_NME(msg, confirmedMessage); break; case "NOT": ProcessYES_NOT(msg, confirmedMessage); break; case "OBS": ProcessYES_OBS(msg, confirmedMessage); break; case "SND": ProcessYES_SND(msg, confirmedMessage); break; case "TME": ProcessYES_TME(msg, confirmedMessage); break; default: ProcessYES_Unexpected(msg, confirmedMessage); break; } }
/// <summary>Processes a SLO message (Someone has won solo). /// The default version set the <see cref="finishingCause"/> to <see cref="FinishingCause.Solo"/>. /// </summary> /// <param name="msg">The SLO message.</param> protected virtual void ProcessSLO(TokenMessage msg) { this.finishingCause = FinishingCause.Solo; }
/// <summary>Connects to a DAIDE server running at the specified location. /// </summary> /// <param name="hostName">The name of the server. This can either be an IP number or a server name.</param> /// <param name="port">The port to connect to.</param> /// <param name="name">The name of the bot.</param> /// <param name="version">The version of the bot.</param> protected void Connect(string hostName, int port, string name, string version) { this.connection.Connect(hostName, port); TokenMessage msg = new TokenMessage(Token.NME); msg += new TokenMessage(TokenFactory.FromString(name)).MessageEnclosed; msg += new TokenMessage(TokenFactory.FromString(version)).MessageEnclosed; Send(msg); }
/// <summary>Processes a THX message (Thanks for an order). /// The default version sends the message to the log if the message indicated an error. /// If possible, it also sends a replacement order. /// </summary> /// <param name="msg">The THX message.</param> /// <remarks> /// The action that is taken depends on the note that is returned from the server, as follows: /// MBV - no action taken, the order is correct as it stands. /// NYU - message is logged. /// NRS - message is logged. /// HLD - message is logged. /// NRN - message is logged. /// NMB - message is logged. /// NMR - message is logged. /// FAR - message is logged, and a replacement Hold order is sent. /// NSP - message is logged, and a replacement Hold order is sent. /// NSU - message is logged, and a replacement Hold order is sent. /// NAS - message is logged, and a replacement Hold order is sent. /// NSF - message is logged, and a replacement Hold order is sent. /// NSA - message is logged, and a replacement Hold order is sent. /// NVR - message is logged, and a replacement Disband order is sent. /// YSC - message is logged, and a replacement Waive order is sent. /// ESC - message is logged, and a replacement Waive order is sent. /// HSC - message is logged, and a replacement Waive order is sent. /// NSC - message is logged, and a replacement Waive order is sent. /// CST - message is logged, and a replacement Waive order is sent. /// </remarks> protected virtual void ProcessTHX(TokenMessage msg) { TokenMessage order = msg.SubMessages[1]; Token note = msg.SubMessages[2].Tokens[0]; TokenMessage replacementOrder = null; if (note == Token.MBV) { //Valid order return; } //All invalid orders are here! if ( note == Token.NYU || note == Token.NRS ) { // Not the right season / not your unit // There's not much to do. } TokenMessage unit = order.SubMessages[0].MessageEnclosed;; if (order.SubMessages[1].Tokens[0] == Token.HLD) { // A unit was ordered to hold, but the order failed. // There's not much we can do! } if ( note == Token.NRN || note == Token.NMB || note == Token.NMR ) { // Order wasn't needed in the first place! } if ( note == Token.FAR || note == Token.NSP || note == Token.NSU || note == Token.NAS || note == Token.NSF || note == Token.NSA ) { // Illegal movement order. Replace with a hold order. replacementOrder = unit + Token.HLD; } if (note == Token.NVR) { // Illegal retreat order. Replace with a disband order replacementOrder = unit + Token.DSB; } if ( note == Token.YSC || note == Token.ESC || note == Token.HSC || note == Token.NSC || note == Token.CST ) { // Illegal build order. Replace with a waive order replacementOrder = unit.SubMessages[0] + Token.WVE; } if (replacementOrder != null) { Trace.WriteLineIf(baseBotSwitch.Enabled, string.Format(CultureInfo.InvariantCulture, ErrorMessages.Basebot_Trace_InvalidOrderReplaced, order.ToString(), replacementOrder.ToString()), traceCategory); replacementOrder = Token.SUB & replacementOrder; this.connection.Send(replacementOrder); } else { Trace.WriteLineIf( baseBotSwitch.Enabled, string.Format(CultureInfo.InvariantCulture, ErrorMessages.Basebot_Trace_InvalidOrderNotReplaced, order.ToString()), traceCategory); } }
/// <summary>Processes a CCD message (County in Civil Disorder). /// The default version does nothing. /// </summary> /// <param name="msg">The CCD message</param> /// <param name="isNewDisconnection">Set to true if the notification is a new country in civil disorder. /// <see cref="powersInCivilDisorder"/></param> protected virtual void ProcessCCD(TokenMessage msg, bool isNewDisconnection) { }
/// <summary>Processes a YES TME message (a confirmation of a TME message). /// The default version does nothing. /// </summary> /// <param name="msg">The YES message.</param> /// <param name="confirmedMessage">The TME message.</param> protected virtual void ProcessYES_TME(TokenMessage msg, TokenMessage confirmedMessage) { }
/// <summary>Processes a DRW message (a Draw has been declared by the server). /// The default version sets <see cref="finishingCause"/> to <see cref="FinishingCause.Draw"/>. /// </summary> /// <param name="msg">The DRW message.</param> protected virtual void ProcessDRW(TokenMessage msg) { this.finishingCause = FinishingCause.Draw; }
/// <summary>Sends the <see cref="TokenMessage"/> to the server. /// </summary> /// <param name="msg">The message to send.</param> protected void Send(TokenMessage msg) { //TODO: Preprocess some orders, so that we will not react // to some client orders, such as HST, etc. this.connection.Send(msg); }
/// <summary>Processes a FRM message (press from another <see cref="Power"/>). /// The default version responds with a HUH message, followed with a TRY message that is empty. /// </summary> /// <param name="msg">The FRM message.</param> protected virtual void ProcessFRM(TokenMessage msg) { // The BaseBot does not understand press. // Reply with a "HUH" and and "TRY" that is // empty. if (msg.SubMessages[3].Tokens[0] != Token.HUH && msg.SubMessages[3].Tokens[0] != Token.TRY) { TokenMessage huh = Token.SND & msg.SubMessages[1].Tokens[0] & ( Token.HUH & ( Token.ERR + msg.SubMessages[3] ) ); TokenMessage tryMsg = Token.SND & msg.SubMessages[1].Tokens[0] & (Token.TRY & new TokenMessage()); this.connection.Send(huh); this.connection.Send(tryMsg); } }
protected override void ProcessNOW(TokenMessage msg) { switch (this.Game.Turn.Phase) { case Phase.Spring: randomOrders(); break; case Phase.Summer: randomRetreat(); break; case Phase.Fall: randomOrders(); break; case Phase.Autumn: randomRetreat(); break; case Phase.Winter: randomBuild(); break; default: break; } SubmitOrders(); }
/// <summary>Processes a LOD message (Load a previously saved game). /// The default version responds by rejecting the message. /// </summary> /// <param name="msg">The LOD message.</param> protected virtual void ProcessLOD(TokenMessage msg) { this.connection.Send(Token.REJ & msg); }