ACR_ServerCommunicator.GameWorldManager.SynchronizeIPCEventQueue C# (CSharp) Method

SynchronizeIPCEventQueue() private method

This method synchronizes the IPC event queue for the server.
private SynchronizeIPCEventQueue ( ) : void
return void
        private void SynchronizeIPCEventQueue()
        {
            IALFADatabase Database = DatabaseLinkQueryThread;
            int HighestRecordId = 0;

            //
            // Retrieve any new IPC events from the database.
            //

            List<SynchronizeIPCEventQueueRow> Rowset = new List<SynchronizeIPCEventQueueRow>();

            Database.ACR_SQLQuery(String.Format(
                "SELECT " +
                    "`server_ipc_events`.`ID` as record_id, " +
                    "`server_ipc_events`.`SourcePlayerID` as source_player_id, " +
                    "`server_ipc_events`.`SourceServerID` as source_server_id, " +
                    "`server_ipc_events`.`DestinationPlayerID` as destination_player_id, " +
                    "`server_ipc_events`.`DestinationServerID` as destination_server_id, " +
                    "`server_ipc_events`.`EventType` as event_type, " +
                    "`server_ipc_events`.`EventText` as event_text " +
                "FROM `server_ipc_events` " +
                "WHERE `server_ipc_events`.`DestinationServerID` = {0} " +
                "GROUP BY record_id " +
                "ORDER BY record_id " +
                "LIMIT 1000 ",
                LocalServerId
                ));

            //
            // Fetch and dispatch each of them.
            //

            try
            {
               while (Database.ACR_SQLFetch())
               {
                   SynchronizeIPCEventQueueRow Row;

                   Row.RecordId = Convert.ToInt32(Database.ACR_SQLGetData(0));
                   Row.SourcePlayerId = Convert.ToInt32(Database.ACR_SQLGetData(1));
                   Row.SourceServerId = Convert.ToInt32(Database.ACR_SQLGetData(2));
                   Row.DestinationPlayerId = Convert.ToInt32(Database.ACR_SQLGetData(3));
                   Row.DestinationServerId = Convert.ToInt32(Database.ACR_SQLGetData(4));
                   Row.EventType = Convert.ToInt32(Database.ACR_SQLGetData(5));
                   Row.EventText = Database.ACR_SQLGetData(6);

                   Rowset.Add(Row);
               }

               foreach (SynchronizeIPCEventQueueRow Row in Rowset)
               {
                   int RecordId = Row.RecordId;
                   int SourcePlayerId = Row.SourcePlayerId;
                   int SourceServerId = Row.SourceServerId;
                   int DestinationPlayerId = Row.DestinationPlayerId;
                   int DestinationServerId = Row.DestinationServerId;
                   int EventType = Row.EventType;
                   string EventText = Row.EventText;

                   HighestRecordId = RecordId;

                   switch (EventType)
                   {

                       case ACR_SERVER_IPC_EVENT_CHAT_TELL:
                           lock (this)
                           {
                               GamePlayer SenderPlayer = ReferencePlayerById(SourcePlayerId, Database);
                               GamePlayer RecipientPlayer = ReferencePlayerById(DestinationPlayerId, Database);

                               if (SenderPlayer == null || RecipientPlayer == null)
                               {
                                   WriteDiagnosticLog(String.Format(
                                       "GameWorldManager.SynchronizeIPCEventQueue: Source {0} or destination {1} player IDs invalid for ACR_SERVER_IPC_EVENT_CHAT_TELL.", SourcePlayerId, DestinationPlayerId));
                                   continue;

                               }

                               GameCharacter SenderCharacter = SenderPlayer.GetOnlineCharacter();
                               GameCharacter RecipientCharacter = RecipientPlayer.GetOnlineCharacter();

                               if (SenderCharacter == null || RecipientCharacter == null)
                               {
                                   WriteDiagnosticLog(String.Format(
                                       "GameWorldManager.SynchronizeIPCEventQueue: Source {0} or destination {1} player has already gone offline for ACR_SERVER_IPC_EVENT_CHAT_TELL.", SourcePlayerId, DestinationPlayerId));
                                   continue;
                               }

                               OnChatTell(SenderCharacter, RecipientPlayer, EventText);
                           }
                           break;

                       case ACR_SERVER_IPC_EVENT_BROADCAST_NOTIFICATION:
                           lock (this)
                           {
                               OnBroadcastNotification(EventText);
                           }
                           break;

                       case ACR_SERVER_IPC_EVENT_DISCONNECT_PLAYER:
                           lock (this)
                           {
                               GamePlayer Player = ReferencePlayerById(DestinationPlayerId, Database);

                               if (Player == null)
                               {
                                   WriteDiagnosticLog(String.Format(
                                       "GameWorldManager.SynchronizeIPCEventQueue: Target player {0} for ACR_SERVER_IPC_EVENT_DISCONNECT_PLAYER is an invalid player id reference.", DestinationPlayerId));
                                   continue;
                               }

                               OnDisconnectPlayer(Player);
                           }
                           break;

                       case ACR_SERVER_IPC_EVENT_PURGE_CACHED_CHARACTER:
                           lock (this)
                           {
                               GamePlayer Player = ReferencePlayerById(DestinationPlayerId, Database);

                               if (Player == null)
                               {
                                   WriteDiagnosticLog(String.Format(
                                       "GameWorldManager.SynchronizeIPCEventQueue: Target player {0} for ACR_SERVER_IPC_EVENT_PURGE_CACHED_CHARACTER is an invalid player id reference.", DestinationPlayerId));
                                   continue;
                               }

                               OnPurgeCachedCharacter(Player, EventText);
                           }
                           break;

                       case ACR_SERVER_IPC_EVENT_SHUTDOWN_SERVER:
                           lock (this)
                           {
                               OnShutdownServer(EventText);
                           }
                           break;

                       case ACR_SERVER_IPC_EVENT_PAGE:
                           lock (this)
                           {
                               GamePlayer SenderPlayer = ReferencePlayerById(SourcePlayerId, Database);
                               GamePlayer RecipientPlayer = ReferencePlayerById(DestinationPlayerId, Database);

                               if (SenderPlayer == null || RecipientPlayer == null)
                               {
                                   WriteDiagnosticLog(String.Format(
                                       "GameWorldManager.SynchronizeIPCEventQueue: Source {0} or destination {1} player IDs invalid for ACR_SERVER_IPC_EVENT_PAGE.", SourcePlayerId, DestinationPlayerId));
                                   continue;
                               }

                               GameCharacter RecipientCharacter = RecipientPlayer.GetOnlineCharacter();

                               if (RecipientCharacter == null)
                               {
                                   WriteDiagnosticLog(String.Format(
                                       "GameWorldManager.SynchronizeIPCEventQueue: Destination {1} player has already gone offline for ACR_SERVER_IPC_EVENT_PAGE.", DestinationPlayerId));
                                   continue;
                               }

                               OnPage(SenderPlayer, RecipientPlayer, EventText);
                           }
                           break;

                       case ACR_SERVER_IPC_EVENT_RUN_SCRIPT:
                           lock (this)
                           {
                               GameServer SourceServer = ReferenceServerById(SourceServerId, Database);
                               string ScriptName;
                               string ScriptArgument;
                               int i;

                               if (SourceServerId != 0 && SourceServer == null)
                               {
                                   WriteDiagnosticLog(String.Format(
                                       "GameWorldManager.SynchronizeIPCEventQueue: Source {0} server ID is invalid for ACR_SERVER_IPC_EVENT_RUN_SCRIPT.", SourceServerId));
                                   continue;
                               }

                               i = EventText.IndexOf(':');

                               if (i == -1)
                               {
                                   ScriptName = EventText.ToLowerInvariant();
                                   ScriptArgument = "";
                               }
                               else
                               {
                                   ScriptName = EventText.Substring(0, i).ToLowerInvariant();
                                   ScriptArgument = EventText.Substring(i + 1);
                               }

                               OnRunScript(SourceServer, ScriptName, ScriptArgument);
                           }
                           break;

                       default:
                           lock (this)
                           {
                               OnUnsupportedIPCEventType(RecordId, SourcePlayerId, SourceServerId, DestinationPlayerId, EventType, EventText);
                           }
                           break;

                   }
               }
            }
            finally
            {
               //
               // Now delete all of the records that we processed.
               //

               if (HighestRecordId != 0)
               {
                   Database.ACR_SQLQuery(String.Format(
                       "DELETE FROM `server_ipc_events` WHERE `DestinationServerID` = {0} AND `ID` < {1}",
                       LocalServerId,
                       HighestRecordId + 1));
               }
            }
        }