Example #1
0
 public static void GenerateIceBreaker(bool useTimer = true)
 {
     AlreadyFrozenPlayers = new List <ClientSession>();
     Map = ServerManager.Instance.GenerateMapInstance(2005, MapInstanceType.IceBreakerInstance, new InstanceBag());
     if (useTimer)
     {
         ServerManager.Instance.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(
                                              string.Format(Language.Instance.GetMessageFromKey("ICEBREAKER_MINUTES"), 5, LevelBrackets[_currentBracket].Item1, LevelBrackets[_currentBracket].Item2), 1));
         Thread.Sleep(5 * 60 * 1000);
         ServerManager.Instance.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(
                                              string.Format(Language.Instance.GetMessageFromKey("ICEBREAKER_MINUTES"), 1, LevelBrackets[_currentBracket].Item1, LevelBrackets[_currentBracket].Item2), 1));
         Thread.Sleep(1 * 60 * 1000);
         ServerManager.Instance.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(
                                              string.Format(Language.Instance.GetMessageFromKey("ICEBREAKER_SECONDS"), 30, LevelBrackets[_currentBracket].Item1, LevelBrackets[_currentBracket].Item2), 1));
         Thread.Sleep(30 * 1000);
         ServerManager.Instance.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(
                                              string.Format(Language.Instance.GetMessageFromKey("ICEBREAKER_SECONDS"), 10, LevelBrackets[_currentBracket].Item1, LevelBrackets[_currentBracket].Item2), 1));
         Thread.Sleep(10 * 1000);
     }
     ServerManager.Instance.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("ICEBREAKER_STARTED"), 1));
     ServerManager.Instance.IceBreakerInWaiting = true;
     ServerManager.Instance.Sessions.Where(x => x.Character.Level >= LevelBrackets[_currentBracket].Item1 && x.Character.Level <= LevelBrackets[_currentBracket].Item2 && x.CurrentMapInstance.MapInstanceType == MapInstanceType.BaseMapInstance).ToList().ForEach(x => x.SendPacket($"qnaml 2 #guri^501 {string.Format(Language.Instance.GetMessageFromKey("ICEBREAKER_ASK"), 500)}"));
     _currentBracket++;
     if (_currentBracket > 5)
     {
         _currentBracket = 0;
     }
     Observable.Timer(TimeSpan.FromSeconds(10)).Subscribe(c =>
     {
         ServerManager.Instance.StartedEvents.Remove(EventType.ICEBREAKER);
         ServerManager.Instance.IceBreakerInWaiting = false;
         if (Map.Sessions.Count() <= 1)
         {
             Map.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("ICEBREAKER_WIN"), 0));
             Map.Sessions.ToList().ForEach(x =>
             {
                 x.Character.GetReput(x.Character.Level * 10);
                 if (x.Character.Dignity < 100)
                 {
                     x.Character.Dignity = 100;
                 }
                 x.Character.Gold += GoldRewards[_currentBracket];
                 x.Character.Gold  = x.Character.Gold > ServerManager.Instance.MaxGold ? ServerManager.Instance.MaxGold : x.Character.Gold;
                 x.SendPacket(x.Character.GenerateFd());
                 x.SendPacket(x.Character.GenerateGold());
                 x.SendPacket(x.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("WIN_MONEY"), GoldRewards[_currentBracket]), 10));
                 x.SendPacket(x.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("WIN_REPUT"), x.Character.Level * 10), 10));
                 x.SendPacket(x.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("DIGNITY_RESTORED"), x.Character.Level * 10), 10));
             });
             Thread.Sleep(5000);
             EventHelper.Instance.ScheduleEvent(TimeSpan.FromSeconds(10), new EventContainer(Map, EventActionType.DISPOSEMAP, null));
         }
         else
         {
             Map.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("ICEBREAKER_FIGHT_WARN"), 0));
             Thread.Sleep(6000);
             Map.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("ICEBREAKER_FIGHT_WARN"), 0));
             Thread.Sleep(7000);
             Map.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("ICEBREAKER_FIGHT_WARN"), 0));
             Thread.Sleep(1000);
             Map.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("ICEBREAKER_FIGHT_START"), 0));
             Map.IsPVP = true;
             while (Map.Sessions.Count() > 1 || AlreadyFrozenPlayers.Count() != Map.Sessions.Count())
             {
                 Thread.Sleep(1000);
             }
             Map.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("ICEBREAKER_WIN"), 0));
             Map.Sessions.ToList().ForEach(x =>
             {
                 x.Character.GetReput(x.Character.Level * 10);
                 if (x.Character.Dignity < 100)
                 {
                     x.Character.Dignity = 100;
                 }
                 x.Character.Gold += GoldRewards[_currentBracket];
                 x.Character.Gold  = x.Character.Gold > ServerManager.Instance.MaxGold ? ServerManager.Instance.MaxGold : x.Character.Gold;
                 x.SendPacket(x.Character.GenerateFd());
                 x.SendPacket(x.Character.GenerateGold());
                 x.SendPacket(x.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("WIN_MONEY"), GoldRewards[_currentBracket]), 10));
                 x.SendPacket(x.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("WIN_REPUT"), x.Character.Level * 10), 10));
                 x.SendPacket(x.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("DIGNITY_RESTORED"), x.Character.Level * 10), 10));
             });
             EventHelper.Instance.ScheduleEvent(TimeSpan.FromSeconds(10), new EventContainer(Map, EventActionType.DISPOSEMAP, null));
         }
     });
 }
