battlearray_client/Assets/Scripts/Net/Server/BAServer.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using Sfs2X.Entities.Data;

public class BAServer
{
	public enum ConnectionType
	{
		Local,
		Remote,

	}

	private MessageManager.MessageCallBackDelegate msgManCallBack;

	private BARoom currentRoom;
	private List<Message> messageStack;
	private ResponseWaiter resWaiter;

	private IConnection connection;
	private IConnection localConnection;
	private IConnection remoteConnection;

	public BAServer ()
	{
		remoteConnection = new SFSConnection();
		localConnection = new LocalConnection();

		messageStack = new List<Message>();
		resWaiter = new ResponseWaiter();

		SetConnection (ConnectionType.Remote);
	}

	public void SetMsgManCallBack(MessageManager.MessageCallBackDelegate callBack)
	{
		this.msgManCallBack = callBack;
	}

	public void SetConnection(ConnectionType type)
	{
		IConnection newConnection = null;
		switch(type)
		{
		case ConnectionType.Local:
			newConnection = localConnection;
			break;
		case ConnectionType.Remote:
			newConnection = remoteConnection;
			break;
		}

		if (connection != null) {
			connection.SetResponseMessageCallBack (null);

//			if(connection.IsConnected && connection != newConnection)
//			{
//				connection.Disconnect();
//			}
		}

		connection = newConnection;
		connection.SetResponseMessageCallBack (OnRemoteCallBack);
	}

	public void Connect()
	{
		if(!connection.IsConnected)
			connection.Connect ();
	}

	public bool IsConnected()
	{
		return connection.IsConnected;
	}

	public void EnterBase()
	{
		resWaiter.StartWait();
//		SetConnection (ConnectionType.Local);

		Message msg = new Message(Command.EnterBase, new SFSObject());
		Debuger.Log ("Send : ["+msg.cmd+"]"+msg.data.GetDump());
//		connection.SendMessage(msg);
		DealEnterBase(msg);
	}

	private void DealEnterBase(Message msg)
	{
		string mapName = MapData.MapID.Base.ToString ();

		ISFSArray arr = new SFSArray ();

		ISFSObject myObj = new SFSObject ();
		myObj.PutUtfString (UserSFSObjectLabel.ID, Session.myUserId.ToString());
		myObj.PutInt (UserSFSObjectLabel.TEAM_ID, TeamUtil.Team.Blue.GetHashCode());
		myObj.PutUtfString (UserSFSObjectLabel.NICK, WWW.EscapeURL(Session.GetInstance().myUserData.nick));
		arr.AddSFSObject(myObj);

//		ISFSObject oppObj = new SFSObject ();
//		oppObj.PutInt ("u", -1);
//		oppObj.PutInt ("t", TeamUtil.Team.Red.GetHashCode());
//		oppObj.PutUtfString ("i", "-1");
//		oppObj.PutUtfString ("n", RandomNPCNick());
//		arr.AddSFSObject (oppObj);

		ISFSObject data = new SFSObject();
		data.PutUtfString("m", mapName);
		data.PutUtfString ("c", Session.myUserId.ToString());
		data.PutBool ("s", true);
		data.PutSFSArray("a", arr);

		Message callBackMsg = new Message(Command.SearchRoom, data);
		OnRemoteCallBack(callBackMsg.GetMessagePackage());
	}

	public void SearchRoom()
	{
		resWaiter.StartWait();
//		SetConnection (ConnectionType.Local);

		ISFSObject data = new SFSObject();
		Message msg = new Message(Command.SearchRoom, data);
		Debuger.Log ("Send : ["+msg.cmd+"]"+msg.data.GetDump());
		connection.SendMessage(msg);
	}


	private void HandleReplay()
	{
		ISFSObject msg = ReplayManager.GetInstance ().GetRecord ();
		if (msg != null)
			RoomHandleResponse (msg);
	}


	private void SetRoom(MapData.MapID mapId, ISFSArray arr, int myUserId)
	{
		if (currentRoom != null)
			currentRoom.Dispose ();

		switch(mapId)
		{
		case MapData.MapID.Base:
			currentRoom = new BaseRoom(this);
			break;
		case MapData.MapID.Challenge:
			currentRoom = new ChallengeRoom(this);
			break;
		case MapData.MapID.Defense:
			currentRoom = new DefenceRoom (this);
			break;
		case MapData.MapID.Flag:
			currentRoom = new FlagRoom (this);
			break;
		}

		if(currentRoom == null)
			throw new System.Exception("Illegal Map id["+mapId.ToString()+"]");

		currentRoom.AddUser(arr);
		currentRoom.handlerCallBack = RoomHandleResponse;

		if (currentRoom.isRecord)
			ReplayManager.GetInstance ().StartRecord ();
	}

