private void SendMessageToAll(GameRoom room, string message, object val)
 {
     foreach (var player in room.Players)
     {
         qManager.SendMessage(player.Gateway, message, player, val);
     }
 }
Beispiel #2
0
        public void CreateGame(GameCreateRequestModel data)
        {
            Logger.Log("--game created ", LogLevel.DebugInformation);
            GameRoom room;
            rooms.Add(room = new GameRoom());
            room.MaxUsers = data.Players.Count; //todo idk
            room.GameType = data.GameType;
            room.Started = false;
            room.Players.AddRange(data.Players);

            GameObject gameObject;
            if (cachedGames.ContainsKey(room.GameType))
                gameObject = cachedGames[room.GameType];
            else
                gameObject = cachedGames[room.GameType] = Global.Require<GameObject>(string.Format("./Games/{0}/app.js", room.GameType));

            room.Fiber = CreateFiber(room, gameObject, true);
            room.Unwind = players => {
                              gameData.FinishedGames++;
                              Logger.Log("--game closed", LogLevel.DebugInformation);
                          };
            room.PlayerLeave += (player) => {
                                    //todo laeve player api in the game
                                    ////i think an action that it calls

                                    room.Players.Remove(player);
                                    room.PlayersLeft.Add(player);
                                };

            foreach (var userLogicModel in room.Players) {
                myServerManager.RegisterGameServer(userLogicModel);
            }

            startGame(room);
        }
 private UserLogicModel getPlayerByUsername(GameRoom room, string userName)
 {
     foreach (var player in room.Players)
     {
         if (player.UserName == userName)
             return player;
     }
     return null;
 }
        private void askQuestion(CardGameQuestion answ, GameRoom room)
        {
            var user = getPlayerByUsername(room, answ.User.UserName);
            myServerManager.SendAskQuestion(user, new GameSendAnswerModel(answ.Question, answ.Answers));
            myServerManager.SendUpdateState(room, answ.User);


            ServerLogger.LogDebug("Ask question   ", answ);
        }
        private void askPlayerQuestion(GameRoom room, FiberYieldResponse answer)
        {
            gameData.TotalQuestionsAnswered++;

            var answ = answer.Question;

            if (answ == null)
            {
                ServerLogger.LogDebug("game question over", room);
                myServerManager.SendGameOver(room);
                room.Fiber.Run<FiberYieldResponse>();
                //     profiler.takeSnapshot('game over ' + room.roomID);
                return;
            }
            askQuestion(answ, room);
            //ServerLogger.Log(gameData.toString());

            var dt = new DateTime();
            var then = dt.GetMilliseconds();
            //ServerLogger.Log(then - now + " Milliseconds");
            //  ServerLogger.Log(gameData.TotalQuestionsAnswered / ((dt.GetTime() - startTime.GetTime()) / 1000d) + " Answers per seconds", LogLevel.DebugInformation);
        }
