protected override void endGameHandler(UserThread client, CSMessage msg)
{
try
{
CSUser challenger = (CSUser)msg.get(MessageType.USER);
bool play = (bool)msg.get(MessageType.PLAY_GAME);
Object gameStuff = (Object)msg.get(MessageType.GAME_STUFF);
GameState state = GameState.LOST;
if (msg.get(MessageType.WIN_GAME) != null)
{
client.ClientUser.win();
state = GameState.WON;
}
else if (msg.get(MessageType.DRAW_GAME) != null)
{
client.ClientUser.draw();
state = GameState.DRAW;
}
client.ClientUser.incrementParties();
if (view.isOpened())
{
view.endGameHandler(client.ClientUser, challenger, state, play, gameStuff);
}
}
catch (Exception e)
{
log(Severiry.ERROR, "Controller[EndGame] - " + e.Message);
}
}
public override void handleMessage(CSMessage msg)
{
switch (msg.Type)
{
case MessageType.IN_GAME:
gameHandler(this, msg);
break;
case MessageType.USER_LIST:
userListHandler(this, msg);
break;
case MessageType.CLEAR:
clearHandler(this);
break;
case MessageType.CONNECTION:
connectionHandler(this, msg);
break;
case MessageType.START_GAME:
startGameHandler(this, msg);
break;
case MessageType.SEND_MSG:
receiveMsgHandler(this, msg);
break;
default:
break;
}
}
protected override void stopGameHandler(UserThread client, CSMessage msg)
{
try
{
ServerThread cl1 = (ServerThread)client;
if (cl1.playing())
{
ServerThread cl2 = cl1.CurrentChallenger;
if (cl2.playing())
{
msg.add(MessageType.USER, cl1.ClientUser);
cl2.send(msg);
}
cl2.CurrentChallenger = null;
cl1.CurrentChallenger = null;
if (view != null && view.isOpened())
{
view.removeParty(cl1.ClientUser, cl2.ClientUser);
}
broadcast();
}
}
catch (Exception e)
{
log(Severiry.ERROR, "Controller[STOPGAME] - " + e.Message);
}
}
public override void handleMessage(CSMessage msg)
{
if (playing())
{
currentChallenger.send(msg);
}
}
/// <summary>
/// Send a deconnection message to the server.
/// </summary>
private void deconnectionEvent()
{
CSMessage msg = new CSMessage(MessageType.DECONNECTION);
process.send(msg);
process.stop();
}
private void broadcast(CSMessage msg)
{
foreach (ServerThread cl in clients)
{
cl.send(msg);
}
}
/// <summary>
/// Handle the stop server event.
/// </summary>
private void stopServer()
{
CSMessage msg = new CSMessage(MessageType.DECONNECTION);
broadcast(msg);
foreach (UserThread cl in clients)
{
cl.stop();
}
clients.Clear();
if (ps.isStarted())
{
ps.stop();
}
if (view != null && view.isOpened())
{
view.clearAll();
view.updateState(ps.isStarted());
ServerThread.initCounter();
}
else
{
manager.close();
}
}
protected override void loginHandler(UserThread client, CSMessage msg)
{
try
{
if ((bool)msg.get(MessageType.STATE))
{
client.ClientUser = (CSUser)msg.get(MessageType.USER);
if (view.isOpened())
{
view.loginHandler(client.ClientUser);
}
}
else
{
if (view.isOpened())
{
view.showRegisterOption();
view.connectionHandler(client.ClientUser);
}
log(Severiry.ERROR, (string)msg.get(MessageType.ERROR));
}
}
catch (Exception e)
{
log(Severiry.ERROR, "Controller - " + e.Message);
}
}
/// <summary>
/// Send a game message to the server.
/// </summary>
/// <param name="gameStuff"></param>
private void gameEvent(Object gameStuff)
{
CSMessage tosend = new CSMessage(MessageType.IN_GAME).
add(MessageType.GAME_STUFF, gameStuff);
process.send(tosend);
}
/// <summary>
/// Send a message to the server.
/// </summary>
/// <param name="msg"></param>
private void sendMsgEvent(string msg)
{
CSMessage tosend = new CSMessage(MessageType.SEND_MSG).
add(MessageType.USER, process.ClientUser).
add(MessageType.MESSAGE, msg);
process.send(tosend);
}
/// <summary>
/// Send a game response message to the server.
/// </summary>
/// <param name="user"></param>
private void responseEvent(CSUser user)
{
CSMessage msg = new CSMessage(MessageType.CHALLENGING).
add(MessageType.RESPONSE, true).
add(MessageType.USER, user);
process.send(msg);
}
/// <summary>
/// Send a game request message to the server.
/// </summary>
/// <param name="user"></param>
private void requestEvent(CSUser user)
{
process.To = user;
CSMessage msg = new CSMessage(MessageType.CHALLENGING).
add(MessageType.REQUEST, true).
add(MessageType.USER, user);
process.send(msg);
}
protected override void endGameHandler(UserThread client, CSMessage msg)
{
try
{
ServerThread cl1 = (ServerThread)client;
ServerThread cl2 = cl1.CurrentChallenger;
CSMessage msg2 = new CSMessage(MessageType.END_GAME).
add(MessageType.GAME_STUFF, msg.get(MessageType.GAME_STUFF));
bool play = new Random().Next(2) != 0;
if (msg.get(MessageType.WIN_GAME) != null)
{
cl1.ClientUser.win();
msg2.add(MessageType.LOSE_GAME, true);
}
if (msg.get(MessageType.DRAW_GAME) != null)
{
cl1.ClientUser.draw();
cl2.ClientUser.draw();
msg2.add(MessageType.DRAW_GAME, true);
}
cl1.ClientUser.incrementParties();
cl2.ClientUser.incrementParties();
if (cl1.isLogged())
{
manager.update(cl1.ClientUser);
}
if (cl2.isLogged())
{
manager.update(cl2.ClientUser);
}
if (view != null && view.isOpened())
{
view.update(cl1.ClientUser.Login, cl1.ClientUser);
}
if (view != null && view.isOpened())
{
view.update(cl2.ClientUser.Login, cl2.ClientUser);
}
msg.add(MessageType.USER, cl2.ClientUser);
msg.add(MessageType.PLAY_GAME, play);
msg2.add(MessageType.USER, cl1.ClientUser);
msg2.add(MessageType.PLAY_GAME, !play);
cl1.send(msg);
cl2.send(msg2);
}
catch (Exception e)
{
log(Severiry.ERROR, "Controller[ENDGAME] - " + e.Message);
}
}
//--------------------------------------------------------------发送消息----------------------------------------------------------------------
/// <summary>
/// 发送注册测试账号
/// </summary>
/// <param name="_Account"></param>
/// <param name="_Password"></param>
public void SendRegisterTestAcountReq(string _Account, string _Password)
{
Login.RegisterTestAcountReq msg = new Login.RegisterTestAcountReq()
{
Account = "liwei1dao",
Password = "******",
};
CSMessage cmsg = new CSMessage();
cmsg.WriteMsg(1, 1, msg.ToByteArray());
ServiceModel.Instance.SendMessage(cmsg);
}
/// <summary>
/// 发送登陆测试账号的协议
/// </summary>
/// <param name="_Account"></param>
/// <param name="_Password"></param>
public void SendLoginTestAcountReq(string _Account, string _Password)
{
Login.LoginTestAcountReq msg = new Login.LoginTestAcountReq()
{
Account = _Account,
Password = _Password,
};
CSMessage cmsg = new CSMessage();
cmsg.WriteMsg(1, 1, msg.ToByteArray());
ServiceModel.Instance.SendMessage(cmsg);
}
/// <summary>
/// Send the abort message form the given user 'from' to the given user 'to'.
/// </summary>
/// <param name="to"></param>
/// <param name="from"></param>
private void abortRequest(CSUser to, CSUser from)
{
ServerThread cl = findClient(to);
if (cl != null)
{
CSMessage msg = new CSMessage(MessageType.CHALLENGING)
.add(MessageType.ABORT, true)
.add(MessageType.USER, from);
cl.send(msg);
cl.To = null;
}
}
//-------------------------------------------------------------接收消息------------------------------------------------------------------------
public void DealMessage(CSMessage msg)
{
LoggerHelper.Debug("收到服务器消息", msg.Head.MsgId);
switch (msg.Head.MsgId)
{
case 2: //注册测试账号回应
RegisterTestAcountRes(msg.Msg);
break;
case 4:
LoginTestAcountRes(msg.Msg);
break;
}
}
/// <summary>
/// Send an end game message to the server.
/// </summary>
/// <param name="gameStuff"></param>
/// <param name="state"></param>
private void endGameEvent(Object gameStuff, GameState state)
{
CSMessage msg = new CSMessage(MessageType.END_GAME);
msg.add(MessageType.GAME_STUFF, gameStuff);
if (state == GameState.WON)
{
msg.add(MessageType.WIN_GAME, true);
}
else
{
msg.add(MessageType.DRAW_GAME, true);
}
process.send(msg);
}
protected void gameHandler(UserThread client, CSMessage msg)
{
try
{
Object gameStuff = msg.get(MessageType.GAME_STUFF);
if (view.isOpened())
{
view.gameHandler(gameStuff);
}
}
catch (Exception e)
{
log(Severiry.ERROR, "Controller[InGame] - " + e.Message);
}
}
/// <summary>
/// Send a login message to the server.
/// </summary>
/// <param name="user"></param>
/// <param name="enrolled">True if the given user is registered</param>
/// <param name="save">True if the server should save the given user</param>
private void loginEvent(CSUser user, bool enrolled, bool save)
{
if (save)
{
manager.createUnique(user);
}
CSMessage msg = new CSMessage(MessageType.LOGIN);
msg.add(MessageType.USER, user);
if (enrolled)
{
msg.add(MessageType.REGISTRATION, true);
}
process.send(msg);
}
protected override void stopGameHandler(UserThread client, CSMessage msg)
{
try
{
CSUser user = (CSUser)msg.get(MessageType.USER);
if (view.isOpened())
{
view.stopGameHandler(user);
}
}
catch (Exception e)
{
log(Severiry.ERROR, "Controller[StopGame] - " + e.Message);
}
}
/// <summary>
/// Abort the party between the given users.
/// </summary>
/// <param name="client"></param>
/// <param name="user"></param>
private void abortRequest(UserThread client, CSUser user)
{
if (client.To != null)
{
ServerThread old;
if ((old = findClient(client.To)) != null)
{
CSMessage msg = new CSMessage(MessageType.CHALLENGING).
add(MessageType.ABORT, true).
add(MessageType.USER, user);
old.send(msg);
old.Froms.Remove(client.ClientUser);
}
}
}
protected void userListHandler(UserThread client, CSMessage msg)
{
try
{
List <CSUser> users = (List <CSUser>)msg.get(MessageType.USER_LIST);
users.Remove(client.ClientUser);
if (view.isOpened())
{
view.userListHandler(users);
}
}
catch (Exception e)
{
log(Severiry.ERROR, "Controller [UserList] - " + e.Message);
}
}
/// <summary>
/// Send an abort message to the server.
/// </summary>
/// <param name="user"></param>
/// <param name="sent"></param>
private void abortEvent(CSUser user, bool sent)
{
if (sent)
{
process.To = null;
}
else
{
process.Froms.Remove(user);
}
CSMessage msg = new CSMessage(MessageType.CHALLENGING).
add(MessageType.ABORT, true).
add(MessageType.USER, user);
process.send(msg);
}
protected void connectionHandler(UserThread client, CSMessage msg)
{
try
{
CSUser user = (CSUser)msg.get(MessageType.USER);
client.ClientUser = user;
if (view.isOpened())
{
view.connectionHandler(user);
}
}
catch (Exception e)
{
log(Severiry.ERROR, "Controller[Connection] - " + e.Message);
}
}
protected void receiveMsgHandler(UserThread client, CSMessage msg)
{
try
{
CSUser user = (CSUser)msg.get(MessageType.USER);
string message = (string)msg.get(MessageType.MESSAGE);
if (view.isOpened())
{
view.receiveMsgHandler(user, message);
}
}
catch (Exception e)
{
log(Severiry.ERROR, "Controller [ReceiveMsg] - " + e.Message);
}
}
protected void startGameHandler(UserThread client, CSMessage msg)
{
try
{
CSUser user = (CSUser)msg.get(MessageType.USER);
bool play = (bool)msg.get(MessageType.PLAY_GAME);
client.To = null;
client.Froms.Clear();
if (view.isOpened())
{
view.startGameHandler(user, play);
}
}
catch (Exception e)
{
log(Severiry.ERROR, "Controller[StartGame] - " + e.Message);
}
}
protected override void deconnectionHandler(UserThread client)
{
if (!ps.isStarted())
{
return;
}
try
{
ServerThread cl1 = (ServerThread)client;
if (cl1.playing())
{
ServerThread cl2 = cl1.CurrentChallenger;
CSMessage msg = new CSMessage(MessageType.STOP_GAME).add(MessageType.USER, cl1.ClientUser);
cl2.send(msg);
cl2.CurrentChallenger = null;
cl1.CurrentChallenger = null;
if (view != null && view.isOpened())
{
view.removeParty(cl1.ClientUser, cl2.ClientUser);
}
}
else
{
abortRequest(client, client.ClientUser);
foreach (CSUser u in client.Froms)
{
abortRequest(u, client.ClientUser);
}
}
if (view != null && view.isOpened())
{
view.delete(cl1.ClientUser);
}
cl1.stop();
clients.Remove(cl1);
broadcast();
}
catch (Exception e)
{
log(Severiry.ERROR, "Controller[DECONNECTION] - " + e.Message);
}
}
// Receives and returns messages from server in JSON form.
public void SendSocketMessage(CSMessage message)
{
byte error;
byte[] buffer = new byte[1024];
Stream stream = new MemoryStream(buffer);
BinaryFormatter formatter = new BinaryFormatter();
message.setPlayer(player); // set player value to client's player number for validation
string str = JsonUtility.ToJson(message);
formatter.Serialize(stream, str);
NetworkTransport.Send(socketId, connectionId, channelId, buffer, buffer.Length, out error);
if ((NetworkError)error != NetworkError.Ok)
{
Debug.Log("Error sending message: " + ((NetworkError)error).ToString());
}
}
public Text messageDisplay; // FOR DEBUGGING PURPOSES ONLY
// Checks for received messages and displays their contents in a text display.
void Update() //make do while loop - while received != null?
{
string received = null;
do
{
received = ReceiveMessage();
if (received != null)
{
CSMessage message = JsonUtility.FromJson <CSMessage>(received);
if (!revUserList[message.type].Contains(message.player)) // player not authorized to send message
{
Debug.Log("Illegal " + message.type.ToString() + " message received from player " + message.player);
return;
}
switch (message.type)
{
case MType.Init:
handleInit(received);
break;
case MType.Pilot:
handlePilot(received);
break;
case MType.Nav:
handleNav(received);
break;
default:
Debug.Log("Invalid message type!");
break;
}
}
} while (received != null);
}