Example #2
0
            public void Run(MapInstance map)
            {
                _map = map;

                foreach (ClientSession session in _map.Sessions)
                {
                    ServerManager.Instance.TeleportOnRandomPlaceInMap(session, map.MapInstanceId);
                    if (session.Character.IsVehicled)
                    {
                        session.Character.RemoveVehicle();
                    }
                    if (session.Character.UseSp)
                    {
                        session.Character.LastSp = (DateTime.Now - Process.GetCurrentProcess().StartTime.AddSeconds(-50)).TotalSeconds;
                        ItemInstance specialist = session.Character.Inventory.LoadBySlotAndType((byte)EquipmentType.Sp, InventoryType.Wear);
                        if (specialist != null)
                        {
                            removeSP(session, specialist.ItemVNum);
                        }
                    }
                    Spawn = true;
                    session.Character.CanAttack     = true;
                    session.Character.Speed         = 5;
                    session.Character.IsVehicled    = true;
                    session.Character.IsCustomSpeed = true;
                    session.Character.Morph         = 1009;
                    session.Character.ArenaWinner   = 0;
                    session.Character.MorphUpgrade  = 0;
                    session.Character.MorphUpgrade2 = 0;
                    session.SendPacket(session.Character.GenerateCond());
                    session.Character.LastSpeedChange = DateTime.Now;
                    session.CurrentMapInstance?.Broadcast(session.Character.GenerateCMode());
                    session.SendPacket($"eff_s 1 {session.Character.CharacterId} 4323");
                    _map.Broadcast("srlst 0");
                    session.SendPacket("say 1 -1 10 En 30 segundos, el asalto a las granjas de ovejas comienza pronto.");
                    Observable.Timer(TimeSpan.FromSeconds(30)).Subscribe(o =>
                    {
                        session.SendPacket("say 1 -1 10 En 10 segundos, el asalto a las granjas de ovejas comienza pronto");
                    });
                    Observable.Timer(TimeSpan.FromSeconds(35)).Subscribe(o =>
                    {
                        session.SendPacket("say 1 -1 10 En 5 segundos, el asalto a las granjas de ovejas comienza pronto");
                    });
                    Observable.Timer(TimeSpan.FromSeconds(36)).Subscribe(o =>
                    {
                        session.SendPacket("say 1 -1 10 En 4 segundos, el asalto a las granjas de ovejas comienza pronto");
                    });
                    Observable.Timer(TimeSpan.FromSeconds(37)).Subscribe(o =>
                    {
                        session.SendPacket("say 1 -1 10 En 3 segundos, el asalto a las granjas de ovejas comienza pronto");
                    });
                    Observable.Timer(TimeSpan.FromSeconds(38)).Subscribe(o =>
                    {
                        session.SendPacket("say 1 -1 10 En 2 segundos, el asalto a las granjas de ovejas comienza pronto");
                    });
                    Observable.Timer(TimeSpan.FromSeconds(39)).Subscribe(o =>
                    {
                        session.SendPacket("say 1 -1 10 En 1 segundos, el asalto a las granjas de ovejas comienza pronto");
                    });
                    Observable.Timer(TimeSpan.FromSeconds(50)).Subscribe(o =>
                    {
                        _map.Broadcast("srlst 3");
                        _map.Broadcast("sh_o");
                    });
                    Observable.Timer(TimeSpan.FromMinutes(5)).Subscribe(o =>
                    {
                        End(session.Character);
                    });
                }

                int i = 0;

                while (_map?.Sessions?.Any() == true)
                {
                    runRound(i++);
                }

                //ended
            }
Example #3
0
 public static void SendInMapAfter(this MapInstance map, double sec, string packet)
 {
     Observable.Timer(TimeSpan.FromSeconds(sec)).Subscribe(o => { map.Broadcast(packet); });
 }
Example #4
0
        public void TargetHit(IBattleEntity target, TargetHitType hitType, Skill skill, short?skillEffect = null,
                              short?mapX = null, short?mapY = null, ComboDTO skillCombo = null, bool showTargetAnimation = false,
                              bool isPvp = false)
        {
            if (!target.IsTargetable(Entity.SessionType(), isPvp) ||
                target.Faction == Entity.Faction && ServerManager.Instance.Act4Maps.Any(m => m == Entity.MapInstance))
            {
                if (Session is Character cha)
                {
                    cha.Session.SendPacket($"cancel 2 {target.GetId()}");
                }

                return;
            }

            MapInstance mapInstance = target.MapInstance;
            int         hitmode     = 0;
            bool        onyxWings   = false;
            ushort      damage      = GenerateDamage(target, skill, ref hitmode, ref onyxWings);

            if (Session is Character charact && onyxWings && mapInstance != null)
            {
                short onyxX  = (short)(charact.PositionX + 2);
                short onyxY  = (short)(charact.PositionY + 2);
                int   onyxId = mapInstance.GetNextId();
                var   onyx   = new MapMonster
                {
                    MonsterVNum   = 2371,
                    MapX          = onyxX,
                    MapY          = onyxY,
                    MapMonsterId  = onyxId,
                    IsHostile     = false,
                    IsMoving      = false,
                    ShouldRespawn = false
                };
                mapInstance.Broadcast($"guri 31 1 {charact.CharacterId} {onyxX} {onyxY}");
                onyx.Initialize(mapInstance);
                mapInstance.AddMonster(onyx);
                mapInstance.Broadcast(onyx.GenerateIn());
                target.GetDamage(target.DealtDamage / 2, Entity, false);
                Observable.Timer(TimeSpan.FromMilliseconds(350)).Subscribe(o =>
                {
                    mapInstance.Broadcast(
                        $"su 3 {onyxId} 3 {target.GetId()} -1 0 -1 {skill.Effect} -1 -1 1 {(int)(target.CurrentHp / (double)target.MaxHp * 100)} {damage / 2} 0 0");
                    mapInstance.RemoveMonster(onyx);
                    mapInstance.Broadcast(onyx.GenerateOut());
                });
            }

            if (target.GetSession() is Character character)
            {
                damage             = (ushort)(character.HasGodMode ? 0 : damage);
                target.DealtDamage = (ushort)(character.HasGodMode ? 0 : damage);
                if (character.IsSitting)
                {
                    character.IsSitting = false;
                    character.MapInstance.Broadcast(character.GenerateRest());
                }
            }
            else if (target.GetSession() is Mate mate)
            {
                if (mate.IsSitting)
                {
                    mate.IsSitting = false;
                    mate.Owner.MapInstance.Broadcast(mate.GenerateRest());
                }
            }

            int castTime = 0;

            if (skill != null && skill.CastEffect != 0)
            {
                Entity.MapInstance.Broadcast(Entity.GenerateEff(skill.CastEffect), Entity.GetPos().X,
                                             Entity.GetPos().Y);
                castTime = skill.CastTime * 100;
            }

            Observable.Timer(TimeSpan.FromMilliseconds(castTime)).Subscribe(o => TargetHit2(target, hitType, skill,
                                                                                            damage, hitmode, skillEffect, mapX, mapY, skillCombo, showTargetAnimation, isPvp));
        }