Beispiel #6
0
        private void breakGameExecution(GameRoom room, FiberYieldResponse response)
        {
            if (!room.Debuggable) {
                var answ3 = room.Fiber.Run<FiberYieldResponse>();
                processGameResponse(room, answ3);
                return;
            }
            if (!room.Game.CardGame.Emulating) {
                var ganswer = new GameAnswerModel(response.LineNumber + 2, 0);

                myServerManager.SendDebugBreak(room, ganswer);
            }
        }
        public void SendGameOver(GameRoom room)
        {
            SendMessageToAll(room, "Area.Game.GameOver", "a");

            if (room.DebuggingSender != null)
                qManager.SendMessage(room.DebuggingSender.Gateway, "Area.Debug.GameOver", room.DebuggingSender, new object());
        }
 public void SendUpdateState(GameRoom room)
 {
     SendMessageToAll(room, "Area.Game.UpdateState", new Compressor().CompressText(Json.Stringify(room.Game.CardGame.CleanUp())));
 }
        public void SendGameOver(GameRoom room)
        {
            SendMessageToAll(room, "Area.Game.GameOver", "a");

        }
        private Fiber<List<UserLogicModel>> CreateFiber(GameRoom room, GameObject gameObject, bool emulating, GameDataModel game)
        {
            return new Fiber<List<UserLogicModel>>(players =>
            {
                if (players == null || players.Count == 0) return true;
                room.Players = players;
                ServerLogger.LogDebug("game started", room);
                GameObject sev = null;

                Script.Eval("sev = new gameObject();");
                room.PlayersLeft = new List<UserLogicModel>();
                sev.CardGame = new GameCardGame();
                sev.CardGame.Emulating = emulating;
                room.Game = sev;
                sev.CardGame.SetEmulatedAnswers(room.EmulatedAnswers);
                sev.CardGame.SetPlayers(players);
                sev.CardGame.Size = new Size(game.GameLayout.Width, game.GameLayout.Height);

                foreach (var gameTextModel in game.GameLayout.Texts)
                {
                    sev.CardGame.TextAreas.Add(new GameCardGameTextArea(new GameCardGameTextAreaOptions()
                    {
                        X = gameTextModel.Left,
                        Y = gameTextModel.Top,
                        Name = gameTextModel.Name,
                        Text = gameTextModel.Text,

                    }));
                }


                foreach (var gameSpaceModel in game.GameLayout.Spaces)
                {
                    sev.CardGame.Spaces.Add(new CardGameTableSpace(new CardGameTableSpaceOptions()
                    {
                        X = gameSpaceModel.Left,
                        Y = gameSpaceModel.Top,
                        Height = gameSpaceModel.Height,
                        Width = gameSpaceModel.Width,
                        Name = gameSpaceModel.Name,
                        Vertical = gameSpaceModel.Vertical,
                        ResizeType = gameSpaceModel.ResizeType
                    }));
                }

                foreach (var gameEffect in game.Effects)
                {
                    sev.CardGame.Effects.Add(new CardGameEffect(new CardGameEffectOptions()
                    {
                        Name = gameEffect.Name,
                        Type = gameEffect.Type,
                        Properties = gameEffect.Properties.Map(a => new CardGameEffectProperty() { Name = a.Name, Value = a.Value })
                    }));
                }

                gameData.TotalGames++;
                gameData.TotalPlayers += players.Count;
                sev.CardGame.EmulatedAnswerIndex = 0;

                //todo to data
                sev.CardGame.NumberOfCards = 52;
                sev.CardGame.NumberOfJokers = 0;

                sev.CardGame.ConfigurationCompleted();
                sev.Constructor();
                sev.RunGame();
                ServerLogger.LogDebug("Doneski", gameData);

                room.Unwind(players);
                return true;
            });
        }
        private void startGame(GameRoom room)
        {
            myServerManager.SendGameStarted(room);

            room.Started = true;

            var answer = room.Fiber.Run<FiberYieldResponse>(room.Players);
            processGameResponse(room, answer);
        }
Beispiel #12
0
        private void processGameResponse(GameRoom room, FiberYieldResponse response)
        {
            if (response == null) {
                Logger.Log("game request over", LogLevel.DebugInformation);

                myServerManager.SendGameOver(room);
                room.Fiber.Run<FiberYieldResponse>();
                rooms.Remove(room);
                room.Unwind(room.Players);
                return;
            }

            switch (response.Type) {
                case FiberYieldResponseType.AskQuestion:
                    askPlayerQuestion(room, response);
                    break;

                case FiberYieldResponseType.PlayersLeft:
                    didPlayersLeave(room, response);
                    break;
                case FiberYieldResponseType.GameOver:
                    gameOver(room);
                    break;
                case FiberYieldResponseType.Log:
                    logGameConsoleLine(room, response);
                    break;
                case FiberYieldResponseType.Break:
                    breakGameExecution(room, response);
                    break;
            }
        }
