public virtual void onSnapshot(BinaryReader message)
        {
            List <Object> objects = new List <Object>();

            objects.Add(message);
            int numPlayers = message.ReadInt16();

            for (int i = 0; i < numPlayers; i++)
            {
                int clientId = message.ReadInt16();
                JesterLogger.log("clientId: " + clientId);
                ActionBasedGameLocation location = new ActionBasedGameLocation();
                location.clientId = clientId;
                location.posX     = readFloat(message);
                location.posY     = readFloat(message);
                location.posZ     = readFloat(message);
                location.rotX     = readFloat(message);
                location.rotY     = readFloat(message);
                location.rotZ     = readFloat(message);
                objects.Add(location);
            }
            Event event_ = new Event(ActionGameProtocol.SNAPSHOT, objects);

            eventQueue.addFunction(event_);
        }
Example #2
0
        private Client updateSingleClient(BinaryReader message)
        {
            int clientId = message.ReadInt16();

            JesterLogger.log("Update connected clients, clientId: " + clientId);
            if (thisClient == null || thisClient.getId() != clientId)
            {
                int count = message.ReadInt16();
                JesterLogger.log("count bytes: " + count);
                byte[]   strBytes = message.ReadBytes(count);
                Encoding enc      = new UTF8Encoding(true, true);
                string   clientServerObjectName = enc.GetString(strBytes);
                JesterLogger.log("Update connected clients, len: " + clientServerObjectName.Length + ", name&email: " + clientServerObjectName);
                int clientStatus = message.ReadByte();
                JesterLogger.log("_Update connected clients, status: " + clientStatus);
                //string[] nameemail = clientServerObjectName.Split('&');
                //string name = nameemail[0];
                //string email = nameemail[1];
                string name  = clientServerObjectName;
                string email = clientServerObjectName;
                JesterLogger.log("updateOnClientEnter 0");
                Client client = new Client(clientId, name, email, clientStatus);
                clientsMap.Add(clientId, client);
                JesterLogger.log("updateOnClientEnter 1");
                updateOnClientEnter(client, message);
                JesterLogger.log("updateOnClientEnter 2");
                return(client);
            }
            else
            {
                return(null);
            }
        }
        public override bool callFunction(int fnc, BinaryReader message, CompletionCallback callback = null)
        {
            bool ret = base.callFunction(fnc, message, callback);

            JesterLogger.log("ActionGameSpace.callFunction, ret: " + ret + ", fnc: " + fnc);

            if (ret)
            {
                return(true);
            }

            switch (fnc)
            {
            case ActionGameProtocol.SNAPSHOT:
                JesterLogger.log("ActionGameProtocol.Snapshot");
                onSnapshot(message);
                return(true);

            case ActionGameProtocol.ACTION:
                JesterLogger.log("ActionGameProtocol.Action");
                onAction(message);
                return(true);

            case ActionGameProtocol.MOVE:
                JesterLogger.log("ActionGameProtocol.Move");
                onMove(message);
                return(true);
            }

            return(false);
        }
 public void Login(string userName, string password, string host, int port)
 {
     this.userName = userName;
     this.password = password;
     client        = new SimpleClient(this);
     JesterLogger.log("EventsHandler.Login(), userName: "******", host: " + host + ", port: " + port);
     client.login(host, port);
 }
Example #5
0
        protected void updateConnectedClients(BinaryReader message)
        {
            int numClients = message.ReadInt16();

            JesterLogger.log("Update connected clients, numclients: " + numClients);
            for (int i = 0; i < numClients; i++)
            {
                updateSingleClient(message);
            }
        }
Example #6
0
        protected void putGameRobotEnter(BinaryReader message)
        {
            RobotInterface robotPlayer = createRobot(message);

            JesterLogger.log("GameSpace.putGameRobotEnter, getRobotIndex(): " + robotPlayer.getRobotIndex());
            robotsMap.Add(robotPlayer.getRobotIndex(), robotPlayer);

            List <Object> objects = new List <Object>();

            objects.Add(robotPlayer);
            eventQueue.addFunction(new Event(GameProtocol.GAME_ROBOT_ENTER, objects));
        }