Example #5
0
            public void SummonNpc(MapInstance map)
            {
                List <MapNpc> npc = new List <MapNpc>
                {
                    new MapNpc
                    {
                        NpcVNum   = 922,
                        MapNpcId  = map.GetNextNpcId(),
                        Dialog    = 0,
                        MapId     = map.Map.MapId,
                        MapX      = 59,
                        MapY      = 40,
                        IsMoving  = false,
                        Position  = 0,
                        IsSitting = false,
                        Effect    = 3009,
                        Score     = 5
                    },
                    new MapNpc
                    {
                        NpcVNum   = 923,
                        MapNpcId  = map.GetNextNpcId(),
                        Dialog    = 0,
                        MapId     = map.Map.MapId,
                        MapX      = 74,
                        MapY      = 53,
                        IsMoving  = false,
                        Position  = 0,
                        IsSitting = false,
                        Effect    = 3009,
                        Score     = 2
                    },
                    new MapNpc
                    {
                        NpcVNum   = 923,
                        MapNpcId  = map.GetNextNpcId(),
                        Dialog    = 0,
                        MapId     = map.Map.MapId,
                        MapX      = 32,
                        MapY      = 75,
                        IsMoving  = false,
                        Position  = 0,
                        IsSitting = false,
                        Effect    = 3009,
                        Score     = 2
                    },
                    new MapNpc
                    {
                        NpcVNum   = 923,
                        MapNpcId  = map.GetNextNpcId(),
                        Dialog    = 0,
                        MapId     = map.Map.MapId,
                        MapX      = 85,
                        MapY      = 4,
                        IsMoving  = false,
                        Position  = 0,
                        IsSitting = false,
                        Effect    = 3009,
                        Score     = 2
                    },
                    new MapNpc
                    {
                        NpcVNum   = 923,
                        MapNpcId  = map.GetNextNpcId(),
                        Dialog    = 0,
                        MapId     = map.Map.MapId,
                        MapX      = 43,
                        MapY      = 26,
                        IsMoving  = false,
                        Position  = 0,
                        IsSitting = false,
                        Effect    = 3009,
                        Score     = 2
                    },
                    new MapNpc
                    {
                        NpcVNum   = 924,
                        MapNpcId  = map.GetNextNpcId(),
                        Dialog    = 0,
                        MapId     = map.Map.MapId,
                        MapX      = 15,
                        MapY      = 40,
                        IsMoving  = false,
                        Position  = 0,
                        IsSitting = false,
                        Effect    = 3009,
                        Score     = 1
                    },
                    new MapNpc
                    {
                        NpcVNum   = 924,
                        MapNpcId  = map.GetNextNpcId(),
                        Dialog    = 999,
                        MapId     = map.Map.MapId,
                        MapX      = 102,
                        MapY      = 39,
                        IsMoving  = false,
                        Position  = 0,
                        IsSitting = false,
                        Effect    = 3009,
                        Score     = 1
                    },
                };

                foreach (var Stone in npc)
                {
                    Stone.Dialog = 999;
                    Stone.Initialize(map);
                    map.AddNPC(Stone);
                    map.Broadcast(Stone.GenerateIn());
                    IEnumerable <ClientSession> sess = ServerManager.Instance.Sessions.Where(s => s.Character?.CharacterId == null);
                    foreach (ClientSession ses in sess)
                    {
                        if (Stone.Dialog == 999)
                        {
                            ses.SendPacket(UserInterfaceHelper.GenerateDelay(5000, 1, $"#guri^711^{Stone.MapNpcId}"));
                            Stone.Score++;
                            RainbowBattleManager.SendFbs();
                        }
                    }
                }
            }