	private void UpdateRoom()
	{
		if(currentRoom != null)
			currentRoom.Update();
	}

	public void RoomHandleResponse(ISFSObject msg)
	{
		if (currentRoom != null && currentRoom.isRecord) {
			//Did not ignore zone message yet
			ReplayManager.GetInstance ().CheckRecord (msg);
		}

		Debuger.Log ("Recieve : "+msg.GetDump());

		if(msgManCallBack != null)
			msgManCallBack(msg);
	}




	public void Send(ISFSObject msg)
	{
		Message message = new Message (msg);
		Send (message);
	}

	public void Send(Message msg)
	{
		if(currentRoom == null)
			return;

		//TODO add to message trace
		Debuger.Log ("Send : ["+msg.cmd+"]"+msg.data.GetDump());

		for(int i=0; i<messageStack.Count; i++)
		{
			Message existMsg = messageStack[i];
			if(existMsg.cmd == msg.cmd && existMsg.AttempOverride(msg))
			{
				return;
			}
		}

		if(messageStack.Count < 50)
			messageStack.Add(msg);
	}




	private void CheckMessageStack()
	{
		if(resWaiter.isWaiting || messageStack.Count == 0)
			return;

		resWaiter.StartWait();

		int unknowMsg = 0;
		int zoneMsg = 1;
		int roomMsg = 2;

		int msgType = unknowMsg;

		ISFSArray arr = new SFSArray();
		for(int i=0; i<messageStack.Count; i++)
		{
			Message m = messageStack[i];
			int tempMsgType = Command.IsRoomExtensionCommand (m.cmd) ? roomMsg : zoneMsg;

			if (msgType == unknowMsg) 
			{
				msgType = tempMsgType;
			}
			else if(msgType != tempMsgType)
			{
				continue;
			}

			ISFSObject obj = new SFSObject();
			obj.PutUtfString(Message.LABEL_COMMAND, m.cmd);
			obj.PutSFSObject(Message.LABEL_DATA, m.data);
			arr.AddSFSObject (obj);

			messageStack.RemoveAt (i);
			i--;
		}

		ISFSObject data = new SFSObject();
		data.PutSFSArray(Message.LABEL_DATA_ARRAY, arr);

		Message msg = new Message(Command.MessageArray, data);
		msg.isRoomMsg = (msgType == roomMsg);
		connection.SendMessage(msg);
	}


	private void OnRemoteCallBack(ISFSObject msg)
	{
		string cmd = msg.GetUtfString(Message.LABEL_COMMAND);
		ISFSObject data = msg.GetSFSObject(Message.LABEL_DATA);

		if(cmd == Command.MessageArray)
		{
			int sender = StringUtil.ToInt(data.GetUtfString(Message.LABEL_SENDER));
			int timeStamp = data.GetInt (Message.LABEL_TIMESTAMP);
			if(currentRoom.IsMyUserId(sender))
				resWaiter.StopWait();

			if (sender == currentRoom.aiTaker)
				currentRoom.AITakerMessageGot ();

			ISFSArray arr = data.GetSFSArray(Message.LABEL_DATA_ARRAY);
			for(int i=0; i<arr.Count; i++)
			{
				ISFSObject m = arr.GetSFSObject(i);
				currentRoom.HandleMassage(m, sender, timeStamp);
			}
		}
		else if(cmd == Command.SearchRoom)
		{
			resWaiter.StopWait();

			string mapId = data.GetUtfString("m");
			int aiTaker = StringUtil.ToInt(data.GetUtfString ("c"));
			bool isStarted = data.GetBool ("s");
			ISFSArray arr = data.GetSFSArray("a");
			SetRoom(MapData.GetMapIdByName(mapId), arr, connection.myUserId);
			currentRoom.aiTaker = aiTaker;
			RoomHandleResponse(msg);
		}
	}


	public void Update()
	{
		connection.ProcessEvents();
		if(ReplayManager.GetInstance().IsReplaying())
		{
			HandleReplay ();
		}
		else
		{
			UpdateRoom();
			CheckMessageStack();
		}
	}


	public void Disconnect()
	{
		if(connection != null)
			connection.Disconnect();
	}








	public bool IsWaiting()
	{
		return resWaiter.isWaiting;
	}

	public class ResponseWaiter
	{
		private bool _isWaiting;
		private float startTime;

		public void StartWait()
		{
			_isWaiting = true;
			startTime = GameTime.realtimeSinceStartup;
		}

		public void StopWait()
		{
			_isWaiting = false;
		}

		public bool isWaiting
		{
			get{
				return _isWaiting;
			}
		}

		public float timeWaited
		{
			get{
				return _isWaiting ? GameTime.realtimeSinceStartup - startTime : 0;
			}
		}

	}
}