Example #7
0
        // Input events -------------------------------------------------------

        public void channelJoin(Channel channel)
        {
            JesterLogger.log("Channel join: " + channel.getName());
            channelsMap.Add(channel.getName(), channel);

            // chat interface
            if (chatInterface != null && channel.getName().ToLower().Contains("chat"))
            {
                channel.putMessageInterface(chatInterface);
                chatInterface.onJoinChannel(channel);
            }
        }
        public void LoginFailed(string reason)
        {
            loggedIn = false;
            JesterLogger.log("EventsHandler.loginFailed, reason: " + reason);

            login.loginFailed(reason);
            //List<int> keys = new List<int>(eventListenersMap.Keys);
            //foreach (int key in keys)
            //{
            //    EventListener eventListener = eventListenersMap[key];
            //    eventListener.loginFailed(reason);
            //}
        }
        public void Disconnected(bool forced, string message)
        {
            JesterLogger.log("EventsHandler.Disconnected, forced: " + forced + ", message: " + message);
            loggedIn = false;

            List <int> keys = new List <int>(eventListenersMap.Keys);

            foreach (int key in keys)
            {
                EventListener eventListener = eventListenersMap[key];
                eventListener.disconnected(forced, message);
            }
        }
        public void LoggedIn(byte[] reconnectKey)
        {
            loggedIn = true;
            JesterLogger.log("EventsHandler.LoggedIn()");

            login.loginSuccess(reconnectKey);

            //List<int> keys = new List<int>(eventListenersMap.Keys);
            //foreach (int key in keys)
            //{
            //    EventListener eventListener = eventListenersMap[key];
            //    eventListener.loginSuccess(reconnectKey);
            //}
        }
        public void putEventListener(EventListener eventListener)
        {
            JesterLogger.log("EventsHandler.putEventListener(), eventListener: " + eventListener + ",,id: " + eventListener.getId());
            int id = eventListener.getId();

            if (!eventListenersMap.ContainsKey(id))
            {
                eventListenersMap.Add(id, eventListener);
            }
            else
            {
                JesterLogger.log("EventsHandler.putEventListener() WARNING, adding event as listener again!");
            }
        }
        public ClientChannelListener JoinedChannel(ClientChannel clientChannel)
        {
            JesterLogger.log("EventsHandler.JoinedChannel, channelName: " + clientChannel.Name);
            Channel channel = new Channel(clientChannel);

            List <int> keys = new List <int>(eventListenersMap.Keys);

            foreach (int key in keys)
            {
                EventListener eventListener = eventListenersMap[key];
                eventListener.channelJoin(channel);
            }
            return(channel);
        }