Example #6
0
        internal static void GenerateTalentArena()
        {
            long        groupid = 0;
            int         seconds = 0;
            IDisposable obs     = Observable.Interval(TimeSpan.FromSeconds(1)).Subscribe(start2 =>
            {
                ServerManager.Instance.ArenaMembers.Where(s => s.ArenaType == EventType.TALENTARENA).ToList().ForEach(s =>
                {
                    s.Time -= 1;
                    List <long> groupids = new List <long>();
                    ServerManager.Instance.ArenaMembers.Where(o => o.GroupId != null).ToList().ForEach(o =>
                    {
                        if (ServerManager.Instance.ArenaMembers.Count(g => g.GroupId == o.GroupId) != 3)
                        {
                            return;
                        }
                        if (o.GroupId != null)
                        {
                            groupids.Add(o.GroupId.Value);
                        }
                    });

                    if (s.Time > 0)
                    {
                        if (s.GroupId == null)
                        {
                            List <ArenaMember> members = ServerManager.Instance.ArenaMembers
                                                         .Where(e => e.Session != s.Session && e.ArenaType == EventType.TALENTARENA && e.Session.Character.Level <= s.Session.Character.Level + 5 &&
                                                                e.Session.Character.Level >= s.Session.Character.Level - 5).ToList();
                            members.RemoveAll(o => o.GroupId != null && groupids.Contains(o.GroupId.Value));
                            ArenaMember member = members.FirstOrDefault();
                            if (member == null)
                            {
                                return;
                            }
                            {
                                if (member.GroupId == null)
                                {
                                    groupid++;
                                    member.GroupId = groupid;
                                }
                                s.GroupId = member.GroupId;
                                ServerManager.Instance.ArenaMembers.Where(e => e.ArenaType == EventType.TALENTARENA && e.GroupId == member.GroupId).ToList().ForEach(o =>
                                {
                                    o.Session.SendPacket(o.Session.Character.GenerateBsInfo(1, 2, -1, 6));
                                    o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("ARENA_TEAM_FOUND"), 10));
                                    Observable.Timer(TimeSpan.FromSeconds(1)).Subscribe(time =>
                                    {
                                        s.Time = 300;
                                        if (ServerManager.Instance.ArenaMembers.Count(g => g.GroupId == s.GroupId) < 3)
                                        {
                                            o.Session.SendPacket(o.Session.Character.GenerateBsInfo(0, 2, s.Time, 8));
                                            o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SEARCH_ARENA_TEAM"), 10));
                                        }
                                        else
                                        {
                                            o.Session.SendPacket(o.Session.Character.GenerateBsInfo(0, 2, s.Time, 1));
                                            o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SEARCH_RIVAL_ARENA_TEAM"), 10));
                                        }
                                    });
                                });
                            }
                        }
                        else
                        {
                            if (ServerManager.Instance.ArenaMembers.Count(g => g.GroupId == s.GroupId) != 3)
                            {
                                return;
                            }
                            ArenaMember member =
                                ServerManager.Instance.ArenaMembers.FirstOrDefault(o => o.GroupId != null && o.GroupId != s.GroupId && groupids.Contains(o.GroupId.Value) &&
                                                                                   o.Session.Character.Level <= s.Session.Character.Level + 5 &&
                                                                                   o.Session.Character.Level >= s.Session.Character.Level - 5);
                            if (member == null)
                            {
                                return;
                            }

                            MapInstance map = ServerManager.Instance.GenerateMapInstance(2015, MapInstanceType.TalentArenaMapInstance, new InstanceBag());
                            ConcurrentBag <ArenaTeamMember> arenaTeam = new ConcurrentBag <ArenaTeamMember>();
                            ServerManager.Instance.ArenaTeams.Add(arenaTeam);

                            ArenaMember[] arenamembers = ServerManager.Instance.ArenaMembers.Where(o => o.GroupId == member.GroupId || o.GroupId == s.GroupId).OrderBy(o => o.GroupId)
                                                         .ToArray();
                            for (int i = 0; i < 6; i++)
                            {
                                ItemInstance item = Inventory.InstantiateItemInstance((short)(4433 + (i > 2 ? 5 - i : i)), member.Session.Character.CharacterId);
                                item.Design       = (short)(4433 + (i > 2 ? 5 - i : i));
                                map.MapDesignObjects.Add(new MapDesignObject
                                {
                                    ItemInstance   = item,
                                    ItemInstanceId = item.Id,
                                    CharacterId    = member.Session.Character.CharacterId,
                                    MapX           = (short)(i > 2 ? 120 : 19),
                                    MapY           = (short)(i > 2 ? 35 + i % 3 * 4 : 36 + i % 3 * 4)
                                });
                            }
                            map.InstanceBag.Clock.BasesSecondRemaining = 60;
                            map.InstanceBag.Clock.DeciSecondRemaining  = 600;
                            map.InstanceBag.Clock.StartClock();
                            IDisposable obs4 = null;
                            IDisposable obs2 = null;
                            IDisposable obs3 = null;
                            IDisposable obs6 = null;
                            Observable.Timer(TimeSpan.FromSeconds(5)).Subscribe(time2 =>
                            {
                                obs3 = Observable.Interval(TimeSpan.FromSeconds(5)).Subscribe(effect =>
                                {
                                    arenamembers.ToList().ForEach(o => map.Broadcast(o.Session.Character.GenerateEff(o.GroupId == s.GroupId ? 3012 : 3013)));
                                });
                            });
                            IDisposable obs5 = Observable.Interval(TimeSpan.FromMilliseconds(500)).Subscribe(start3 =>
                            {
                                map.Broadcast(arenamembers.FirstOrDefault(o => o.Session != null)?.Session.Character.GenerateTaPs());
                                List <ArenaTeamMember> erenia = arenaTeam.Where(team => team.ArenaTeamType == ArenaTeamType.ERENIA).ToList();
                                List <ArenaTeamMember> zenas  = arenaTeam.Where(team => team.ArenaTeamType == ArenaTeamType.ZENAS).ToList();
                                BuffTeam(erenia);
                                BuffTeam(zenas);
                            });
                            arenamembers.ToList().ForEach(o =>
                            {
                                o.Session.SendPacket(o.Session.Character.GenerateBsInfo(0, 2, s.Time, 2));
                                o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("RIVAL_ARENA_TEAM_FOUND"), 10));

                                Observable.Timer(TimeSpan.FromSeconds(1)).Subscribe(time =>
                                {
                                    o.Session.SendPacket("ta_close");
                                    Observable.Timer(TimeSpan.FromSeconds(5)).Subscribe(time2 =>
                                    {
                                        o.Session.Character.Mates.Where(m => m.IsTeamMember).ToList().ForEach(m => m.IsTeamMember = false);
                                        o.Session.Character.GeneralLogs.Add(new GeneralLogDTO
                                        {
                                            AccountId   = o.Session.Account.AccountId,
                                            CharacterId = o.Session.Character.CharacterId,
                                            IpAddress   = o.Session.IpAddress,
                                            LogData     = "Entry",
                                            LogType     = "TalentArena",
                                            Timestamp   = DateTime.Now
                                        });
                                        List <BuffType> bufftodisable = new List <BuffType> {
                                            BuffType.Bad, BuffType.Good, BuffType.Neutral
                                        };
                                        o.Session.Character.DisableBuffs(bufftodisable);
                                        int i = Array.IndexOf(arenamembers, o) + 1;
                                        o.Session.Character.Hp = (int)o.Session.Character.HPLoad();
                                        o.Session.Character.Mp = (int)o.Session.Character.MPLoad();
                                        ServerManager.Instance.ChangeMapInstance(o.Session.Character.CharacterId, map.MapInstanceId, o.GroupId == member.GroupId ? 125 : 14,
                                                                                 (o.GroupId == member.GroupId ? 37 : 38) + i % 3 * 2);
                                        o.Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("SELECT_ORDER_ARENA_TIME"), 0));
                                        o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SELECT_ORDER_ARENA_TIME"), 10));
                                        o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SELECT_ORDER_ARENA"), 10));
                                        o.Session.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("SELECT_ORDER_ARENA"), 0));
                                        o.Session.SendPacket(o.Session.Character.GenerateTaM(0));
                                        o.Session.SendPacket("ta_sv 0");
                                        o.Session.SendPacket(UserInterfaceHelper.Instance.GenerateTaSt(TalentArenaOptionType.Watch));
                                        o.Session.SendPacket(o.Session.Character.GenerateTaM(3));


                                        o.Session.SendPacket(o.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey(o.GroupId == s.GroupId ? "ZENAS" : "ERENIA"), 10));
                                        arenaTeam.Add(new ArenaTeamMember(o.Session, o.GroupId == s.GroupId ? ArenaTeamType.ZENAS : ArenaTeamType.ERENIA, null));
                                        o.Session.SendPacket(o.Session.Character.GenerateTaP(0, false));

                                        obs2 = Observable.Interval(TimeSpan.FromMilliseconds(100)).Subscribe(start3 =>
                                        {
                                            bool resettap = false;
                                            map.MapDesignObjects.ToList().ForEach(e =>
                                            {
                                                if (e.ItemInstance.Design >= 4433 && e.ItemInstance.Design <= 4435)
                                                {
                                                    Character chara = map.GetCharactersInRange(e.MapX, e.MapY, 0).FirstOrDefault();
                                                    if (chara != null)
                                                    {
                                                        resettap = true;
                                                        ArenaTeamMember teammember = arenaTeam.FirstOrDefault(at => at.Session == chara.Session);
                                                        if (teammember != null &&
                                                            !arenaTeam.Any(at => at.Order == (e.ItemInstance.ItemVNum - 4433) &&
                                                                           at.ArenaTeamType == (e.MapX == 120 ? ArenaTeamType.ERENIA : ArenaTeamType.ZENAS)))
                                                        {
                                                            if (teammember.Order != null)
                                                            {
                                                                MapDesignObject obj =
                                                                    map.MapDesignObjects.FirstOrDefault(mapobj => mapobj.ItemInstance.ItemVNum == e.ItemInstance.ItemVNum &&
                                                                                                        e.MapX == (teammember.ArenaTeamType == ArenaTeamType.ERENIA ? 120 : 19));
                                                                if (obj != null)
                                                                {
                                                                    obj.ItemInstance.Design = obj.ItemInstance.ItemVNum;
                                                                }
                                                            }
                                                            teammember.Order = (byte)(e.ItemInstance.ItemVNum - 4433);
                                                        }
                                                    }
                                                }
                                                else if (e.ItemInstance.Design == 4436)
                                                {
                                                    if (!map.GetCharactersInRange(e.MapX, e.MapY, 0).Any())
                                                    {
                                                        resettap = true;
                                                        ArenaTeamMember teammember = arenaTeam.FirstOrDefault(at =>
                                                                                                              at.Order == (e.ItemInstance.ItemVNum - 4433) && at.ArenaTeamType == (e.MapX == 120 ? ArenaTeamType.ERENIA : ArenaTeamType.ZENAS));
                                                        if (teammember != null)
                                                        {
                                                            teammember.Order = null;
                                                        }
                                                    }
                                                }
                                                if (!arenaTeam.Any(at => at.Order == (e.ItemInstance.ItemVNum - 4433) && at.ArenaTeamType == (e.MapX == 120 ? ArenaTeamType.ERENIA : ArenaTeamType.ZENAS)))
                                                {
                                                    if (e.ItemInstance.Design != 4436)
                                                    {
                                                        return;
                                                    }
                                                    e.ItemInstance.Design = e.ItemInstance.ItemVNum;
                                                    map.Broadcast(e.GenerateEffect(false));
                                                }
                                                else if (e.ItemInstance.Design != 4436)
                                                {
                                                    e.ItemInstance.Design = 4436;
                                                    map.Broadcast(e.GenerateEffect(false));
                                                }
                                            });

                                            if (resettap)
                                            {
                                                arenaTeam.ToList().ForEach(arenauser => { arenauser.Session.SendPacket(arenauser.Session.Character.GenerateTaP(2, false)); });
                                            }
                                        });

                                        Observable.Timer(TimeSpan.FromSeconds(map.InstanceBag.Clock.BasesSecondRemaining)).Subscribe(start =>
                                        {
                                            obs2.Dispose();
                                            arenaTeam.ToList().ForEach(arenauser =>
                                            {
                                                if (arenauser.Order == null)
                                                {
                                                    for (byte x = 0; x < 3; x++)
                                                    {
                                                        if (!arenaTeam.Any(at => at.ArenaTeamType == arenauser.ArenaTeamType && at.Order == x))
                                                        {
                                                            arenauser.Order = x;
                                                        }
                                                    }
                                                }
                                                arenauser.Session.SendPacket($"ta_pn {arenauser.Order + 1}");
                                                arenauser.Session.SendPacket(arenauser.Session.Character.GenerateTaP(2, true));
                                            });
                                            map.MapDesignObjects.ToList().ForEach(md => map.Broadcast(md.GenerateEffect(true)));
                                            map.MapDesignObjects.Clear();
                                        });
                                    });
                                });
                            });
                            Observable.Timer(TimeSpan.FromSeconds(map.InstanceBag.Clock.BasesSecondRemaining)).Subscribe(start =>
                            {
                                bool newround1   = true;
                                bool newround2   = true;
                                int count1       = 0;
                                int count2       = 0;
                                IDisposable obs7 = obs4;
                                obs4             = Observable.Interval(TimeSpan.FromMilliseconds(500)).Subscribe(start3 =>
                                {
                                    int ereniacount = arenaTeam.Count(at => at.Dead && at.ArenaTeamType == ArenaTeamType.ERENIA);
                                    int zenascount  = arenaTeam.Count(at => at.Dead && at.ArenaTeamType == ArenaTeamType.ZENAS);
                                    if (count1 != ereniacount || count2 != zenascount)
                                    {
                                        if (count1 != ereniacount)
                                        {
                                            newround1 = true;
                                        }
                                        if (count2 != zenascount)
                                        {
                                            newround2 = true;
                                        }
                                        count1 = ereniacount;
                                        count2 = zenascount;
                                    }

                                    ArenaTeamMember tm  = arenaTeam.OrderBy(tm3 => tm3.Order).FirstOrDefault(tm3 => tm3.ArenaTeamType == ArenaTeamType.ERENIA && !tm3.Dead);
                                    ArenaTeamMember tm2 = arenaTeam.OrderBy(tm3 => tm3.Order).FirstOrDefault(tm3 => tm3.ArenaTeamType == ArenaTeamType.ZENAS && !tm3.Dead);

                                    if (!newround1 && !newround2)
                                    {
                                        return;
                                    }
                                    map.InstanceBag.Clock.BasesSecondRemaining = 300;
                                    map.InstanceBag.Clock.DeciSecondRemaining  = 3000;
                                    arenaTeam.ToList().ForEach(friends =>
                                    {
                                        friends.Session.SendPacket(friends.Session.Character.GenerateTaM(2));
                                        friends.Session.SendPacket(friends.Session.Character.GenerateTaM(3));
                                    });
                                    map.Sessions.Except(arenaTeam.Select(ss => ss.Session)).ToList().ForEach(o =>
                                    {
                                        o.SendPacket(tm2?.Session.Character.GenerateTaM(2));
                                        o.SendPacket(tm2?.Session.Character.GenerateTaM(3));
                                    });

                                    obs6?.Dispose();
                                    obs6 = Observable.Timer(TimeSpan.FromSeconds(map.InstanceBag.Clock.BasesSecondRemaining)).Subscribe(start4 =>
                                    {
                                        if (tm2 != null && tm != null)
                                        {
                                            tm.Dead  = true;
                                            tm2.Dead = true;
                                            tm.Session.Character.PositionX  = 120;
                                            tm.Session.Character.PositionY  = 39;
                                            tm2.Session.Character.PositionX = 19;
                                            tm2.Session.Character.PositionY = 40;
                                            map.Broadcast(tm2.Session, tm.Session.Character.GenerateTp());
                                            map.Broadcast(tm2.Session, tm2.Session.Character.GenerateTp());
                                            tm.Session.SendPacket(UserInterfaceHelper.Instance.GenerateTaSt(TalentArenaOptionType.Watch));
                                            tm2.Session.SendPacket(UserInterfaceHelper.Instance.GenerateTaSt(TalentArenaOptionType.Watch));
                                            arenaTeam.Where(friends => friends.ArenaTeamType == tm.ArenaTeamType).ToList().ForEach(friends =>
                                            {
                                                friends.Session.SendPacket(friends.Session.Character.GenerateTaFc(0));
                                            });
                                        }
                                        newround1 = true;
                                        newround2 = true;
                                        arenaTeam.ToList().ForEach(arenauser => { arenauser.Session.SendPacket(arenauser.Session.Character.GenerateTaP(2, true)); });
                                    });

                                    if (tm != null && tm2 != null)
                                    {
                                        map.IsPVP = false;
                                        arenaTeam.Where(at => at.LastSummoned != null).ToList().ForEach(at =>
                                        {
                                            at.LastSummoned = null;
                                            at.Session.Character.PositionX = at.ArenaTeamType == ArenaTeamType.ERENIA ? (short)120 : (short)19;
                                            at.Session.Character.PositionY = at.ArenaTeamType == ArenaTeamType.ERENIA ? (short)39 : (short)40;
                                            at.Session.CurrentMapInstance.Broadcast(at.Session.Character.GenerateTp());
                                            at.Session.SendPacket(UserInterfaceHelper.Instance.GenerateTaSt(TalentArenaOptionType.Watch));
                                        });
                                        if (newround1)
                                        {
                                            map.Broadcast(tm.Session.Character.GenerateTaFc(1));
                                            tm.Session.Character.PositionX = 87;
                                            tm.Session.Character.PositionY = 39;
                                            map.Broadcast(tm.Session, tm.Session.Character.GenerateTp());
                                        }

                                        if (newround2)
                                        {
                                            tm2.Session.Character.PositionX = 56;
                                            tm2.Session.Character.PositionY = 40;
                                            map.Broadcast(tm2.Session, tm2.Session.Character.GenerateTp());
                                        }

                                        arenaTeam.ToList().ForEach(friends =>
                                        {
                                            friends.Session.SendPacket(friends.ArenaTeamType == ArenaTeamType.ERENIA
                                                ? tm.Session.Character.GenerateTaFc(0)
                                                : tm2.Session.Character.GenerateTaFc(0));
                                        });

                                        map.Sessions.Except(arenaTeam.Select(ss => ss.Session)).ToList().ForEach(ss =>
                                        {
                                            ss.SendPacket(tm.Session.Character.GenerateTaFc(0));
                                            ss.SendPacket(tm2.Session.Character.GenerateTaFc(1));
                                        });

                                        tm.Session.SendPacket(UserInterfaceHelper.Instance.GenerateTaSt(TalentArenaOptionType.Call));
                                        tm2.Session.SendPacket(UserInterfaceHelper.Instance.GenerateTaSt(TalentArenaOptionType.Call));

                                        map.Broadcast("ta_s");
                                        Observable.Timer(TimeSpan.FromSeconds(5)).Subscribe(start4 => { map.IsPVP = true; });
                                    }
                                    else
                                    {
                                        switch (tm)
                                        {
                                        case null when tm2 == null:
                                            map.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("EQUALITY"), 0));
                                            arenaTeam.ToList().ForEach(arenauser =>
                                            {
                                                arenauser.Session.SendPacket(arenauser.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("EQUALITY"), 10));
                                                arenauser.Session.SendPacket(arenauser.Session.Character.GenerateTaF(3));
                                            });
                                            map.Sessions.Except(arenamembers.Select(x => x.Session)).ToList().ForEach(
                                                x =>
                                            {
                                                ArenaTeamMember arenauser = arenaTeam.FirstOrDefault(se => se.Session != null);
                                                if (arenauser == null)
                                                {
                                                    return;
                                                }
                                                x.SendPacket(arenauser.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("EQUALITY"), 10));
                                                x.SendPacket(arenauser.Session.Character.GenerateTaF(0));
                                            }
                                                );
                                            break;

                                        case null:
                                            map.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("VICTORIOUS_ZENAS"), 0));

                                            arenaTeam.ToList().ForEach(arenauser =>
                                            {
                                                SendRewards(arenauser, arenauser.ArenaTeamType == ArenaTeamType.ZENAS);
                                            });
                                            map.Sessions.Except(arenamembers.Select(x => x.Session)).ToList().ForEach(x =>
                                            {
                                                ArenaTeamMember arenauser = arenaTeam.FirstOrDefault(se => se.Session != null);
                                                if (arenauser == null)
                                                {
                                                    return;
                                                }
                                                x.SendPacket(arenauser.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("VICTORIOUS_ZENAS"), 10));
                                                x.SendPacket(arenauser.Session.Character.GenerateTaF(1));
                                            });
                                            break;

                                        default:
                                            map.Broadcast(UserInterfaceHelper.Instance.GenerateMsg(Language.Instance.GetMessageFromKey("VICTORIOUS_ERENIA"), 0));
                                            arenaTeam.ToList().ForEach(arenauser =>
                                            {
                                                SendRewards(arenauser, arenauser.ArenaTeamType == ArenaTeamType.ERENIA);
                                            });
                                            map.Sessions.Except(arenamembers.Select(x => x.Session)).ToList().ForEach(
                                                x =>
                                            {
                                                ArenaTeamMember arenauser = arenaTeam.FirstOrDefault(se => se.Session != null);
                                                if (arenauser == null)
                                                {
                                                    return;
                                                }
                                                x.SendPacket(arenauser.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("VICTORIOUS_ERENIA"), 10));
                                                x.SendPacket(arenauser.Session.Character.GenerateTaF(2));
                                            }
                                                );
                                            break;
                                        }
                                        obs3.Dispose();
                                        obs2.Dispose();
                                        obs7?.Dispose();
                                        obs5.Dispose();
                                        Observable.Timer(TimeSpan.FromSeconds(30)).Subscribe(start4 =>
                                        {
                                            map.Dispose();
                                            arenaTeam.ToList().ForEach(o =>
                                            {
                                                if (o.Session?.CurrentMapInstance?.MapInstanceType == MapInstanceType.TalentArenaMapInstance)
                                                {
                                                    ServerManager.Instance.TeleportOnRandomPlaceInMap(o.Session, ServerManager.Instance.ArenaInstance.MapInstanceId);
                                                }
                                            });
                                        });
                                    }
                                    newround1 = false;
                                    newround2 = false;
                                });
                            });
                            ServerManager.Instance.ArenaMembers.Where(o => o.GroupId == member.GroupId || o.GroupId == s.GroupId).ToList()
                            .ForEach(se => { se.Session.SendPacket(se.Session.Character.GenerateBsInfo(2, 2, 0, 0)); });

                            ServerManager.Instance.ArenaMembers.RemoveAll(o => o.GroupId == member.GroupId || o.GroupId == s.GroupId);
                        }
                    }
                    else
                    {
                        if (s.GroupId == null)
                        {
                            if (s.Time != -1)
                            {
                                s.Session.SendPacket(s.Session.Character.GenerateBsInfo(1, 2, s.Time, 7));
                                s.Session.SendPacket(s.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("NO_TEAM_ARENA"), 10));
                            }
                            s.Time = 300;
                            s.Session.SendPacket(s.Session.Character.GenerateBsInfo(1, 2, s.Time, 5));
                            s.Session.SendPacket(s.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SEARCH_ARENA_TEAM"), 10));
                        }
                        else if (ServerManager.Instance.ArenaMembers.Count(g => g.GroupId == s.GroupId) < 3)
                        {
                            s.Session.SendPacket(s.Session.Character.GenerateBsInfo(1, 2, -1, 4));
                            Observable.Timer(TimeSpan.FromSeconds(1)).Subscribe(time =>
                            {
                                s.Time = 300;
                                s.Session.SendPacket(s.Session.Character.GenerateBsInfo(1, 2, s.Time, 8));
                                s.Session.SendPacket(s.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("RETRY_SEARCH_ARENA_TEAM"), 10));
                            });
                        }
                        else
                        {
                            s.Session.SendPacket(s.Session.Character.GenerateBsInfo(0, 2, -1, 3));
                            Observable.Timer(TimeSpan.FromSeconds(1)).Subscribe(time =>
                            {
                                s.Time = 300;
                                s.Session.SendPacket(s.Session.Character.GenerateBsInfo(0, 2, s.Time, 1));
                                s.Session.SendPacket(s.Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("SEARCH_RIVAL_ARENA_TEAM"), 10));
                            });
                        }
                    }
                });
                seconds++;
            });

            Observable.Timer(TimeSpan.FromHours(7)).Subscribe(start2 =>
            {
                ServerManager.Instance.StartedEvents.Remove(EventType.TALENTARENA);
                obs.Dispose();
            });
        }