Beispiel #13
0
        private void logGameConsoleLine(GameRoom room, FiberYieldResponse answer)
        {
            var answ2 = room.Fiber.Run<FiberYieldResponse>();
            processGameResponse(room, answ2);

            if (!room.Game.CardGame.Emulating && room.Debuggable) {
                //Logger.Log(gameData.toString());
                var ganswer = new GameAnswerModel(0, answer.Contents);

                myServerManager.SendDebugLog(room, ganswer);
            }
        }
Beispiel #14
0
        private void gameOver(GameRoom room)
        {
            Logger.Log("game real over", LogLevel.DebugInformation);

            myServerManager.SendUpdateState(room);

            myServerManager.SendGameOver(room);
            room.Fiber.Reset();

            rooms.Remove(room);
        }
Beispiel #15
0
        private Fiber<List<UserLogicModel>> CreateFiber(GameRoom room, GameObject gameObject, bool emulating)
        {
            return new Fiber<List<UserLogicModel>>(players => {
                                                       if (players == null || players.Count == 0) return true;
                                                       room.Players = players;
                                                       Logger.Log("game started", LogLevel.Information);
                                                       GameObject sev = null;

                                                       Script.Eval("sev = new gameObject();");
                                                       room.PlayersLeft = new List<UserLogicModel>();
                                                       sev.CardGame.Emulating = emulating;
                                                       room.Game = sev;
                                                       sev.CardGame.SetAnswers(room.Answers);
                                                       sev.CardGame.SetPlayers(players);
                                                       gameData.TotalGames++;
                                                       gameData.TotalPlayers += players.Count;
                                                       sev.CardGame.AnswerIndex = 0;
                                                       sev.Constructor();
                                                       sev.RunGame();
                                                       Logger.Log("Doneski", LogLevel.DebugInformation);

                                                       room.Unwind(players);
                                                       return true;
                                                   });
        }
        public void CreateGame(GameCreateRequestModel data)
        {

            ServerLogger.LogDebug("--game created ", data);
            dataManager.SiteData.Game_GetGamesByName(data.GameType, (game) =>
                                                                    {
                                                                        if (game == null)
                                                                        {
                                                                            ServerLogger.LogError("--game not found " + data.GameType, data);
                                                                            return;
                                                                        }
                                                                        ServerLogger.LogDebug("--game found " + game.Name, game);

                                                                        GameRoom room;
                                                                        rooms.Add(room = new GameRoom());
                                                                        room.MaxUsers = data.Players.Count; //todo idk
                                                                        room.GameType = data.GameType;
                                                                        room.Started = false;
                                                                        room.Players.AddRange(data.Players);
                                                                        GameObject evaluated_game = null;
                                                                        Script.Eval("evaluated_game=" + game.GameCode.Code);
                                                                        GameObject gameObject;
                                                                        if (cachedGames.ContainsKey(room.GameType))
                                                                            gameObject = cachedGames[room.GameType];
                                                                        else
                                                                            gameObject = cachedGames[room.GameType] = evaluated_game;

                                                                        room.Fiber = CreateFiber(room, gameObject, true, game);
                                                                        room.Unwind = players =>
                                                                        {
                                                                            gameData.FinishedGames++;
                                                                            ServerLogger.LogDebug("--game closed", gameData);
                                                                        };
                                                                        room.PlayerLeave += (player) =>
                                                                        {
                                                                            //todo laeve player api in the game
                                                                            ////i think an action that it calls

                                                                            room.Players.Remove(player);
                                                                            room.PlayersLeft.Add(player);
                                                                        };

                                                                        foreach (var userLogicModel in room.Players)
                                                                        {
                                                                            myServerManager.RegisterGameServer(userLogicModel);
                                                                        }

                                                                        startGame(room);
                                                                    });
        }
        private void processGameResponse(GameRoom room, FiberYieldResponse response)
        {
            if (response == null)
            {
                ServerLogger.LogDebug("game request over", room);

                myServerManager.SendGameOver(room);
                room.Fiber.Run<FiberYieldResponse>();
                rooms.Remove(room);
                room.Unwind(room.Players);
                return;
            }

            switch (response.Type)
            {
                case FiberYieldResponseType.AskQuestion:
                    askPlayerQuestion(room, response);
                    break;
                case FiberYieldResponseType.PlayersLeft:
                    didPlayersLeave(room, response);
                    break;
                case FiberYieldResponseType.GameOver:
                    gameOver(room);
                    break;
                case FiberYieldResponseType.Log:
                    gameNoop(room);
                    break;
                case FiberYieldResponseType.Break:
                    gameNoop(room);
                    break;
            }
        }
        private void didPlayersLeave(GameRoom room, FiberYieldResponse response)
        {
            room.Fiber.Run<FiberYieldResponse>(room.PlayersLeft);

            room.PlayersLeft.Clear();
        }
        public void SendUpdateState(GameRoom room, UserLogicModel user)
        {

            foreach (var player in room.Players)
            {
                var tmp = Json.Parse<GameCardGame>(Json.Stringify(room.Game.CardGame));
                JsDictionary<string, CardGamePile> piles = new JsDictionary<string, CardGamePile>();

                foreach (var cgUser in tmp. Users)
                {
                    piles[cgUser.Cards.Name] = cgUser.Cards;
                    foreach (var card in cgUser.Cards.Cards)
                    {
                        if (card.State == CardGameCardState.FaceUpIfOwned && cgUser.UserName!=player.UserName )
                        {
                            card.Type = -1;
                            card.Value = -1;
                        }

                        if (card.State == CardGameCardState.FaceDown)
                        {
                            card.Type = -1;
                            card.Value = -1;
                        }
                    }
                }

                foreach (var space in tmp.Spaces)
                {
                    if (piles[space.PileName] != null)
                    {
                        space.Pile = piles[space.PileName];
                    }
                
                    foreach (var card in space.Pile.Cards)
                    {
                        if (card.State == CardGameCardState.FaceDown)
                        {
                            card.Type = -1;
                            card.Value = -1;
                        }
                    }
                }

                foreach (var card in tmp.Deck.Cards)
                {
                    if (card.State == CardGameCardState.FaceDown)
                    {
                        card.Type = -1;
                        card.Value = -1;
                    }
                }

                string stringify = Json.Stringify(tmp.CleanUp());
                ServerLogger.LogData("Send Data"+player.UserName, stringify);
                var val = compress.CompressText(stringify);
                qManager.SendMessage(player.Gateway, "Area.Game.UpdateState", player, val);
            }




        }
        private void gameNoop(GameRoom room)
        {
            var answ2 = room.Fiber.Run<FiberYieldResponse>();
            processGameResponse(room, answ2);

        }
 public void SendDebugLog(GameRoom room, GameAnswerModel ganswer)
 {
     qManager.SendMessage(room.DebuggingSender.Gateway, "Area.Debug.Log", room.DebuggingSender, ganswer);
 }
        private void gameOver(GameRoom room)
        {
            ServerLogger.LogDebug("game real over", room);

            myServerManager.SendUpdateState(room, null);

            myServerManager.SendGameOver(room);
            rooms.Remove(room);
            room.Fiber.Reset();

        }
 public void SendGameStarted(GameRoom room)
 {
     SendMessageToAll(room, "Area.Game.Started", new GameRoomModel() { RoomID = room.RoomID});
 }
Beispiel #24
0
        private void askQuestion(GameQuestionAnswerModel answ, GameRoom room)
        {
            var user = getPlayerByUsername(room, answ.User.UserName);
            myServerManager.SendAskQuestion(user, new GameSendAnswerModel(answ.Question, answ.Answers));
            myServerManager.SendUpdateState(room);

            if (verbose) {
                Logger.Log(answ.User.UserName + ": " + answ.Question + "   ", LogLevel.Information);
                var ind = 0;
                foreach (var answer in answ.Answers) {
                    Logger.Log("     " + ind++ + ": " + answer, LogLevel.Information);
                }
            }
        }