private static async void VoteMapTimer()
        {
            Debug.WriteLine("START VOTE");

            await Delay(30000);

            Debug.WriteLine("CHECK VOTE");

            var votes = new Dictionary <string, int>();

            foreach (var p in new PlayerList())
            {
                if (!Sync.Data.Has(User.GetPlayerServerId(p), "voteMap"))
                {
                    continue;
                }
                string map = (string)Sync.Data.Get(User.GetPlayerServerId(p), "voteMap");

                Debug.WriteLine("VOTE " + map);

                if (votes.ContainsKey(map))
                {
                    votes[map]++;
                }
                else
                {
                    votes.Add(map, 1);
                }
            }

            MapManager.SetMap(votes.FirstOrDefault(x => x.Value == votes.Values.Max()).Key);
            Debug.WriteLine("END VOTE");
        }
Beispiel #2
0
        public static void TriggerEventToPlayer(int serverId, string eventName, int countArgs = 0, object args1 = null, object args2 = null, object args3 = null, object args4 = null, object args5 = null, object args6 = null, object args7 = null, object args8 = null, object args9 = null, object args10 = null)
        {
            foreach (var pl in new PlayerList())
            {
                if (User.GetPlayerServerId(pl) != serverId)
                {
                    continue;
                }

                switch (countArgs)
                {
                case 0:
                    TriggerClientEvent(pl, eventName);
                    break;

                case 1:
                    TriggerClientEvent(pl, eventName, args1);
                    break;

                case 2:
                    TriggerClientEvent(pl, eventName, args1, args2);
                    break;

                case 3:
                    TriggerClientEvent(pl, eventName, args1, args2, args3);
                    break;

                case 4:
                    TriggerClientEvent(pl, eventName, args1, args2, args3, args4);
                    break;

                case 5:
                    TriggerClientEvent(pl, eventName, args1, args2, args3, args4, args5);
                    break;

                case 6:
                    TriggerClientEvent(pl, eventName, args1, args2, args3, args4, args5, args6);
                    break;

                case 7:
                    TriggerClientEvent(pl, eventName, args1, args2, args3, args4, args5, args6, args7);
                    break;

                case 8:
                    TriggerClientEvent(pl, eventName, args1, args2, args3, args4, args5, args6, args7, args8);
                    break;

                case 9:
                    TriggerClientEvent(pl, eventName, args1, args2, args3, args4, args5, args6, args7, args8, args9);
                    break;

                case 10:
                    TriggerClientEvent(pl, eventName, args1, args2, args3, args4, args5, args6, args7, args8, args9, args10);
                    break;
                }

                return;
            }
        }
 protected static void KickByPlayer([FromSource] Player player, int playerId, string reason)
 {
     foreach (var p in new PlayerList())
     {
         if (User.GetPlayerServerId(p) == playerId)
         {
             User.Kick(p, reason);
         }
     }
 }
        public static void StopGame(List <Player> inGameList, int winnerType)
        {
            CountPlayMap++;
            if (CountPlayMap > 2)
            {
                VoteMapTimer();
            }

            Sync.Data.Reset(-1, "GameTimer");
            foreach (var p in inGameList)
            {
                var playerId = User.GetPlayerServerId(p);
                p.TriggerEvent("TTT:StopGame", winnerType, CountPlayMap > 2);
                Sync.Data.Reset(playerId, "InGame");
                Sync.Data.Reset(playerId, "isDead");
                Sync.Data.Reset(playerId, "playerType");
            }
        }
        private static async Task BriefingTimer()
        {
            await Delay(1000);

            var inGameList = new PlayerList().Where(p => Sync.Data.Has(User.GetPlayerServerId(p), "InGame")).ToList();

            if (inGameList.Any())
            {
                if (Sync.Data.Has(-1, "BriefingTimer") && (int)Sync.Data.Get(-1, "BriefingTimer") > 0)
                {
                    Sync.Data.Set(-1, "BriefingTimer", (int)Sync.Data.Get(-1, "BriefingTimer") - 1);

                    foreach (var p in inGameList)
                    {
                        p.TriggerEvent("TTT:UpdateBriefingInfo", (int)Sync.Data.Get(-1, "BriefingTimer"));
                    }

                    if ((int)Sync.Data.Get(-1, "BriefingTimer") < 1)
                    {
                        int traitor1   = -1;
                        int traitor2   = -1;
                        int traitor3   = -1;
                        int traitor4   = -1;
                        int detective1 = -1;
                        int detective2 = -1;

                        var rand = new Random();

                        traitor1 = User.GetPlayerServerId(inGameList[rand.Next(inGameList.Count)]);

                        if (inGameList.Count > 7 && inGameList.Count <= 10)
                        {
                            traitor2 = User.GetPlayerServerId(inGameList[rand.Next(inGameList.Count)]);
                            //detective1 = User.GetPlayerServerId(inGameList[rand.Next(inGameList.Count)]);
                        }
                        else if (inGameList.Count > 10 && inGameList.Count <= 16)
                        {
                            traitor2 = User.GetPlayerServerId(inGameList[rand.Next(inGameList.Count)]);
                            traitor3 = User.GetPlayerServerId(inGameList[rand.Next(inGameList.Count)]);
                            //detective1 = User.GetPlayerServerId(inGameList[rand.Next(inGameList.Count)]);
                        }
                        else if (inGameList.Count > 16)
                        {
                            traitor2 = User.GetPlayerServerId(inGameList[rand.Next(inGameList.Count)]);
                            traitor3 = User.GetPlayerServerId(inGameList[rand.Next(inGameList.Count)]);
                            traitor4 = User.GetPlayerServerId(inGameList[rand.Next(inGameList.Count)]);
                            //detective1 = User.GetPlayerServerId(inGameList[rand.Next(inGameList.Count)]);
                            //detective2 = User.GetPlayerServerId(inGameList[rand.Next(inGameList.Count)]);
                        }

                        Sync.Data.Set(-1, "GameTimer", MapManager.MapData.PlayTime);
                        Sync.Data.Reset(-1, "BriefingTimer");

                        foreach (var p in inGameList)
                        {
                            p.TriggerEvent("TTT:StartGame", traitor1, traitor2, traitor3, traitor4, detective1, detective2, MapManager.MapData.PlayTime, (int)Sync.Data.Get(-1, "CameraType"));
                        }
                    }
                }
            }
            else if (Sync.Data.Has(-1, "BriefingTimer"))
            {
                Sync.Data.Reset(-1, "BriefingTimer");
            }
        }
        private static async Task LobbyTimer()
        {
            await Delay(1000);

            var lobbyList = new PlayerList().Where(p => Sync.Data.Has(User.GetPlayerServerId(p), "Lobby")).ToList();

            if (lobbyList.Any())
            {
                if (Sync.Data.Has(-1, "StartTimer") && (int)Sync.Data.Get(-1, "StartTimer") > 0)
                {
                    Sync.Data.Set(-1, "StartTimer", (int)Sync.Data.Get(-1, "StartTimer") - 1);

                    int voteCam1 = 0;
                    int voteCam2 = 0;

                    foreach (var player in new PlayerList())
                    {
                        if (!Sync.Data.Has(User.GetPlayerServerId(player), "CameraType"))
                        {
                            continue;
                        }
                        if ((int)Sync.Data.Get(User.GetPlayerServerId(player), "CameraType") == 0)
                        {
                            voteCam1++;
                        }
                        else
                        {
                            voteCam2++;
                        }
                    }

                    foreach (var p in lobbyList)
                    {
                        p.TriggerEvent("TTT:UpdateLobbyInfo", (int)Sync.Data.Get(-1, "StartTimer"), voteCam1, voteCam2, lobbyList.Count);
                    }

                    if ((int)Sync.Data.Get(-1, "StartTimer") > 15)
                    {
                        if (lobbyList.Count / 2 <= voteCam1 + voteCam2)
                        {
                            Sync.Data.Set(-1, "StartTimer", 10);
                        }
                    }

                    if ((int)Sync.Data.Get(-1, "StartTimer") < 1)
                    {
                        Sync.Data.Reset(-1, "StartTimer");
                        Sync.Data.Set(-1, "CameraType", voteCam1 > voteCam2 ? 0 : 1);

                        if (await MapManager.LoadMap(MapManager.GetMap(), lobbyList))
                        {
                            var weatherList = new List <string>
                            {
                                "EXTRASUNNY",
                                "CLEAR",
                                "CLOUDS",
                                "SMOG",
                                "FOGGY",
                                "OVERCAST",
                                "CLEARING",
                                "XMAS"
                            };

                            var rand = new Random();

                            string weatherMap = weatherList[rand.Next(weatherList.Count)];
                            int    hourMap    = rand.Next(23);

                            Sync.Data.Set(-1, "BriefingTimer", MapManager.MapData.Briefing);
                            foreach (var p in lobbyList)
                            {
                                Sync.Data.Set(User.GetPlayerServerId(p), "InGame", true);
                                p.TriggerEvent("TTT:StartBriefing", MapManager.MapData.Name,
                                               MapManager.MapData.Briefing, MapManager.MapData.CenterX,
                                               MapManager.MapData.CenterY, MapManager.MapData.CenterZ,
                                               MapManager.MapData.MaxRadius, MapManager.MapData.CanSwim, MapManager.MapData.EnableScope, weatherMap, hourMap);
                            }
                        }
                        else
                        {
                            MapManager.SetMap(MapManager.MapList.First());
                            StopGame(lobbyList, PlayerTypes.Unknown);
                        }

                        foreach (var player in new PlayerList())
                        {
                            Sync.Data.Reset(User.GetPlayerServerId(player), "CameraType");
                            Sync.Data.Reset(User.GetPlayerServerId(player), "Lobby");
                        }
                    }
                }
            }
            else if (Sync.Data.Has(-1, "StartTimer"))
            {
                Sync.Data.Reset(-1, "StartTimer");
            }
        }
        private static async Task GameTimer()
        {
            await Delay(1000);

            var inGameList = new PlayerList().Where(p => Sync.Data.Has(User.GetPlayerServerId(p), "InGame")).ToList();

            if (inGameList.Any())
            {
                if (Sync.Data.Has(-1, "GameTimer") && (int)Sync.Data.Get(-1, "GameTimer") > 0)
                {
                    if (MapManager.MapData.PlayTime == (int)Sync.Data.Get(-1, "GameTimer"))
                    {
                        await Delay(5000);
                    }

                    Sync.Data.Set(-1, "GameTimer", (int)Sync.Data.Get(-1, "GameTimer") - 1);

                    int innocentAliveCount = 0;
                    int traitorAliveCount  = 0;

                    foreach (var p in inGameList)
                    {
                        p.TriggerEvent("TTT:UpdateGameInfo", (int)Sync.Data.Get(-1, "GameTimer"));

                        var playerId = User.GetPlayerServerId(p);

                        if (!Sync.Data.Has(playerId, "playerType"))
                        {
                            continue;
                        }

                        if ((int)Sync.Data.Get(playerId, "playerType") == PlayerTypes.Innocent ||
                            (int)Sync.Data.Get(playerId, "playerType") == PlayerTypes.Detective)
                        {
                            if (!Sync.Data.Has(playerId, "isDead"))
                            {
                                innocentAliveCount++;
                            }
                        }
                        else if ((int)Sync.Data.Get(playerId, "playerType") == PlayerTypes.Traitor)
                        {
                            if (!Sync.Data.Has(playerId, "isDead"))
                            {
                                traitorAliveCount++;
                            }
                        }
                    }

                    if (traitorAliveCount == 0)
                    {
                        StopGame(inGameList, PlayerTypes.Innocent);
                    }
                    else if (innocentAliveCount == 0)
                    {
                        StopGame(inGameList, PlayerTypes.Traitor);
                    }
                    else if ((int)Sync.Data.Get(-1, "GameTimer") < 1)
                    {
                        StopGame(inGameList, PlayerTypes.Innocent);
                    }
                }
            }
            else if (Sync.Data.Has(-1, "GameTimer"))
            {
                Sync.Data.Reset(-1, "GameTimer");
            }
        }