Example #7
0
        public void GenerateRaid(byte type, byte faction)
        {
            Act4Guardians = new List <MapMonster>();
            ScriptedInstance raid  = ServerManager.Instance.Act4Raids.FirstOrDefault(r => r.Id == type);
            MapInstance      lobby = ServerManager.Instance.Act4Maps.FirstOrDefault(m => m.Map.MapId == 134);

            if (raid == null || lobby == null)
            {
                Logger.Log.Error(raid == null ? $"Act4 raids is missing - type : {type}" : "There is no map in Act4Maps with MapId == 134");
                return;
            }

            ServerManager.Instance.Act4RaidStart = DateTime.Now;

            lobby.CreatePortal(new Portal
            {
                SourceMapId = 134,
                SourceX     = 139,
                SourceY     = 100,
                Type        = (short)(9 + faction)
            }, 3600, true);

            #region Guardian Spawning

            Act4Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 147,
                MapY          = 88,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = lobby.GetNextId(),
                ShouldRespawn = false,
                IsHostile     = true
            });
            Act4Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 149,
                MapY          = 94,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = lobby.GetNextId(),
                ShouldRespawn = false,
                IsHostile     = true
            });
            Act4Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 147,
                MapY          = 101,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = lobby.GetNextId(),
                ShouldRespawn = false,
                IsHostile     = true
            });
            Act4Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 139,
                MapY          = 105,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = lobby.GetNextId(),
                ShouldRespawn = false,
                IsHostile     = true
            });
            Act4Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 132,
                MapY          = 101,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = lobby.GetNextId(),
                ShouldRespawn = false,
                IsHostile     = true
            });
            Act4Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 129,
                MapY          = 94,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = lobby.GetNextId(),
                ShouldRespawn = false,
                IsHostile     = true
            });
            Act4Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 132,
                MapY          = 88,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = lobby.GetNextId(),
                ShouldRespawn = false,
                IsHostile     = true
            });

            foreach (MapMonster monster in Act4Guardians)
            {
                if (monster == null)
                {
                    continue;
                }

                monster.Initialize();
                lobby.AddMonster(monster);
                lobby.Broadcast(monster.GenerateIn());
            }

            Observable.Timer(TimeSpan.FromMinutes(60)).Subscribe(s =>
            {
                foreach (MapMonster monster in Act4Guardians)
                {
                    lobby.RemoveMonster(monster);
                    lobby.Broadcast(monster.GenerateOut());
                }
                Act4Guardians.Clear();
            });

            #endregion

            foreach (MapInstance map in ServerManager.Instance.Act4Maps)
            {
                map.Sessions.Where(s => s?.Character?.Faction == (FactionType)faction).ToList().ForEach(s =>
                                                                                                        s.SendPacket(UserInterfaceHelper.Instance.GenerateMsg(string.Format(Language.Instance.GetMessageFromKey("ACT4_RAID_OPEN"), ((Act4RaidType)type).ToString()), 0)));
            }

            lock (ServerManager.Instance.FamilyList)
            {
                foreach (Family family in ServerManager.Instance.FamilyList.GetAllItems())
                {
                    if (family == null)
                    {
                        continue;
                    }
                    family.Act4Raid = ServerManager.Instance.Act4Raids.FirstOrDefault(r => r.Id == type)?.GetClone();
                    family.Act4Raid?.LoadScript(MapInstanceType.RaidInstance);
                    if (family.Act4Raid?.FirstMap == null)
                    {
                        continue;
                    }
                    family.Act4Raid.FirstMap.InstanceBag.Lock = true;
                }
            }

            Observable.Timer(TimeSpan.FromSeconds(3600)).Subscribe(s =>
            {
                foreach (Family family in ServerManager.Instance.FamilyList.GetAllItems())
                {
                    if (family == null)
                    {
                        continue;
                    }
                    family.Act4Raid?.MapInstanceDictionary?.Values.ToList().ForEach(m => m?.Dispose());
                    family.Act4Raid = null;
                }
            });
        }
