public virtual void OnNoticeReceived(AVIMNotice notice)
{
var response = new PlayResponse(notice.RawData);
if (response.IsSuccessful)
{
if (Done != null)
{
Done(Command, response);
}
}
//Play.LogCommand(Command, null, Play.CommandType.WebSocket);
//Play.LogCommand(null, response, Play.CommandType.WebSocket);
if (EventCode != PlayEventCode.None)
{
var next = PlayStateMachine.Next(EventCode, response);
if (response.IsSuccessful)
{
Play.InvokeEvent(next);
}
else
{
Play.InvokeEvent(next, response.ErrorCode, response.ErrorReason);
}
}
Play.UnsubscribeNoticeReceived(this);
}
/// <summary>
/// Rejoin the room.
/// </summary>
/// <param name="roomName">Room name.</param>
public static void RejoinRoom(string roomName = null)
{
if (string.IsNullOrEmpty(roomName))
{
if (Play.Room == null)
{
Play.InvokeEvent(PlayEventCode.OnJoinRoomFailed, "-100", "can NOT join a room with the name is NULL.");
return;
}
roomName = Play.Room.Name;
}
var joinRoomCommand = new PlayCommand()
{
Body = new Dictionary <string, object>()
{
{ "cmd", "conv" },
{ "op", "add" },
{ "cid", roomName },
{ "rejoin", true },
},
};
RunSocketCommand(joinRoomCommand, done: DoRejoinRoom);
}
internal static void MasterClientSwitch(string handler, string master)
{
//var handledPlayer = GetPlayer(handler);
var newMasterPlayer = GetPlayer(master);
Play.InvokeEvent(PlayEventCode.OnMasterClientSwitched, newMasterPlayer);
}
public override void OnNoticeReceived(AVIMNotice notice)
{
var propObjs = notice.RawData["props"] as List <object>;
if (propObjs != null)
{
propObjs.Every(metaData =>
{
var prop = metaData as IDictionary <string, object>;
if (prop != null)
{
var clientId = prop["clientId"] as string;
if (clientId != null)
{
var player = Play.Room.GetPlayer(clientId);
var customProperties = prop["customProperties"] as IDictionary <string, object>;
if (player != null)
{
player.CustomPropertiesMetaData.Merge(customProperties);
}
Play.InvokeEvent(PlayEventCode.OnPlayerCustomPropertiesChanged, player, customProperties.ToHashtable());
}
}
});
}
}
internal static void DoRejoinRoom(PlayCommand request, PlayResponse response)
{
if (!response.IsSuccessful)
{
Play.InvokeEvent(PlayEventCode.OnJoinRoomFailed, response.ErrorCode, response.ErrorReason);
return;
}
var room = GetRoomWhenGet(request, response);
Play.InvokeEvent(PlayEventCode.OnJoiningRoom);
ConnectRoom(room, true);
}
internal static void RunHttpCommand(PlayCommand command, PlayEventCode eventCode = PlayEventCode.None, Action <PlayCommand, PlayResponse> done = null)
{
if (eventCode != PlayEventCode.None)
{
Play.InvokeEvent(eventCode);
}
var httpRequest = command.HttpEncode;
Play.ExecuteHttp(httpRequest, (tuple =>
{
int statusCode = (int)HttpStatusCode.BadRequest;
IDictionary <string, object> body = new Dictionary <string, object>();
try
{
body = Json.Parse(tuple.Item2) as IDictionary <string, object>;
statusCode = (int)tuple.Item1;
}
catch
{
}
var response = new PlayResponse()
{
Body = body as IDictionary <string, object>,
StatusCode = (int)tuple.Item1
};
if (response.IsSuccessful)
{
LogCommand(command, response);
if (done != null)
{
done(command, response);
}
}
else
{
LogCommand(command, response, printer: ErrorLogger);
}
if (eventCode != PlayEventCode.None)
{
var next = PlayStateMachine.Next(eventCode, response);
if (response.IsSuccessful)
{
Play.InvokeEvent(next);
}
else
{
Play.InvokeEvent(next, response.ErrorCode, response.ErrorReason);
}
}
}));
}
internal static void ConnectRoom(PlayRoom room, bool isRejoin = false)
{
lock (roomLock)
{
DoConnectToGameSever(room, () =>
{
peer.SessionRoomJoin(room, isRejoin: isRejoin, roomJoined: (roomm, response) =>
{
DoSetRoomProperties(roomm, response);
Play.Room = roomm;
Play.InvokeEvent(PlayEventCode.OnJoinedRoom);
});
});
}
}
/// <summary>
///
/// </summary>
public void ResetEnumerators()
{
listEnumerator = new PlayQueryEnumerator <List <PlayRoom> >();
listEnumerator.Command = new PlayCommand()
{
RelativeUrl = "/rooms",
Method = "GET",
UrlParameters = new Dictionary <string, object>()
};
listEnumerator.Limit = 20;
listEnumerator.Decoder = (resp) =>
{
if (resp.IsSuccessful)
{
var roomMetaDataObjs = resp.Body["rooms"] as List <object>;
if (roomMetaDataObjs != null)
{
var result = roomMetaDataObjs.Select(roomMetaDataObj =>
{
var room = new PlayRoom();
IDictionary <string, object> roomMetaData = roomMetaDataObj as IDictionary <string, object>;
room.MergeFromServer(roomMetaData);
return(room);
});
return(result.ToList());
}
}
else
{
Play.InvokeEvent(PlayEventCode.OnFetchRoomListFailed, resp.ErrorCode, resp.ErrorReason);
}
return(new List <PlayRoom>());
};
listEnumerator.Before = () =>
{
Play.InvokeEvent(PlayEventCode.OnFetchingRoomList);
};
listEnumerator.Callback = (rooms) =>
{
AddRooms(rooms);
Play.InvokeEvent(PlayEventCode.OnFetchedRoomList, rooms);
};
}
/// <summary>
/// create a room with config and name.
/// </summary>
/// <param name="roomConfig">config of Room</param>
/// <param name="roomName">name of Room</param>
public static void CreateRoom(PlayRoom.RoomConfig roomConfig, string roomName = null)
{
var createRoomCommand = new PlayCommand()
{
Body = new Dictionary <string, object>()
{
{ "cmd", "conv" },
{ "op", "start" },
},
};
if (string.IsNullOrEmpty(roomName))
{
roomName = PlayRoom.RandomRoomName(24);
}
RunSocketCommand(createRoomCommand, done: (request, response) =>
{
// get game server address from game router
var roomRemoteSecureAddress = response.Body["secureAddr"] as string;
var roomRemoteAddress = response.Body["addr"] as string;
// open websocket connection with game server
DoConnectToGameSever(roomRemoteSecureAddress, () =>
{
Play.InvokeEvent(PlayEventCode.OnCreatingRoom);
// create room at game server
peer.SessionCreateRoom(roomName, roomConfig, (room) =>
{
Play.Room = room;
Play.InvokeEvent(PlayEventCode.OnCreatedRoom);
Play.InvokeEvent(PlayEventCode.OnJoinedRoom);
});
});
});
}
internal void SessionCreateRoom(string roomName, PlayRoom.RoomConfig roomConfig, Action <PlayRoom> roomCreated = null)
{
IDictionary <string, object> body = new Dictionary <string, object>();
if (roomConfig.CustomRoomProperties != null)
{
body.Add("attr", roomConfig.CustomRoomProperties.ToDictionary());
}
if (roomConfig.MaxPlayerCount > 0 && roomConfig.MaxPlayerCount != PlayRoom.DefaultMaxPlayerCount)
{
body.Add("maxMembers", roomConfig.MaxPlayerCount);
}
if (roomConfig.EmptyTimeToLive > 0 && roomConfig.EmptyTimeToLive != PlayRoom.DefaultMaxEmptyTimeToLive)
{
body.Add("emptyRoomTtl", roomConfig.EmptyTimeToLive);
}
if (roomConfig.PlayerTimeToKeep > 0 && roomConfig.PlayerTimeToKeep != PlayRoom.DefaultMaxKeepPlayerTime)
{
body.Add("playerTtl", roomConfig.PlayerTimeToKeep);
}
if (roomConfig.ExpectedUsers != null)
{
body.Add("expectMembers", roomConfig.ExpectedUsers);
}
if (!roomConfig.IsVisible)
{
body.Add("visible", roomConfig.IsVisible);
}
if (!roomConfig.IsOpen)
{
body.Add("open", roomConfig.IsOpen);
}
if (roomConfig.LobbyMatchKeys != null)
{
body.Add("lobbyAttrKeys", roomConfig.LobbyMatchKeys);
}
body.Add("cmd", "conv");
body.Add("op", "start");
body.Add("cid", roomName);
var createCommand = new PlayCommand()
{
Body = body
};
Play.RunSocketCommand(createCommand, done: (req, response) =>
{
if (response.IsSuccessful)
{
var room = new PlayRoom(roomConfig, roomName);
Play.DoSetRoomProperties(room, response);
if (roomCreated != null)
{
roomCreated(room);
}
}
else
{
Play.InvokeEvent(PlayEventCode.OnCreateRoomFailed, response.ErrorCode, response.ErrorReason);
}
});
}
private static void RoomConnection_OnClosed(int arg1, string arg2, string arg3)
{
Play.InvokeEvent(PlayEventCode.OnDisconnected);
Log("sokcet closed: " + arg1 + arg2 + arg3);
}
internal static void PlayerLeft(Player player)
{
Play.InvokeEvent(PlayEventCode.OnPlayerLeftRoom, player);
}
internal static void PlayerRejoined(Player player)
{
Play.InvokeEvent(PlayEventCode.OnPlayerReconnectedRoom, player);
}
internal static void PlayerOffline(Player player)
{
player.IsInactive = true;
Play.InvokeEvent(PlayEventCode.OnPlayerActivityChanged, player);
}
internal static void NewPlayerJoined(Player newPlayer)
{
Play.InvokeEvent(PlayEventCode.OnNewPlayerJoinedRoom, newPlayer);
}
internal static void RoomUpdated(IDictionary <string, object> transformation)
{
Play.Room.Updated(transformation);
Play.InvokeEvent(PlayEventCode.OnRoomCustomPropertiesUpdated, transformation.ToHashtable());
}