Example #13
0
        protected override void updateOnClientEnter(Client client, BinaryReader additionalInitInfo)
        {
            JesterLogger.log("GameSpace.updateOnClientEnter");
            GamePlayer player = createGamePlayer(client, additionalInitInfo);

            if (thisPlayer == null)
            {
                this.thisPlayer = player;
            }

            client.addPlayer(player);
            gamePlayersMap.Add(player.getClient().getId(), player);

            base.updateOnClientEnter(client, additionalInitInfo);
        }
        public void sendEnterMatchMaker(int matchMakerId = -1)
        {
            JesterLogger.log("LoginSpace.sendEnterLobby(), lobbyId: " + matchMakerId);

            MemoryStream m  = new MemoryStream();
            BinaryWriter bw = new BinaryWriter(m);
            int          idMessageReceiver = -1; // On Server by default LoginMessageReceiver id == -1

            bw.Write(idMessageReceiver);
            byte event_ = LoginProtocol.ENTER_MATCH_MAKER;

            bw.Write(event_);
            bw.Write(matchMakerId);
            clientSession.sessionSend(m);
        }
 public void sessionSend(MemoryStream message)
 {
     byte[] bytesMessage = null;
     //byte[] buffer = new byte[1024];
     //using (MemoryStream ms = new MemoryStream())
     //{
     //    int read;
     //    while ((read = message.Read(buffer, 0, buffer.Length)) > 0)
     //    {
     //        ms.Write(buffer, 0, read);
     //    }
     //    bytesMessage = ms.ToArray();
     //}
     bytesMessage = message.ToArray();
     JesterLogger.log("EventsHandler.sessionSend(), Count: " + bytesMessage.Length);
     client.SessionSend(bytesMessage);
 }
        public void notifyCurrentPlayer(Client client, CompletionCallback callback)
        {
            JesterLogger.log("TurnGameSpace.notifyCurrentPlayer");
            int id = getId();

            JesterLogger.log("getId(): " + id);
            GamePlayer gamePlayer = client.getPlayer(id);

            JesterLogger.log("GamePlayer: " + gamePlayer);
            JesterLogger.log("GamePlayer2: " + gamePlayer.getName());
            this.currentPlayer = (TurnGamePlayer)gamePlayer;
            JesterLogger.log("GamePlayer3: " + this.currentPlayer);
            JesterLogger.log("TurnGameSpace.notifyCurrentPlayer, currentPlayer: " + currentPlayer.getId());

            List <Object> objects = new List <Object>();

            objects.Add(client);
            eventQueue.addFunction(new Event(TurnGameProtocol.NOTIFY_CURRENT_PLAYER, objects));
        }
        public void notifyCurrentPlayerRobot(RobotInterface robot, CompletionCallback callback)
        {
            JesterLogger.log("TurnGameSpace.notifyCurrentPlayerRobot(), robot: " + robot);
            TurnGamePlayer robotPlayer = (TurnGamePlayer)robot;

            if (robotPlayer == null)
            {
                throw new Exception("NullPointerException()");
            }
            JesterLogger.log("TurnGameSpace.notifyCurrentPlayerRobot(), robot:2");
            this.currentPlayer = robotPlayer;
            JesterLogger.log("TurnGameSpace.notifyCurrentPlayerRobot(), robot:3");
            List <Object> objects = new List <Object>();

            objects.Add(robot);
            JesterLogger.log("TurnGameSpace.notifyCurrentPlayerRobot(), robot:4");
            eventQueue.addFunction(new Event(TurnGameProtocol.NOTIFY_CURRENT_PLAYER_ROBOT, objects));
            JesterLogger.log("TurnGameSpace.notifyCurrentPlayerRobot() out");
        }
        public bool isThisCurrentPlayer()
        {
            if (currentPlayer == null)
            {
                return(false);
            }

            if (currentPlayer.isRobot())
            {
                JesterLogger.log("TurnGameSpace.isThisCurrentPlayer(): " + currentPlayer.isRobot());
                return(false);
            }

            int id_     = thisPlayer.getClient().getId();
            int currId_ = currentPlayer.getClient().getId();

            JesterLogger.log("TurnGameSpace.isThisCurrentPlayer(), id: " + id_ + ", currId: " + currId_);
            return(id_ == currId_);
        }
Example #19
0
        public GamePlayer getPlayerWithClientId(int clientId)
        {
            JesterLogger.log("GameSpace.getPlayerWithClientId, clientId: " + clientId);
            JesterLogger.log("GameSpace.getPlayerWithClientId, clientsMapCount: " + clientsMap.Count);

            int        idx  = 0;
            List <int> list = new List <int>(clientsMap.Keys);

            foreach (int k in list)
            {
                JesterLogger.log("Key: " + k + ", idx: " + idx++);
            }

            Client client = clientsMap[clientId];

            JesterLogger.log("GameSpace.getPlayerWithClientId, client: " + client);
            GamePlayer gamePlayer = client.getPlayer(getId());

            JesterLogger.log("GameSpace.getPlayerWithClientId, gamePlayer: " + gamePlayer);
            return(gamePlayer);
        }