Beispiel #8
0
        public static async Task <bool> LoadMap(string mapName, List <Player> lobbyList)
        {
            if (MapList.All(item => item != mapName))
            {
                Debug.WriteLine($"Map \"{mapName}\" not found");
                SetMap(MapList.First());
                return(false);
            }

            SetMapName(mapName);

            var fileList = new DirectoryInfo($@"resources/{GetCurrentResourceName()}/maps/{mapName}/").GetFiles("*.json", SearchOption.AllDirectories);

            bool isFindConfig = false;
            bool isFindWeapon = false;
            bool isFindSpawn  = false;
            bool isFindIpl    = false;

            foreach (var item in fileList)
            {
                if (item.Name == "config.json")
                {
                    isFindConfig = true;
                }
                if (item.Name == "weapon.json")
                {
                    isFindWeapon = true;
                }
                if (item.Name == "spawn.json")
                {
                    isFindSpawn = true;
                }
                if (item.Name == "ipl.json")
                {
                    isFindIpl = true;
                }
            }

            if (!isFindConfig)
            {
                Debug.WriteLine("Config is not found");
                return(false);
            }

            MapData.Name        = mapName;
            MapData.Briefing    = 30;
            MapData.MaxPlayers  = 32;
            MapData.CenterX     = 0;
            MapData.CenterY     = 0;
            MapData.CenterZ     = 0;
            MapData.MaxRadius   = 100;
            MapData.CanSwim     = true;
            MapData.EnableScope = false;
            MapData.PlayTime    = 300;

            foreach (var item in Main.LoadJson($@"resources/{GetCurrentResourceName()}/maps/{mapName}/config.json"))
            {
                if (item.Key == "breefing")
                {
                    MapData.Briefing = Convert.ToInt32(item.Value);
                }
                if (item.Key == "maxPlayers")
                {
                    MapData.MaxPlayers = Convert.ToInt32(item.Value);
                }
                if (item.Key == "centerX")
                {
                    MapData.CenterX = Convert.ToDouble(item.Value);
                }
                if (item.Key == "centerY")
                {
                    MapData.CenterY = Convert.ToDouble(item.Value);
                }
                if (item.Key == "centerZ")
                {
                    MapData.CenterZ = Convert.ToDouble(item.Value);
                }
                if (item.Key == "maxRadius")
                {
                    MapData.MaxRadius = Convert.ToDouble(item.Value);
                }
                if (item.Key == "playTime")
                {
                    MapData.PlayTime = Convert.ToInt32(item.Value);
                }
                if (item.Key == "canSwiming")
                {
                    MapData.CanSwim = (bool)item.Value;
                }
                if (item.Key == "enableScope")
                {
                    MapData.EnableScope = (bool)item.Value;
                }
            }

            if (isFindWeapon)
            {
                foreach (var p in lobbyList)
                {
                    p.TriggerEvent("TTT:LoadWeapon", Main.LoadJson($@"resources/{GetCurrentResourceName()}/maps/{mapName}/weapon.json"));
                }
            }

            if (isFindIpl)
            {
                foreach (var p in lobbyList)
                {
                    p.TriggerEvent("TTT:LoadIpl", Main.LoadJson($@"resources/{GetCurrentResourceName()}/maps/{mapName}/ipl.json"));
                }
            }

            if (isFindSpawn)
            {
                var spawnList = Main.LoadJson($@"resources/{GetCurrentResourceName()}/maps/{mapName}/spawn.json");

                int countPlayerSpawn = 0;
                while (countPlayerSpawn < lobbyList.Count)
                {
                    foreach (var item in spawnList)
                    {
                        if (countPlayerSpawn >= lobbyList.Count)
                        {
                            continue;
                        }
                        var playerId  = User.GetPlayerServerId(lobbyList[countPlayerSpawn]);
                        var posString = item.Value.ToString().Split(',');

                        if (posString.Length != 4)
                        {
                            continue;
                        }

                        Sync.Data.Set(playerId, "spawnPosX", Convert.ToDouble(posString[0]));
                        Sync.Data.Set(playerId, "spawnPosY", Convert.ToDouble(posString[1]));
                        Sync.Data.Set(playerId, "spawnPosZ", Convert.ToDouble(posString[2]));
                        Sync.Data.Set(playerId, "spawnRot", Convert.ToDouble(posString[3]));
                        countPlayerSpawn++;
                    }
                }
            }
            else
            {
                foreach (var p in lobbyList)
                {
                    var playerId = User.GetPlayerServerId(p);
                    Sync.Data.Set(playerId, "spawnPosX", MapData.CenterX);
                    Sync.Data.Set(playerId, "spawnPosY", MapData.CenterY);
                    Sync.Data.Set(playerId, "spawnPosZ", MapData.CenterZ);
                    Sync.Data.Set(playerId, "spawnRot", 0);
                }
            }

            return(true);
        }