Example #8
0
            private void runRound(int number)
            {
                if (number == 6)
                {
                    endEvent();
                }

                int amount = 120 + (60 * number);

                int i = amount;

                while (i != 0)
                {
                    spawnCircle(number);
                    Thread.Sleep(60000 / amount);
                    i--;
                }
                Thread.Sleep(5000);
                string round = "";

                switch (number)
                {
                case 1:
                    round = "first";
                    _map.Broadcast(UserInterfaceHelper.GenerateMsg(string.Format(Language.Instance.GetMessageFromKey("TOURNAMENT_ROUND"), round), 0));
                    break;

                case 2:
                    round = "second";
                    _map.Broadcast(UserInterfaceHelper.GenerateMsg(string.Format(Language.Instance.GetMessageFromKey("TOURNAMENT_ROUND"), round), 0));
                    break;

                case 3:
                    round = "three";
                    _map.Broadcast(UserInterfaceHelper.GenerateMsg(string.Format(Language.Instance.GetMessageFromKey("TOURNAMENT_ROUND"), round), 0));
                    break;

                case 4:
                    round = "fourth";
                    _map.Broadcast(UserInterfaceHelper.GenerateMsg(string.Format(Language.Instance.GetMessageFromKey("TOURNAMENT_ROUND"), round), 0));
                    break;

                case 5:
                    round = "ultimate";
                    _map.Broadcast(UserInterfaceHelper.GenerateMsg(string.Format(Language.Instance.GetMessageFromKey("TOURNAMENT_ROUND"), round), 0));
                    break;
                }

                Thread.Sleep(5000);

                // Your dropped reward
                _map.DropItems(generateDrop(_map.Map, 1046, 20, 200 * ((number + 1) > 10 ? 10 : (number + 1))).ToList());
                _map.DropItems(generateDrop(_map.Map, 1030, 10, 3 * ((number + 1) > 10 ? 10 : (number + 1))).ToList());
                _map.DropItems(generateDrop(_map.Map, 2282, 10, 3 * ((number + 1) > 10 ? 10 : (number + 1))).ToList());
                _map.DropItems(generateDrop(_map.Map, 2514, 5, 1 * ((number + 1) > 10 ? 10 : (number + 1))).ToList());
                _map.DropItems(generateDrop(_map.Map, 2515, 5, 1 * ((number + 1) > 10 ? 10 : (number + 1))).ToList());
                _map.DropItems(generateDrop(_map.Map, 2516, 5, 1 * ((number + 1) > 10 ? 10 : (number + 1))).ToList());
                _map.DropItems(generateDrop(_map.Map, 2517, 5, 1 * ((number + 1) > 10 ? 10 : (number + 1))).ToList());
                _map.DropItems(generateDrop(_map.Map, 2518, 5, 1 * ((number + 1) > 10 ? 10 : (number + 1))).ToList());
                _map.DropItems(generateDrop(_map.Map, 2519, 5, 1 * ((number + 1) > 10 ? 10 : (number + 1))).ToList());
                _map.DropItems(generateDrop(_map.Map, 2520, 5, 1 * ((number + 1) > 10 ? 10 : (number + 1))).ToList());
                _map.DropItems(generateDrop(_map.Map, 2521, 5, 1 * ((number + 1) > 10 ? 10 : (number + 1))).ToList());
                foreach (ClientSession session in _map.Sessions)
                {
                    // Your reward that every player should get
                }

                Thread.Sleep(30000);
            }