Example #20
0
        protected virtual void updateOnClientEnter(Client client, BinaryReader additionalInitInfo)
        {
            JesterLogger.log("updateoncliententer, space, id: " + id);
            if (thisClient == null)
            {
                thisClient = client;
                if (chatInterface != null)
                {
                    chatInterface.setClient(thisClient);
                }
            }

            if (parentSpace != null)
            {
                parentSpace.onChildEnter(this, client);
            }

            List <object> objects = new List <object>();

            objects.Add(client);
            eventQueue.addFunction(new Event(SpaceProtocol.ENTER, objects));
        }
        public void ReceivedMessage(byte[] message)
        {
            JesterLogger.log("EventsHandler.ReceivedMessage_, message: " + message.Length);
            MemoryStream m = new MemoryStream();

            m.SetLength(message.Length);

            BinaryWriter bw = new BinaryWriter(m);

            bw.Write(message);
            bw.Flush();
            m.Position = 0;

            JavaBinaryReader br = new JavaBinaryReader(m);
            int id  = br.ReadInt32();
            int fnc = br.ReadByte();

            JesterLogger.log("EventsHandler.ReceivedMessage, fnc: " + fnc + ", id: " + id);

            EventListener eventListener = eventListenersMap[id];

            JesterLogger.log("EventsHandler.ReceivedMessage, eventListener: " + eventListener.getId());
            eventListener.callFunction(fnc, br);
        }
Example #22
0
        public override bool callFunction(int fnc, BinaryReader message, CompletionCallback callback = null)
        {
            bool ret = base.callFunction(fnc, message, callback);

            if (ret)
            {
                return(true);
            }

            JesterLogger.log("GameSpace.function: " + fnc);

            switch (fnc)
            {
            case GameProtocol.GAME_PLAYER_GIVE_UP:
                List <Object> objects    = new List <Object>();
                int           clientId   = message.ReadInt16();
                GamePlayer    gamePlayer = getPlayerWithClientId(clientId);
                objects.Add(gamePlayer);
                eventQueue.addFunction(new Event(GameProtocol.GAME_PLAYER_GIVE_UP, objects));
                clientsMap.Remove(clientId);
                return(true);

            case GameProtocol.GAME_PLAYER_FALL:
                objects    = new List <Object>();
                clientId   = message.ReadInt16();
                gamePlayer = getPlayerWithClientId(clientId);
                objects.Add(gamePlayer);
                eventQueue.addFunction(new Event(GameProtocol.GAME_PLAYER_FALL, objects));
                clientsMap.Remove(clientId);
                return(true);

            case GameProtocol.GAME_STARTED:
                objects = new List <Object>();
                objects.Add(message);
                eventQueue.addFunction(new Event(GameProtocol.GAME_STARTED, objects));
                return(true);

            case GameProtocol.GAME_STOPPED:
                objects = new List <Object>();
                objects.Add(message);
                eventQueue.addFunction(new Event(GameProtocol.GAME_STOPPED, objects));
                return(true);

            case GameProtocol.GAME_RESULTS:
                objects = new List <Object>();
                objects.Add(message);
                eventQueue.addFunction(new Event(GameProtocol.GAME_RESULTS, objects));
                return(true);

            case GameProtocol.UPDATE_SCORE:
                objects = new List <Object>();
                objects.Add(message);
                eventQueue.addFunction(new Event(GameProtocol.UPDATE_SCORE, objects));
                return(true);

            case GameProtocol.GAME_FINISHED:
                objects = new List <Object>();
                objects.Add(message);
                eventQueue.addFunction(new Event(GameProtocol.GAME_FINISHED, objects));
                return(true);

            case GameProtocol.GAME_CAN_RESTART:
                bool canRestartFlag = message.ReadBoolean();
                objects = new List <Object>();
                objects.Add(canRestartFlag);
                eventQueue.addFunction(new Event(GameProtocol.GAME_CAN_RESTART, objects));
                return(true);

            case GameProtocol.GAME_ROBOT_ENTER:
                putGameRobotEnter(message);
                return(true);

            case GameProtocol.GAME_ROBOT_REPLACEMENT:
                gameRobotReplacement(message);
                return(true);

            case GameProtocol.GAME_ROBOT_EXIT:
                onGameRobotExit(message);
                return(true);
            }

            return(false);
        }
