public void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.REQUEST_HEARTBEAT:
double currentTimestamp = (DateTime.Now - DateTime.MinValue).TotalMilliseconds;
RequestHeartbeatMessage requestMessage = (RequestHeartbeatMessage)message;
HeartbeatMessage heartbeatMessage = new HeartbeatMessage(requestMessage);
heartbeatMessage.serverTimestamp = ((RequestHeartbeatMessage)message).createdTimestamp;
heartbeatMessage.createdTimestamp = currentTimestamp;
sendMessage(heartbeatMessage);
break;
case QTMessage.type.ROOM_INFO:
RoomInfoMessage infoMessage = (RoomInfoMessage)message;
WorkerServerManager.instance.room = infoMessage.room;
WorkerInfoMessage workerMessage = new WorkerInfoMessage();
workerMessage.id = WorkerServerManager.instance.room.id;
workerMessage.ip = "127.0.0.1";
sendMessage(workerMessage);
QTDebugger.instance.debug(QTDebugger.debugType.BASE, "Sending worker info message...");
break;
}
}
public void StartGame()
{
networkJobHandle.Complete();
StartGameMessage startMessage = new StartGameMessage
{
StartHP = 10
};
SendMessageToAll(startMessage);
//enviroment data is setup
serverDataHolder.GameSetup();
//everyone gets a rooms info message.
for (int i = 0; i < connections.Length; i++)
{
RoomInfoMessage startRoomMessage = serverDataHolder.GetRoomMessage(i);
SendMessage(startRoomMessage, connections[i]);
}
//turn event is called
PlayerTurnMessage turnMessage = new PlayerTurnMessage
{
PlayerID = serverDataHolder.turnID
};
SendMessageToAll(turnMessage);
}
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.WORKER_READY: {
MasterServerQTClient qtRemoteClient = (MasterServerQTClient)client;
WorkerReadyMessage workerReadyMessage = (WorkerReadyMessage)message;
qtRemoteClient.remoteType = QTClient.clientType.WORKER_SERVER;
MasterServerWorker worker = MasterServerManager.instance.workersManager.workers[workerReadyMessage.id];
RoomInfoMessage roomInfoMessage = new RoomInfoMessage();
roomInfoMessage.room = worker.room;
qtRemoteClient.sendMessage(roomInfoMessage);
worker.onWorkerReady();
break;
}
case QTMessage.type.WORKER_INFO: {
MasterServerQTClient qtRemoteClient = (MasterServerQTClient)client;
WorkerInfoMessage workerInfoMessage = (WorkerInfoMessage)message;
MasterServerWorker worker = MasterServerManager.instance.workersManager.workers[workerInfoMessage.id];
worker.room.ip = workerInfoMessage.ip;
QTDebugger.instance.debug(QTDebugger.debugType.BASE, "Recieved info from Worker(" + worker.room.id + ")...");
break;
}
}
}
private void GetRoomInfo(ref DataStreamReader reader)
{
var roomInfoMessage = new RoomInfoMessage();
roomInfoMessage.DeserializeObject(ref reader);
dataHolder.game.UpdateRoom(roomInfoMessage);
}
public void HandleRoomInfo(Message message)
{
RoomInfoMessage roomInfoMessage = (RoomInfoMessage)message;
Menu.Singleton.gameWindow.OutputRoomInfoText(roomInfoMessage);
//could disable UI
}
/// <summary>
/// Sends a RoomInfoMessage and saves the given room configuration.
/// </summary>
/// <param name="roomJid">The bare JID if the room you would like to save the room configuration for. e.g. '*****@*****.**'</param>
/// <param name="roomConfiguration">The new room configuration.</param>
/// <param name="configLevel">The requested configuration level (the senders affiliation).</param>
/// <param name="onMessage">The method that should get executed once the helper receives a new valid message.</param>
/// <param name="onTimeout">The method that should get executed once the helper timeout gets triggered.</param>
/// <returns>Returns a MessageResponseHelper listening for RoomInfoMessage answers.</returns>
public MessageResponseHelper <IQMessage> saveRoomConfiguration(string roomJid, DataForm roomConfiguration, MUCAffiliation configLevel, Func <IQMessage, bool> onMessage, Action onTimeout)
{
MessageResponseHelper <IQMessage> helper = new MessageResponseHelper <IQMessage>(CLIENT, onMessage, onTimeout);
RoomInfoMessage msg = new RoomInfoMessage(CLIENT.getXMPPAccount().getIdDomainAndResource(), roomJid, roomConfiguration, configLevel);
helper.start(msg);
return(helper);
}
private void SendNewRoomInfo()
{
for (int i = 0; i < connections.Length; i++)
{
RoomInfoMessage info = GameManager.Instance.MakeRoomInfoMessage(i);
NetworkManager.SendMessage(networkDriver, info, connections[i]);
}
}
/// <summary>
/// Sends a RoomInfoMessage and saves the given room configuration.
/// </summary>
/// <param name="roomJid">The bare JID if the room you would like to save the room configuration for. e.g. '*****@*****.**'</param>
/// <param name="roomConfiguration">The new room configuration.</param>
/// <param name="configLevel">The requested configuration level (the senders affiliation).</param>
/// <param name="onMessage">The method that should get executed once the helper receives a new valid message.</param>
/// <param name="onTimeout">The method that should get executed once the helper timeout gets triggered.</param>
/// <returns>Returns a MessageResponseHelper listening for RoomInfoMessage answers.</returns>
public MessageResponseHelper <IQMessage> saveRoomConfiguration(string roomJid, DataForm roomConfiguration, MUCAffiliation configLevel, MessageResponseHelper <IQMessage> .OnMessageHandler onMessage, MessageResponseHelper <IQMessage> .OnTimeoutHandler onTimeout)
{
MessageResponseHelper <IQMessage> helper = new MessageResponseHelper <IQMessage>(CONNECTION, onMessage, onTimeout);
RoomInfoMessage msg = new RoomInfoMessage(CONNECTION.account.getFullJid(), roomJid, roomConfiguration, configLevel);
helper.start(msg);
return(helper);
}
public void UpdateInfo(RoomInfoMessage message)
{
roomData.treasureAmmount = message.TreasureRoom;
roomData.containsMonster = message.ContainsMonster == 1;
if (roomData.containsMonster)
{
roomData.monsterHP = 10;
}
roomData.containsExit = message.ContainsExit == 1;
roomData.numberOfOtherPlayers = message.NumberOfOtherPlayers;
roomData.otherPlayersIDs = message.OtherPlayerIDs;
roomData.directions = roomData.ReadDirectionByte(message.MoveDirections);
UpdateRoom();
}
private bool HandleMoveRequest(MoverequestMessage message, int connectID)
{
PlayerData playerData = serverDataHolder.players.Find(x => x.playerIndex == connectID);
RoomData currentRoom = serverDataHolder.rooms[playerData.roomID[0], playerData.roomID[1]];
int[] nextRoom = serverDataHolder.GetNextRoomID(currentRoom, message.Direction);
bool monsterActive = currentRoom.containsMonster && currentRoom.monsterHP > 0;
//check if player can move to that direction and if the monster in current room is killed or doesnt exist
if (nextRoom == null || monsterActive)
{
//handle requestdenied message
Debug.LogWarning("Request denied");
return(false);
}
//if so update dataholder of server
serverDataHolder.players.Find(x => x.playerIndex == connectID).roomID = nextRoom;
//send room info to cplayer
RoomInfoMessage newRoomMessage = serverDataHolder.GetRoomMessage(connectID);
SendMessage(newRoomMessage, connections[connectID]);
//send leavmessage to players who are in the previous room
List <int> idsInPreviousRoom = serverDataHolder.GetPlayerIDsRoom(currentRoom);
foreach (int id in idsInPreviousRoom)
{
if (id != connectID)
{
//Debug.Log("player # " + connectID + " leaves room where player # " + id + " resides ");
PlayerLeftRoom(connectID, id);
}
}
//send enter message to player who are in the next room.
List <int> idsInNewRoom = serverDataHolder.GetPlayerIDsRoom(serverDataHolder.rooms[nextRoom[0], nextRoom[1]]);
foreach (int id in idsInNewRoom)
{
if (id != connectID)
{
//Debug.Log("player # " + connectID + " enter room where player # " + id + " resides ");
PlayerJoinedRoom(connectID, id);
}
}
return(true);
}
public RoomInfoMessage GetRoomInfo(int playerId)
{
Player player = serverManager.lobby.players[playerId];
Room room = GetRoom(player);
RoomInfoMessage roomInfoMessage = new RoomInfoMessage {
directions = GetPossibleDirections(player.position),
TreasureInRoom = (ushort)room.treasure,
ContainsMonster = room.monster != null,
ContainsExit = room.exit,
OtherPlayerIDs = new List <int>(room.playerIdsInRoom)
};
//dont send the player itself
roomInfoMessage.OtherPlayerIDs.Remove(playerId);
roomInfoMessage.NumberofOtherPlayers = (byte)roomInfoMessage.OtherPlayerIDs.Count;
return(roomInfoMessage);
}
/// <summary>
/// Packing info message for the player in this room.
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
public RoomInfoMessage MakeRoomInfoMessage(int i)
{
byte neighbors = CurrentGrid.CheckNeighbors(i);
TileContent tileContent = CurrentGrid.TileContain(PlayerManager.Instance.Players[i].TilePosition);
ushort treasure = 0;
byte monster = 0;
byte exit = 0;
if (tileContent == TileContent.Treasure || tileContent == TileContent.Both)
{
treasure = 1;
}
if (tileContent == TileContent.Monster || tileContent == TileContent.Both)
{
monster = 1;
}
if (tileContent == TileContent.Exit)
{
exit = 1;
}
List <int> playersID = new List <int>();
for (int j = 0; j < PlayerManager.Instance.Players.Count; j++)
{
if (PlayerManager.Instance.Players[j].TilePosition == PlayerManager.Instance.Players[i].TilePosition)
{
playersID.Add(PlayerManager.Instance.Players[j].playerID);
}
}
var roomInfo = new RoomInfoMessage()
{
directions = neighbors,
TreasureInRoom = treasure,
ContainsMonster = monster,
ContainsExit = exit,
NumberOfOtherPlayers = (byte)playersID.Count,
OtherPlayerIDs = playersID
};
return(roomInfo);
}
private bool onNewMessage(IQMessage iq)
{
if (iq is RoomInfoMessage)
{
RoomInfoMessage responseMessage = iq as RoomInfoMessage;
// Add controls and update viability:
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
fields.Clear();
roomConfigType_tbx.Text = "Configuration level: " + Utils.mucAffiliationToString(responseMessage.CONFIG_LEVEL);
foreach (Field o in responseMessage.ROOM_CONFIG.FIELDS)
{
if (o.type != FieldType.HIDDEN)
{
fields.Add(new MUCInfoFieldTemplate()
{
field = o
});
}
}
reload_btn.IsEnabled = true;
notificationBanner_ian.Dismiss();
timeout_stckpnl.Visibility = Visibility.Collapsed;
loading_grid.Visibility = Visibility.Collapsed;
info_grid.Visibility = Visibility.Visible;
}).AsTask();
return(true);
}
else if (iq is IQErrorMessage errorMessage)
{
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
fields.Clear();
retry_btn.IsEnabled = true;
info_grid.Visibility = Visibility.Collapsed;
loading_grid.Visibility = Visibility.Collapsed;
timeout_stckpnl.Visibility = Visibility.Visible;
notificationBanner_ian.Show("Failed to request configuration! Server responded:\nType: " + errorMessage.ERROR_OBJ.ERROR_NAME + "\nMessage: " + errorMessage.ERROR_OBJ.ERROR_MESSAGE);
}).AsTask();
}
return(false);
}
public void HandleMoveRequest(AdressedMessage adressedMessage)
{
if (!ValidateMessage(adressedMessage.connectionID))
{
SendRequestDenied(adressedMessage);
return;
}
RoomInfoMessage leftRoom = game.GetRoomInfo(adressedMessage.connectionID);
if (game.MovePlayer(adressedMessage.connectionID, ((MoveRequestMessage)adressedMessage.message).direction))
{
//player left messages
foreach (int playerID in leftRoom.OtherPlayerIDs)
{
serverBehaviour.QeueMessage(new AdressedMessage(new PlayerLeaveRoomMessage()
{
PlayerID = adressedMessage.connectionID
}, playerID));
}
//player entered messages
RoomInfoMessage enteredRoom = game.GetRoomInfo(adressedMessage.connectionID);
foreach (int playerID in enteredRoom.OtherPlayerIDs)
{
serverBehaviour.QeueMessage(new AdressedMessage(new PlayerEnterRoomMessage()
{
PlayerID = adressedMessage.connectionID
}, playerID));
}
//roominfo message
serverBehaviour.QeueMessage(new AdressedMessage(enteredRoom, adressedMessage.connectionID));
}
else
{
SendRequestDenied(adressedMessage);
}
}
/// <summary>
/// Send info of the current room to the client as an answer to the MoveRequest & Start of the Game.
/// </summary>
private void SendRoomInfo(Node roomNode, Client activeTurnClient)
{
// testing
int treasureAmt = 0;
Wall openDirection = roomNode.GetOpenDirection();
byte monster = System.Convert.ToByte(roomNode.Monster);
byte exit = System.Convert.ToByte(roomNode.DungeonExit);
int numberOfOtherPlayers = 0;
List <int> otherPlayerIDs = new List <int>();
if (roomNode.Treasure)
{
treasureAmt = Random.Range(minTreasureContainingAmt, maxTreasureContainingAmt);
roomNode.TreasureAmount = treasureAmt;
}
//Get everyone that is in this room
foreach (KeyValuePair <Client, Player> clientPlayerPair in ActiveClientPlayerDictionary)
{
if (clientPlayerPair.Value.CurrentNode == roomNode && clientPlayerPair.Key != activeTurnClient)
{
numberOfOtherPlayers++;
otherPlayerIDs.Add(clientPlayerPair.Key.PlayerID);
}
}
byte numberOfOtherPlayersByte = System.Convert.ToByte(numberOfOtherPlayers);
var roomInfoMessage = new RoomInfoMessage {
MoveDirections = (byte)openDirection,
TreasureInRoom = (ushort)treasureAmt,
ContainsMonster = monster,
ContainsExit = exit,
NumberOfOtherPlayers = numberOfOtherPlayersByte,
OtherPlayerIDs = otherPlayerIDs
};
server.SendMessage(roomInfoMessage, activeTurnClient.Connection);
}
public void Update()
{
networkJobHandle.Complete();
if (!connection.IsCreated)
{
return;
}
DataStreamReader reader;
NetworkEvent.Type cmd;
while ((cmd = connection.PopEvent(networkDriver, out reader)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
Debug.Log("Connected to server");
}
else if (cmd == NetworkEvent.Type.Data)
{
var messageType = (Message.MessageType)reader.ReadUShort();
Debug.Log("Client Received: " + messageType + " from Host");
Message message = null;
switch (messageType)
{
case Message.MessageType.None: break;
case Message.MessageType.NewPlayer: message = new NewPlayerMessage(); break;
case Message.MessageType.Welcome: message = new WelcomeMessage(); break;
case Message.MessageType.RequestDenied: message = new RequestDeniedMessage(); break;
case Message.MessageType.PlayerLeft: message = new PlayerLeftMessage(); break;
case Message.MessageType.StartGame: message = new StartGameMessage(); break;
case Message.MessageType.PlayerTurn: message = new PlayerTurnMessage(); break;
case Message.MessageType.RoomInfo: message = new RoomInfoMessage(); break;
case Message.MessageType.PlayerEnterRoom: message = new PlayerEnterRoomMessage(); break;
case Message.MessageType.PlayerLeaveRoom: message = new PlayerLeaveRoomMessage(); break;
case Message.MessageType.ObtainTreasure: message = new ObtainTreasureMessage(); break;
case Message.MessageType.HitMonster: message = new HitMonserMessage(); break;
case Message.MessageType.HitByMonster: message = new HitByMonserMessage(); break;
case Message.MessageType.PlayerDefends: message = new PlayerDefendsMessage(); break;
case Message.MessageType.PlayerLeftDungeon: message = new PlayerLeftDungeonMessage(); break;
case Message.MessageType.PlayerDies: message = new PlayerDiesMessage(); break;
case Message.MessageType.EndGame: break;
default: break;
}
if (message != null)
{
message.DeserializeObject(ref reader);
receivedMessagesQueue.Enqueue(message);
}
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Disconnected from server");
connection = default;
}
}
ProcessMessagesQueue();
if (Time.time - lastSendTime > STAY_ALIVE_AFTER_SECONDS)
{
SendMessage(new NoneMessage());
}
networkJobHandle = networkDriver.ScheduleUpdate();
}
public override void AfterInvoke(InvocationInfo info, ref object returnValue)
{
//if (info.target is EndGameScreen && info.targetMethod.Equals("GoToLobby")) { ntwrk.inbattle = false; } // user leaved a battle
if (info.target is ChatUI && info.targetMethod.Equals("Show"))
{
helpf.chatisshown = (bool)info.arguments[0]; this.screenh = 0;
} // so position will be calculatet new on next ongui
if (info.target is ChatUI && info.targetMethod.Equals("Initiate"))
{
helpf.target = (ChatUI)info.target;
helpf.setchatlogstyle((GUIStyle)this.chatLogStyleinfo.GetValue(info.target));
}
if (info.target is TradeSystem && info.targetMethod.Equals("StartTrade"))// user start a trade, show the buy-message
{
if (helpf.postmsgontrading == true)
{
helpf.postmsgontrading = false;
helpf.postmsggetnextroomenter = true;// the next RoomEnterMsg is the tradeRoom!
}
}
if (info.target is Store && info.targetMethod.Equals("Start"))//user opened store
{
helpf.setlobbyskin((GUISkin)typeof(Store).GetField("lobbySkin", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(info.target));
helpf.storeinfo = (Store)info.target;
helpf.showtradedialog = false;
helpf.inauchouse = false;
helpf.generator = false;
helpf.settings = false;
}
if (info.target is ChatRooms && info.targetMethod.Equals("SetRoomInfo")) //adding new users to userlist
{
RoomInfoMessage roomInfo = (RoomInfoMessage)info.arguments[0];
RoomInfoProfile[] profiles = roomInfo.updated;
for (int i = 0; i < profiles.Length; i++)
{
RoomInfoProfile p = profiles[i];
ChatUser user = ChatUser.FromRoomInfoProfile(p);
if (!helpf.globalusers.ContainsKey(user.name))
{
helpf.globalusers.Add(user.name, user);
}
;
}
}
if (info.target is Store && info.targetMethod.Equals("OnGUI")) // drawing our buttons and stuff in store
{
GUI.color = Color.white;
GUI.contentColor = Color.white;
drawsubmenu.Invoke(info.target, null);
Vector2 screenMousePos = GUIUtil.getScreenMousePos();
if (!(Screen.height == screenh) || !(Screen.width == screenw) || helpf.chatLogStyle == null) // if resolution was changed, recalc positions
{
Console.WriteLine("change resolution");
screenh = Screen.height;
screenw = Screen.width;
helpf.chatLogStyle = (GUIStyle)chatLogStyleinfo.GetValue(helpf.target);
recto.setupPositions(helpf.chatisshown, sttngs.rowscale, helpf.chatLogStyle, helpf.cardListPopupSkin); // need it to calc fieldhight even if bothmenue=true
if ((helpf.bothmenue || (helpf.createAuctionMenu && !helpf.offerMenuSelectCardMenu)) && !helpf.generator)
{
recto.setupPositionsboth(helpf.chatisshown, sttngs.rowscale, helpf.chatLogStyle, helpf.cardListPopupSkin);
}
recto.setupsettingpositions(helpf.chatLogStyle, helpf.cardListPopupBigLabelSkin);
}
// delete picture on click!
if ((Input.GetMouseButtonUp(0) || Input.GetMouseButtonUp(1)) && crdvwr.clicked >= 3)
{
crdvwr.clearallpics();
}
//klick button AH
//Console.WriteLine("draw buttons");
if (LobbyMenu.drawButton(recto.ahbutton, "AH", helpf.lobbySkin) && !helpf.showtradedialog)
{
if (this.deckchanged)
{
App.Communicator.sendRequest(new LibraryViewMessage()); this.deckchanged = false;
}
if (helpf.bothmenue || helpf.createAuctionMenu)
{
recto.setupPositionsboth(helpf.chatisshown, sttngs.rowscale, helpf.chatLogStyle, helpf.cardListPopupSkin);
}
else
{
recto.setupPositions(helpf.chatisshown, sttngs.rowscale, helpf.chatLogStyle, helpf.cardListPopupSkin);
}
ahui.ahbuttonpressed();
}
// klick button Gen
if (LobbyMenu.drawButton(recto.genbutton, "Gen", helpf.lobbySkin) && !helpf.showtradedialog)
{
if (this.deckchanged)
{
App.Communicator.sendRequest(new LibraryViewMessage()); this.deckchanged = false;
}
recto.setupPositions(helpf.chatisshown, sttngs.rowscale, helpf.chatLogStyle, helpf.cardListPopupSkin);
genui.genbuttonpressed();
}
//klick settings-button
if (LobbyMenu.drawButton(recto.settingsbutton, "Settings", helpf.lobbySkin) && !helpf.showtradedialog)
{
recto.setupsettingpositions(helpf.chatLogStyle, helpf.cardListPopupBigLabelSkin);
setui.setbuttonpressed();
}
// draw ah oder gen-menu
if (helpf.inauchouse)
{
ahui.drawAH();
}
if (helpf.generator)
{
genui.drawgenerator();
}
if (helpf.settings)
{
setui.drawsettings();
}
GUI.color = Color.white;
GUI.contentColor = Color.white;
crdvwr.draw(); // drawing the card you have clicked
}
else if (info.target is Store && (info.targetMethod.Equals("showBuyMenu") || info.targetMethod.Equals("showSellMenu")))
{
//disable auc.house + generator
Store.ENABLE_SHARD_PURCHASES = true;
helpf.inauchouse = false;
helpf.generator = false;
helpf.settings = false;
helpf.showtradedialog = false;
helpf.makeOfferMenu = false;
helpf.offerMenuSelectCardMenu = false;
helpf.showtradedialog = false;
if (info.targetMethod.Equals("showSellMenu"))
{
this.deckchanged = false;
}
}
if (info.target is ChatRooms && info.targetMethod.Equals("ChatMessage"))
{
//get trademessages from chatmessages
RoomChatMessageMessage msg = (RoomChatMessageMessage)info.arguments[0];
if (msg.from != "Scrolls")
{
AuctionHouse.Instance.addAuctions(mssgprsr.GetAuctionsFromMessage(msg.text, msg.from, msg.roomName));
}
}
return;
}
public void UpdateRoom(RoomInfoMessage message)
{
cRoom.UpdateInfo(message);
}
public override bool WantsToReplace(InvocationInfo info)
{
if ((this.sttngs.waitForAuctionBot || this.sttngs.actualTrading) && info.target is InviteManager && info.targetMethod.Equals("handleMessage") && info.arguments[0] is TradeResponseMessage && (info.arguments[0] as TradeResponseMessage).to.name == this.twb.botname)
{ // return true if you are waiting for auctionbot
//because we dont want to display the trading-gui
return(true);
}
if (info.target is Store && info.targetMethod.Equals("OnGUI"))
{
// dont want to see the orginal store-interface in our AH
if (helpf.inauchouse || helpf.generator || helpf.settings)
{
return(true);
}
}
if (info.target is ArenaChat && info.targetMethod.Equals("handleMessage"))
{
Message msg = (Message)info.arguments[0];
if (msg is WhisperMessage)
{
WhisperMessage wmsg = (WhisperMessage)msg;
//dont want to see whisper messages from/to the auctionbot
if (this.sttngs.actualTrading && wmsg.from == this.twb.botname)
{
return(true);
}
if (this.sttngs.waitForAuctionBot && wmsg.toProfileName == this.twb.botname)
{
return(true);
}
if ((wmsg.text.Equals("to slow") || wmsg.text.Contains("dont fool me") || wmsg.text.Contains("there is not such an auction") || wmsg.text.Contains("auctionlimit reached")) && wmsg.from == this.twb.botname)
{
return(true);
}
}
if (msg is RoomChatMessageMessage)
{
RoomChatMessageMessage rem = (RoomChatMessageMessage)msg;
if ((this.sttngs.auctionScrollsMessagesCounter >= 1) && rem.roomName.StartsWith("trade-"))
{
if (this.sttngs.auctionScrollsMessagesCounter == 3)
{
this.sttngs.auctionScrollsMessagesCounter = 0;
}
return(true);
}
if (rem.text.StartsWith("auc parsertest"))
{
helpf.messegparsingtest(); return(true);
}
}
if (msg is RoomEnterMessage)
{
RoomEnterMessage rem = (RoomEnterMessage)msg;
if ((this.sttngs.waitForAuctionBot || this.sttngs.actualTrading) && rem.roomName.StartsWith("trade-"))
{
return(true);
}
}
if (msg is RoomInfoMessage)
{
RoomInfoMessage rem = (RoomInfoMessage)msg;
if ((this.sttngs.waitForAuctionBot || this.sttngs.actualTrading) && rem.roomName.StartsWith("trade-"))
{
return(true);
}
}
}
return(false);
}
public void ShowNewRoom(MessageHeader roomInfo)
{
RoomInfoMessage info = roomInfo as RoomInfoMessage;
Direction directions = (Direction)info.directions;
if (directions.HasFlag((Enum)Direction.North))
{
doors[0].SetActive(true);
}
else
{
doors[0].SetActive(false);
}
if (directions.HasFlag((Enum)Direction.East))
{
doors[1].SetActive(true);
}
else
{
doors[1].SetActive(false);
}
if (directions.HasFlag((Enum)Direction.South))
{
doors[2].SetActive(true);
}
else
{
doors[3].SetActive(false);
}
if (directions.HasFlag((Enum)Direction.West))
{
doors[3].SetActive(true);
}
else
{
doors[3].SetActive(false);
}
if (directions.HasFlag((Enum)Direction.West) && directions.HasFlag((Enum)Direction.South) && !directions.HasFlag((Enum)Direction.North) && !directions.HasFlag((Enum)Direction.East))
{
LeaveButton.SetActive(true);
}
else
{
LeaveButton.SetActive(false);
}
if (info.ContainsMonster == 1)
{
monsterSprite.gameObject.SetActive(true);
}
else
{
monsterSprite.gameObject.SetActive(false);
}
if (info.TreasureInRoom == 1)
{
treasureSprite.gameObject.SetActive(true);
}
else
{
treasureSprite.gameObject.SetActive(false);
}
PlayerManager.Instance.CurrentPlayer.Sprite.SetActive(true);
for (int i = 0; i < PlayerManager.Instance.Players.Count; i++)
{
if (info.OtherPlayerIDs.Contains(PlayerManager.Instance.Players[i].playerID))
{
PlayerManager.Instance.Players[i].Sprite.SetActive(true);
}
else
{
PlayerManager.Instance.Players[i].Sprite.SetActive(false);
}
}
}