Example #9
0
        public static void GenerateRaida(MapInstanceType raidType, byte faction)
        {
            Guardians = new List <MapMonster>();
            MapInstance bitoren = ServerManager.GetMapInstance(ServerManager.GetBaseMapInstanceIdByMapId(134));

            bitoren.CreatePortal(new Portal
            {
                SourceMapId      = 134,
                SourceX          = 140,
                SourceY          = 100,
                DestinationMapId = 0,
                DestinationX     = 1,
                DestinationY     = 1,
                Type             = (short)(9 + faction)
            });

            #region Guardian Spawning

            Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 147,
                MapY          = 88,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = bitoren.GetNextMonsterId(),
                ShouldRespawn = false,
                IsHostile     = true
            });
            Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 149,
                MapY          = 94,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = bitoren.GetNextMonsterId(),
                ShouldRespawn = false,
                IsHostile     = true
            });
            Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 147,
                MapY          = 101,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = bitoren.GetNextMonsterId(),
                ShouldRespawn = false,
                IsHostile     = true
            });
            Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 139,
                MapY          = 105,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = bitoren.GetNextMonsterId(),
                ShouldRespawn = false,
                IsHostile     = true
            });
            Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 132,
                MapY          = 101,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = bitoren.GetNextMonsterId(),
                ShouldRespawn = false,
                IsHostile     = true
            });
            Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 129,
                MapY          = 94,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = bitoren.GetNextMonsterId(),
                ShouldRespawn = false,
                IsHostile     = true
            });
            Guardians.Add(new MapMonster
            {
                MonsterVNum   = (short)(678 + faction),
                MapX          = 132,
                MapY          = 88,
                MapId         = 134,
                Position      = 2,
                IsMoving      = false,
                MapMonsterId  = bitoren.GetNextMonsterId(),
                ShouldRespawn = false,
                IsHostile     = true
            });

            #endregion

            foreach (MapMonster monster in Guardians)
            {
                monster.Initialize(bitoren);
                bitoren.AddMonster(monster);
                bitoren.Broadcast(monster.GenerateIn());
            }

            Act4RaidThread raidThread = new Act4RaidThread();
            Observable.Timer(TimeSpan.FromMinutes(0)).Subscribe(X => raidThread.Run(raidType, faction));
        }