Example #23
0
 public static void putSpace(JesterClient.Space space)
 {
     JesterLogger.log("SpaceMapping.putSpace: " + space.getId());
     getInstance().spaceMapping.Add(space.getId(), space);
     getInstance().spaceStack.Push(space);
 }
Example #24
0
 public static void removeSpace(int id)
 {
     JesterLogger.log("SpaceMapping.removeSpace: " + id);
     getInstance().spaceMapping.Remove(id);
     getInstance().spaceStack.Pop();
 }
        public override bool callFunction(int fnc, BinaryReader message, CompletionCallback callback = null)
        {
            bool ret = base.callFunction(fnc, message, callback);

            JesterLogger.log("TurnGameSpace.callFunction, ret: " + ret + ", fnc: " + fnc);

            if (ret)
            {
                return(true);
            }

            switch (fnc)
            {
            case TurnGameProtocol.NOTIFY_CURRENT_PLAYER:
                JesterLogger.log("NOTIFY_CURRENT_PLAYER ");
                int clientId = message.ReadInt16();
                JesterLogger.log("clientId: " + clientId);
                Client client = clientsMap[clientId];
                JesterLogger.log("client: " + client);
                notifyCurrentPlayer(client, callback);
                return(true);

            case TurnGameProtocol.NOTIFY_CURRENT_PLAYER_ROBOT:
                JesterLogger.log("TurnGameSpace.NOTIFY_CURRENT_PLAYER_ROBOT");
                int robotIndex = message.ReadByte();
                JesterLogger.log("TurnGameSpace.RobotsMap sz: " + robotsMap.Count + ", robotIdx: " + robotIndex);
                List <int> dellist = new List <int>(robotsMap.Keys);
                for (int i = 0; i < dellist.Count; i++)
                {
                    JesterLogger.log("TurnGameSpace.RobotsMap, i: " + i + ", key: " + dellist[i]);
                }
                RobotInterface robot = robotsMap[robotIndex];
                JesterLogger.log("TurnGameSpace.RobotsMap 2....");
                notifyCurrentPlayerRobot(robot, callback);
                return(true);

            case TurnGameProtocol.TURN_STARTED:
                List <Object> objects = new List <Object>();
                objects.Add(message);
                eventQueue.addFunction(new Event(TurnGameProtocol.TURN_STARTED, objects));
                return(true);

            case TurnGameProtocol.TURN_FINISHED:
                objects = new List <Object>();
                objects.Add(message);
                eventQueue.addFunction(new Event(TurnGameProtocol.TURN_FINISHED, objects));
                return(true);

            case TurnGameProtocol.MATCH_STARTED:
                objects = new List <Object>();
                objects.Add(message);
                eventQueue.addFunction(new Event(TurnGameProtocol.MATCH_STARTED, objects));
                return(true);

            case TurnGameProtocol.MATCH_FINISHED:
                objects = new List <Object>();
                objects.Add(message);
                eventQueue.addFunction(new Event(TurnGameProtocol.MATCH_FINISHED, objects));
                return(true);

            case TurnGameProtocol.SET_SELECTABLES_BY_PLAYER:
                int        playerId   = message.ReadInt32();
                bool       selectable = message.ReadBoolean();
                GamePlayer gamePlayer = gamePlayersMap[id];
                objects = new List <Object>();
                objects.Add(gamePlayer);
                objects.Add(selectable);
                eventQueue.addFunction(new Event(TurnGameProtocol.SET_SELECTABLES_BY_PLAYER, objects));
                return(true);

            case TurnGameProtocol.SET_THIS_PLAYER_SELECTABLES:
                selectable = message.ReadBoolean();
                objects    = new List <Object>();
                objects.Add(thisPlayer);
                objects.Add(selectable);
                eventQueue.addFunction(new Event(TurnGameProtocol.SET_THIS_PLAYER_SELECTABLES, objects));
                return(true);
            }

            return(false);
        }