Ejemplo n.º 1
0
        //*********************************************************************************************
        // ThrowNpc / Revisto pela última vez em 01/08/2016, criado por Allyson S. Bacon
        // Empurra determinado NPC para determinada direção e distância
        //*********************************************************************************************
        public static void throwNpc(int Map, int s, int dir, int range)
        {
            //EXTEND
            if (Extensions.ExtensionApp.extendMyApp
                    (MethodBase.GetCurrentMethod().Name, Map, s, dir, range) != null)
            {
                return;
            }

            //CÓDIGO
            switch (dir)
            {
            case 8:
                NpcStruct.tempnpc[Map, s].Y = Convert.ToByte(NpcStruct.tempnpc[Map, s].Y - range);
                break;

            case 2:
                NpcStruct.tempnpc[Map, s].Y = Convert.ToByte(NpcStruct.tempnpc[Map, s].Y + range);
                break;

            case 4:
                NpcStruct.tempnpc[Map, s].X = Convert.ToByte(NpcStruct.tempnpc[Map, s].X - range);
                break;

            case 6:
                NpcStruct.tempnpc[Map, s].X = Convert.ToByte(NpcStruct.tempnpc[Map, s].X + range);
                break;

            default:
                WinsockAsync.Log(String.Format("Direção nula"));
                break;
            }

            SendData.sendKnockBack(Map, 2, s, dir, range);
        }
Ejemplo n.º 2
0
        //*********************************************************************************************
        // CanplayerAttackNpc / Revisto pela última vez em 01/08/2016, criado por Allyson S. Bacon
        // Verifica se determinado jogador pode atacar determinado npc no contexto em que está
        //*********************************************************************************************
        public static bool canPlayerAttackNpc(int Attacker, int Victim)
        {
            //EXTEND
            if (Extensions.ExtensionApp.extendMyApp
                    (MethodBase.GetCurrentMethod().Name, Attacker, Victim) != null)
            {
                return(Convert.ToBoolean(Extensions.ExtensionApp.extendMyApp
                                             (MethodBase.GetCurrentMethod().Name, Attacker, Victim)));
            }

            //CÓDIGO
            int Map     = character[Attacker, player[Attacker].SelectedChar].Map;
            int Dir     = character[Attacker, player[Attacker].SelectedChar].Dir;
            int NpcX    = 0;
            int NpcY    = 0;
            int PlayerX = character[Attacker, player[Attacker].SelectedChar].X;
            int PlayerY = character[Attacker, player[Attacker].SelectedChar].Y;

            if (NpcStruct.tempnpc[Map, Victim].Dead == true)
            {
                return(false);
            }
            //if (NpcStruct.tempnpc[Map, Victim].guildnum == character[Attacker, player[Attacker].SelectedChar].Guild) { return false; }

            switch (Dir)
            {
            case 8:
                NpcX = NpcStruct.tempnpc[Map, Victim].X;
                NpcY = NpcStruct.tempnpc[Map, Victim].Y + 1;
                break;

            case 2:
                NpcX = NpcStruct.tempnpc[Map, Victim].X;
                NpcY = NpcStruct.tempnpc[Map, Victim].Y - 1;
                break;

            case 4:
                NpcX = NpcStruct.tempnpc[Map, Victim].X + 1;
                NpcY = NpcStruct.tempnpc[Map, Victim].Y;
                break;

            case 6:
                NpcX = NpcStruct.tempnpc[Map, Victim].X - 1;
                NpcY = NpcStruct.tempnpc[Map, Victim].Y;
                break;

            default:
                WinsockAsync.Log(String.Format("Direção nula"));
                return(false);
            }

            if ((NpcX == PlayerX) && (NpcY == PlayerY))
            {
                return(true);
            }

            return(false);
        }
Ejemplo n.º 3
0
        //*********************************************************************************************
        // PlayerMove / Revisto pela última vez em 01/08/2016, criado por Allyson S. Bacon
        // Move determinado jogador para determinada posição
        //*********************************************************************************************
        public static void playerMove(int s, byte Dir)
        {
            //EXTEND
            if (Extensions.ExtensionApp.extendMyApp
                    (MethodBase.GetCurrentMethod().Name, s, Dir) != null)
            {
                return;
            }

            //CÓDIGO
            if (PlayerStruct.tempplayer[s].Warping)
            {
                return;
            }
            //Tentamos nos mover
            switch (Dir)
            {
            case 8:
                PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].Y   = Convert.ToByte(Convert.ToInt32(PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].Y) - 1);
                PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].Dir = Globals.DirUp;
                break;

            case 2:
                PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].Y   = Convert.ToByte(Convert.ToInt32(PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].Y) + 1);
                PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].Dir = Globals.DirDown;
                break;

            case 4:
                PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].X   = Convert.ToByte(Convert.ToInt32(PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].X) - 1);
                PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].Dir = Globals.DirLeft;
                break;

            case 6:
                PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].X   = Convert.ToByte(Convert.ToInt32(PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].X) + 1);
                PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].Dir = Globals.DirRight;
                break;

            default:
                WinsockAsync.Log(String.Format("Direção nula"));
                break;
            }

            int map = Convert.ToInt32(PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].Map);
            int x   = Convert.ToInt32(PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].X);
            int y   = Convert.ToInt32(PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].Y);

            //Verifica os tipos de tiles
            if (MapStruct.tile[map, x, y].Data1 == "2")
            {
                PlayerStruct.tempplayer[s].Warping = true;
                playerWarp(s, Convert.ToInt32(MapStruct.tile[map, x, y].Data2), Convert.ToByte(MapStruct.tile[map, x, y].Data3), Convert.ToByte(MapStruct.tile[map, x, y].Data4));
                return;
            }

            //Se nenhum tile tem ação, enviar as novas coordenadas do jogador após o movimento
            SendData.sendPlayerXY(s);
            SendData.sendPlayerDir(s, 1);
        }
Ejemplo n.º 4
0
        //*********************************************************************************************
        // ConsoleEventCallBack / Revisto pela última vez em 01/08/2016, criado por Allyson S. Bacon
        // Desconectar usuários antes de fechar o servidor.
        //*********************************************************************************************
        static bool ConsoleEventCallback(int eventType)
        {
            //EXTEND
            if (Extensions.ExtensionApp.extendMyApp
                    (MethodBase.GetCurrentMethod().Name, eventType) != null)
            {
                return(Convert.ToBoolean(Extensions.ExtensionApp.extendMyApp
                                             (MethodBase.GetCurrentMethod().Name, eventType)));
            }

            //CÓDIGO
            if (eventType == 2)
            {
                for (int i = 0; i <= WinsockAsync.Clients.Count; i++)
                {
                    WinsockAsync.disconnectUser(i);
                }
            }
            return(false);
        }
Ejemplo n.º 5
0
        //*********************************************************************************************
        // ThrowPlayer / Revisto pela última vez em 01/08/2016, criado por Allyson S. Bacon
        // Empurra determinado jogador para determinada direção e distância
        //*********************************************************************************************
        public static void throwPlayer(int s, int dir, int range)
        {
            //EXTEND
            if (Extensions.ExtensionApp.extendMyApp
                    (MethodBase.GetCurrentMethod().Name, s, dir, range) != null)
            {
                return;
            }

            //CÓDIGO
            int map = character[s, player[s].SelectedChar].Map;
            int x   = character[s, player[s].SelectedChar].X;
            int y   = character[s, player[s].SelectedChar].Y;

            switch (dir)
            {
            case 8:
                character[s, player[s].SelectedChar].Y = Convert.ToByte(Convert.ToInt32(character[s, player[s].SelectedChar].Y) - range);
                break;

            case 2:
                character[s, player[s].SelectedChar].Y = Convert.ToByte(Convert.ToInt32(character[s, player[s].SelectedChar].Y) + range);
                break;

            case 4:
                character[s, player[s].SelectedChar].X = Convert.ToByte(Convert.ToInt32(character[s, player[s].SelectedChar].X) - range);
                break;

            case 6:
                character[s, player[s].SelectedChar].X = Convert.ToByte(Convert.ToInt32(character[s, player[s].SelectedChar].X) + range);
                break;

            default:
                WinsockAsync.Log(String.Format("Direção nula"));
                break;
            }

            SendData.sendKnockBack(map, 1, s, dir, range);
        }
Ejemplo n.º 6
0
        //*********************************************************************************************
        // AlphaLoop / Revisto pela última vez em 01/08/2016, criado por Allyson S. Bacon
        // Trabalha com informações direcionadas ao jogo e os jogadores.
        //*********************************************************************************************
        public static void AlphaLoop()
        {
            //EXTEND
            if (Extensions.ExtensionApp.extendMyApp
                    (MethodBase.GetCurrentMethod().Name) != null)
            {
                return;
            }

            //CÓDIGO
            long tmr100;
            long tmr256;
            long Tick;

            tmr100 = 0;
            tmr256 = 0;

            Database.Handler.defineAdmin();

            WinsockAsync.Log(lang.server_started_in_date + " " + DateTime.Now);

            do
            {
                Tick = TickCount.ElapsedMilliseconds;

                //EXTEND
                if (Extensions.ExtensionApp.extendMyApp
                        ("alpha_inject", Tick) != null)
                {
                    return;
                }

                //WinsockAsync.Listen();

                Command = "First For";
                for (int i = 1; i <= Globals.Player_Highs; i++)
                {
                    if (PlayerStruct.tempplayer[i].ingame)
                    {
                        PetRelations.petMove(i);
                    }
                    if ((PlayerStruct.tempplayer[i].SORE) && (PlayerStruct.character[i, PlayerStruct.player[i].SelectedChar].PVPPenalty < Loops.TickCount.ElapsedMilliseconds))
                    {
                        PlayerStruct.tempplayer[i].SORE = false;
                        PlayerStruct.character[i, PlayerStruct.player[i].SelectedChar].PVPPenalty = 0;
                        SendData.sendPlayerSoreToMap(i);
                        SendData.sendAnimation(PlayerStruct.character[i, PlayerStruct.player[i].SelectedChar].Map, Globals.Target_Player, i, 148);
                    }
                    for (int p = 1; p < Globals.MaxPassiveEffects; p++)
                    {
                        if ((PlayerStruct.ppassiveffect[i, p].active) && (Tick > PlayerStruct.ppassiveffect[i, p].timer))
                        {
                            SkillRelations.executePassiveEffect(i, p);
                        }
                    }
                    if (PlayerStruct.tempplayer[i].RegenTimer < Tick)
                    {
                        PlayerRelations.playerRegen(i);
                    }
                    if ((PlayerStruct.tempplayer[i].preparingskill > 0) && (Tick > PlayerStruct.tempplayer[i].skilltimer))
                    {
                        PlayerLogic.ExecuteSkill(i);
                    }
                    //Dano sobre tempo
                    for (int s = 1; s < Globals.MaxNTempSpells; s++)
                    {
                        if ((PlayerStruct.ptempspell[i, s].active) && (Tick > PlayerStruct.ptempspell[i, s].timer))
                        {
                            SkillRelations.executeTempSpell(i, s);
                        }
                    }
                    if ((PlayerStruct.tempplayer[i].Stunned) && (PlayerStruct.tempplayer[i].StunTimer < Tick))
                    {
                        SendData.sendStun(PlayerStruct.character[i, PlayerStruct.player[i].SelectedChar].Map, 1, i, 0);
                        PlayerStruct.tempplayer[i].Stunned = false;
                    }
                    if ((PlayerStruct.tempplayer[i].Sleeping) && (PlayerStruct.tempplayer[i].SleepTimer < Tick))
                    {
                        SendData.sendSleep(PlayerStruct.character[i, PlayerStruct.player[i].SelectedChar].Map, 1, i, 0);
                        PlayerStruct.tempplayer[i].Sleeping = false;
                    }
                    if ((PlayerStruct.tempplayer[i].Blind) && (PlayerStruct.tempplayer[i].BlindTimer < Tick))
                    {
                        //SendData.sendStun(PlayerStruct.character[i, PlayerStruct.player[i].SelectedChar].Map, 1, i, 0);
                        PlayerStruct.tempplayer[i].Blind = false;
                    }
                    if ((PlayerStruct.tempplayer[i].Slowed) && (PlayerStruct.tempplayer[i].SlowTimer < Tick))
                    {
                        if (PlayerStruct.tempplayer[i].isFrozen)
                        {
                            PlayerStruct.tempplayer[i].isFrozen = false;
                            SendData.sendFrozen(Globals.Target_Player, i);
                        }
                        PlayerStruct.tempplayer[i].Slowed    = false;
                        PlayerStruct.tempplayer[i].movespeed = Globals.NormalMoveSpeed;
                        SendData.sendMoveSpeed(Globals.Target_Player, i);
                    }
                }


                Command = "tmr100";
                if (tmr100 < Tick)
                {
                    for (int i = 0; i <= WinsockAsync.Clients.Count - 1; i++)
                    {
                        if (!WinsockAsync.Clients[i].IsConnected)
                        {
                            if (WinsockAsync.Clients[i].s >= 0)
                            {
                                WinsockAsync.disconnectUser(i);
                            }
                        }
                    }

                    for (int i = 0; i <= Globals.Max_WorkPoints - 1; i++)
                    {
                        if ((MapStruct.tempworkpoint[i].respawn > 0) && (Loops.TickCount.ElapsedMilliseconds > MapStruct.tempworkpoint[i].respawn))
                        {
                            MapStruct.tempworkpoint[i].vitality = MapStruct.workpoint[i].vitality;
                            MapStruct.tempworkpoint[i].respawn  = 0;
                            SendData.sendEventGraphicToMap(MapStruct.workpoint[i].map, MapStruct.tile[MapStruct.workpoint[i].map, MapStruct.workpoint[i].x, MapStruct.workpoint[i].y].Event_Id, "", 0, Convert.ToByte(MapStruct.workpoint[i].active_sprite));
                        }
                    }

                    tmr100 = Tick + 100;
                }

                Command = "tmr256";

                if (tmr256 < Tick)
                {
                    for (int i = 0; i < Globals.MaxMaps; i++)
                    {
                        MapStruct.CheckMapItems(i);

                        if (MapStruct.tempmap[i].WarActive)
                        {
                            if (Tick > MapStruct.tempmap[i].WarTimer)
                            {
                                bool b = false;
                                for (int i2 = 0; i2 <= MapStruct.tempmap[i].NpcCount; i2++)
                                {
                                    if (NpcStruct.tempnpc[i, i2].guildnum > 0)
                                    {
                                        if (NpcStruct.tempnpc[i, i2].Target > 0)
                                        {
                                            MapStruct.tempmap[i].WarTimer += Tick + 20000;
                                            b = true;
                                        }
                                        NpcStruct.RegenNpc(i, i2, true);
                                    }
                                }
                                if (b)
                                {
                                    break;
                                }
                                SendData.sendMsgToGuild(MapStruct.map[i].guildnum, lang.the_colector_of + " " + MapStruct.map[i].name + " " + lang.has_survived, Globals.ColorYellow, Globals.Msg_Type_Server);
                                MapStruct.tempmap[i].WarActive = false;
                            }
                        }
                        Command = "NPC COUNT";
                        for (int i2 = 0; i2 <= MapStruct.tempmap[i].NpcCount; i2++)
                        {
                            if (i2 > 0)
                            {
                                Command = "TIME DAMAGE";
                                //Dano sobre tempo
                                for (int s = 1; s < Globals.MaxNTempSpells; s++)
                                {
                                    if ((NpcStruct.ntempspell[i, i2, s].active) && (Tick > NpcStruct.ntempspell[i, i2, s].timer))
                                    {
                                        NpcStruct.ExecuteTempSpell(i, i2, s);
                                    }
                                }

                                //Processamento do NPC
                                if (MapStruct.ExistPlayerInMap(i))
                                {
                                    Command = "NPC MOVE";
                                    NpcIA.CheckNpcMove(i, i2);
                                    if ((NpcStruct.tempnpc[i, i2].preparingskill > 0) && (Tick > NpcStruct.tempnpc[i, i2].skilltimer))
                                    {
                                        Command = "NPC EXECUTE SKILL";
                                        NpcIA.ExecuteSkill(i, i2);
                                    }
                                    if (NpcStruct.tempnpc[i, i2].RegenTimer < Tick)
                                    {
                                        Command = "REGEN NPC";
                                        NpcStruct.RegenNpc(i, i2);
                                    }
                                    if ((NpcStruct.tempnpc[i, i2].Stunned) && (NpcStruct.tempnpc[i, i2].StunTimer < Tick))
                                    {
                                        Command = "NPC STUN";
                                        SendData.sendStun(i, 2, i2, 0);
                                        NpcStruct.tempnpc[i, i2].Stunned = false;
                                    }
                                    if ((NpcStruct.tempnpc[i, i2].Sleeping) && (NpcStruct.tempnpc[i, i2].SleepTimer < Tick))
                                    {
                                        Command = "NPC SLEEP";
                                        SendData.sendSleep(i, 2, i2, 0);
                                        NpcStruct.tempnpc[i, i2].Sleeping = false;
                                    }
                                    if ((NpcStruct.tempnpc[i, i2].Blind) && (NpcStruct.tempnpc[i, i2].BlindTimer < Tick))
                                    {
                                        Command = "NPC BLIND";
                                        // A fazer SendData.sendStun(i, 2, i2, 0);
                                        NpcStruct.tempnpc[i, i2].Blind = false;
                                    }
                                    if ((NpcStruct.tempnpc[i, i2].Slowed) && (NpcStruct.tempnpc[i, i2].SlowTimer < Tick))
                                    {
                                        if (NpcStruct.tempnpc[i, i2].isFrozen)
                                        {
                                            NpcStruct.tempnpc[i, i2].isFrozen = false;
                                            SendData.sendFrozen(Globals.Target_Npc, i2, i);
                                        }
                                        NpcStruct.tempnpc[i, i2].Slowed    = false;
                                        NpcStruct.tempnpc[i, i2].movespeed = Globals.NormalMoveSpeed;
                                        SendData.sendMoveSpeed(Globals.Target_Npc, i2, i);
                                    }
                                }
                                else
                                {
                                    Command = "NPC SUPER REGEN";
                                    NpcStruct.RegenNpc(i, i2, true);
                                    if (NpcStruct.tempnpc[i, i2].Target > 0)
                                    {
                                        NpcStruct.tempnpc[i, i2].Target = 0;
                                    }
                                }
                                Command = "NPC RESPAWN";
                                if ((NpcStruct.tempnpc[i, i2].Dead == true) && (Tick > NpcStruct.tempnpc[i, i2].RespawnTimer))
                                {
                                    //Respawn
                                    NpcIA.NpcRespawned(i, i2);
                                }
                            }
                        }
                        //for (int i2 = 0; i2 <= MapStruct.Ge; i2++)
                        // {
                        //}
                    }
                    tmr256 = Tick + 256;
                }
                long test1 = Tick;
                Command = "save Timer";
                if (save_Timer < TickCount.ElapsedMilliseconds)
                {                        //Salva o jogador SE PRECISAR
                    if (WinsockAsync.Clients.Count > 0)
                    {
                        for (int i = 0; i < WinsockAsync.Clients.Count; i++)
                        {
                            if (PlayerStruct.tempplayer[WinsockAsync.Clients[i].s].ingame)
                            {
                                Database.Characters.saveCharacter(WinsockAsync.Clients[i].s, PlayerStruct.player[WinsockAsync.Clients[i].s].Email, PlayerStruct.player[WinsockAsync.Clients[i].s].SelectedChar);
                                Database.Banks.saveBank(WinsockAsync.Clients[i].s);
                            }
                        }
                    }
                    save_Timer = TickCount.ElapsedMilliseconds + 600000;
                    Console.WriteLine(lang.server_has_been_saved);
                }

                Command = "TPP";
                if ((test1 - Tick) > 0)
                {
                    Console.WriteLine("TPP: " + (test1 - Tick));
                }
                Thread.Sleep(10);
            }while (true);
        }
Ejemplo n.º 7
0
        //*********************************************************************************************
        // Main / Revisto pela última vez em 01/08/2016, criado por Allyson S. Bacon
        // Iniciamos o servidor aqui.
        //*********************************************************************************************
        static void Main(string[] args)
        {
            loadLang();
            Console.WriteLine("");
            Console.WriteLine("///////////////////////////////////////////////////////");
            Console.WriteLine("/                                                     /");
            Console.WriteLine(@"/        ___          _                               /");
            Console.WriteLine(@"/       / __\__  _ __(_) ___ _ __ _   _ _ __ ___      /");
            Console.WriteLine(@"/      / _\/ _ \| '__| |/ _ \ '__| | | | '_ ` _ \     /");
            Console.WriteLine(@"/     / / | (_) | |  | |  __/ |  | |_| | | | | | |    /");
            Console.WriteLine(@"/     \/   \___/|_| _/ |\___|_|   \__,_|_| |_| |_|    /");
            Console.WriteLine(@"/                  |__/                               /");
            Console.WriteLine("/                                                     /");
            Console.WriteLine("/                 http://4tabern.com                  /");
            Console.WriteLine("/         Copyright (C) 2016 Allyson S. Bacon         /");
            Console.WriteLine("/                                                     /");
            Console.WriteLine("///////////////////////////////////////////////////////");

            Console.WriteLine("");
            Console.WriteLine(lang.making_the_query_extensions_in_project);
            Extensions.ExtensionApp.instanceTypes();

            //EXTEND
            if (Extensions.ExtensionApp.extendMyApp
                    (MethodBase.GetCurrentMethod().Name, args) != null)
            {
                return;
            }

            //CÓDIGO PARA RESETAR JOGADORES
            //PlayerStruct.InitializePlayerArrays();
            //Database.ResetAndGiveExp();

            Log(Languages.LStruct.lang.starting_server);
            Log(lang.setting_global_names);
            Globals.GAME_NAME = Database.Handler.getGameName();
            Globals.MOTD      = Database.Handler.getMOTD();
            Globals.NOTICE    = Database.Handler.getNotice();
            Log(lang.starting_server);
            Log(lang.client_defined);
            Log("");
            Log(lang.starting_player_arrays);
            PlayerStruct.initializePlayerArrays();
            Log(lang.starting_guild_arrays);
            GuildStruct.initializeGuildArrays();
            Log(lang.arrays_started);
            Log("");
            Log(lang.loading_enemies);
            Database.Enemies.loadEnemies();
            Log(lang.loaded);
            Log(lang.loading_maps_monsters_and_missions);
            Database.Maps.loadAll();
            Log(lang.loaded);
            Log(lang.loading_items);
            Database.Items.loadItems();
            Log(lang.loaded);
            Log(lang.loading_weapons);
            Database.Weapons.loadWeapons();
            Log(lang.loaded);
            Log(lang.loading_armors);
            Database.Armors.loadArmors();
            Log(lang.loaded);
            Log(lang.loading_skills);
            Database.Skills.loadSkills();
            Log(lang.loaded);
            Log(lang.loading_shops);
            Database.Shops.loadShops();
            //Rudimentar :/
            Database.Manual.loadShopsRud();
            Log(lang.loaded);
            Log(lang.loading_recipes);
            Database.Manual.loadRecipes();
            Log(lang.loaded);
            Log(lang.loading_guilds);
            Database.Guilds.loadGuilds();
            Log(lang.loaded);
            Log(lang.loading_classes);
            Database.Handler.defineClassesData();
            Log(lang.loaded);
            Log("");
            Log(lang.setting_variables);
            rdn = new Random();
            Log(lang.OK);
            Log("");
            Log(lang.starting_server_loop);
            Log(lang.starting_tcpip_connection);

            WinsockAsync.start();
        }
Ejemplo n.º 8
0
        //*********************************************************************************************
        // CanplayerAttackPlayer / Revisto pela última vez em 01/08/2016, criado por Allyson S. Bacon
        // Verifica se determinado jogador pode atacar outro jogador determinado no contexto em que
        // ambos estão.
        //*********************************************************************************************
        public static bool canPlayerAttackPlayer(int Attacker, int Victim)
        {
            //EXTEND
            if (Extensions.ExtensionApp.extendMyApp
                    (MethodBase.GetCurrentMethod().Name, Attacker, Victim) != null)
            {
                return(Convert.ToBoolean(Extensions.ExtensionApp.extendMyApp
                                             (MethodBase.GetCurrentMethod().Name, Attacker, Victim)));
            }

            //CÓDIGO
            int Map     = Convert.ToInt32(character[Attacker, player[Attacker].SelectedChar].Map);
            int Dir     = character[Attacker, player[Attacker].SelectedChar].Dir;
            int VictimX = character[Victim, player[Victim].SelectedChar].X;
            int VictimY = character[Victim, player[Victim].SelectedChar].Y;
            int PlayerX = character[Attacker, player[Attacker].SelectedChar].X;
            int PlayerY = character[Attacker, player[Attacker].SelectedChar].Y;

            if (tempplayer[Victim].isDead == true)
            {
                return(false);
            }

            if (!MapStruct.tempmap[Map].WarActive)
            {
                if (character[Victim, player[Victim].SelectedChar].Level < 10)
                {
                    SendData.sendMsgToPlayer(Attacker, lang.pvp_level_restriction, Globals.ColorRed, Globals.Msg_Type_Server); return(false);
                }
                if (!MapStruct.MapIsPVP(Map))
                {
                    SendData.sendMsgToPlayer(Attacker, lang.pvp_safe_zone, Globals.ColorRed, Globals.Msg_Type_Server); return(false);
                }
            }

            switch (Dir)
            {
            case 8:
                VictimY += 1;
                break;

            case 2:
                VictimY -= 1;
                break;

            case 4:
                VictimX += 1;
                break;

            case 6:
                VictimX -= 1;
                break;

            default:
                WinsockAsync.Log(String.Format("Direção nula"));
                return(false);
            }

            if ((VictimX == PlayerX) && (VictimY == PlayerY))
            {
                return(true);
            }

            return(false);
        }
Ejemplo n.º 9
0
        //*********************************************************************************************
        // CanThrowNpc / Revisto pela última vez em 01/08/2016, criado por Allyson S. Bacon
        // Verifica se determinado NPC pode ser empurrado para determinada direção e distância
        //*********************************************************************************************
        public static bool canThrowNpc(int map, int s, byte Dir, int range)
        {
            //EXTEND
            if (Extensions.ExtensionApp.extendMyApp
                    (MethodBase.GetCurrentMethod().Name, map, s, Dir, range) != null)
            {
                return(Convert.ToBoolean(Extensions.ExtensionApp.extendMyApp
                                             (MethodBase.GetCurrentMethod().Name, map, s, Dir, range)));
            }

            //CÓDIGO
            int x = NpcStruct.tempnpc[map, s].X;
            int y = NpcStruct.tempnpc[map, s].Y;

            //Tentamos nos mover
            switch (Dir)
            {
            case 8:
                if (y - range < 0)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y].UpBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y - range].DownBlock) == false)
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x, y - range].Data1 == "3") || (MapStruct.tile[map, x, y - range].Data1 == "10") || (MapStruct.tile[map, x, y - range].Data1 == "2"))
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x, y - range].Data1 == "17") || (MapStruct.tile[map, x, y - range].Data1 == "18"))
                {
                    return(false);
                }
                break;

            case 2:
                if (y + range > 14)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y].DownBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y + range].UpBlock) == false)
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x, y + range].Data1 == "3") || (MapStruct.tile[map, x, y + range].Data1 == "10") || (MapStruct.tile[map, x, y + range].Data1 == "2"))
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x, y + range].Data1 == "17") || (MapStruct.tile[map, x, y + range].Data1 == "18"))
                {
                    return(false);
                }
                break;

            case 4:
                if (x - range < 0)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y].LeftBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x - range, y].RightBlock) == false)
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x - range, y].Data1 == "3") || (MapStruct.tile[map, x - range, y].Data1 == "10") || (MapStruct.tile[map, x - range, y].Data1 == "2"))
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x - range, y].Data1 == "17") || (MapStruct.tile[map, x - range, y].Data1 == "18"))
                {
                    return(false);
                }
                break;

            case 6:
                if (x + range > 19)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y].RightBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x + range, y].LeftBlock) == false)
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x + range, y].Data1 == "3") || (MapStruct.tile[map, x + range, y].Data1 == "10") || (MapStruct.tile[map, x + range, y].Data1 == "2"))
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x + range, y].Data1 == "17") || (MapStruct.tile[map, x + range, y].Data1 == "18"))
                {
                    return(false);
                }
                break;

            default:
                WinsockAsync.Log(String.Format("Direção nula"));
                break;
            }


            return(true);
        }
Ejemplo n.º 10
0
        //*********************************************************************************************
        // CanThrowPlayer / Revisto pela última vez em 01/08/2016, criado por Allyson S. Bacon
        // Verifica se determinado pode ser empurrado em determinada direção e distância
        //*********************************************************************************************
        public static bool canThrowPlayer(int s, byte Dir, int range)
        {
            //EXTEND
            if (Extensions.ExtensionApp.extendMyApp
                    (MethodBase.GetCurrentMethod().Name, s, Dir, range) != null)
            {
                return(Convert.ToBoolean(Extensions.ExtensionApp.extendMyApp
                                             (MethodBase.GetCurrentMethod().Name, s, Dir, range)));
            }

            //CÓDIGO
            int map = character[s, player[s].SelectedChar].Map;
            int x   = character[s, player[s].SelectedChar].X;
            int y   = character[s, player[s].SelectedChar].Y;

            //Tentamos nos mover
            switch (Dir)
            {
            case 8:
                if (y - range < 0)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y].UpBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y - range].DownBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y - (range - 1)].UpBlock) == false)
                {
                    return(false);
                }

                if ((MapStruct.tile[map, x, y - range].Data1 == "3") || (MapStruct.tile[map, x, y - range].Data1 == "10") || (MapStruct.tile[map, x, y - range].Data1 == "2"))
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x, y - range].Data1 == "17") || (MapStruct.tile[map, x, y - range].Data1 == "18"))
                {
                    return(false);
                }
                if (MapStruct.tile[map, x, y - range].Data1 == "21")
                {
                    if (!PlayerRelations.isPlayerPremmy(s))
                    {
                        return(false);
                    }
                }
                break;

            case 2:
                if (y + range > 14)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y].DownBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y + range].UpBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y + (range - 1)].DownBlock) == false)
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x, y + range].Data1 == "3") || (MapStruct.tile[map, x, y + range].Data1 == "10") || (MapStruct.tile[map, x, y + range].Data1 == "2"))
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x, y + range].Data1 == "17") || (MapStruct.tile[map, x, y + range].Data1 == "18"))
                {
                    return(false);
                }
                if (MapStruct.tile[map, x, y + range].Data1 == "21")
                {
                    if (!PlayerRelations.isPlayerPremmy(s))
                    {
                        return(false);
                    }
                }
                break;

            case 4:
                if (x - range < 0)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y].LeftBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x - range, y].RightBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x - (range - 1), y].LeftBlock) == false)
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x - range, y].Data1 == "3") || (MapStruct.tile[map, x - range, y].Data1 == "10") || (MapStruct.tile[map, x - range, y].Data1 == "2"))
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x - range, y].Data1 == "17") || (MapStruct.tile[map, x - range, y].Data1 == "18"))
                {
                    return(false);
                }
                if (MapStruct.tile[map, x - range, y].Data1 == "21")
                {
                    if (!PlayerRelations.isPlayerPremmy(s))
                    {
                        return(false);
                    }
                }
                break;

            case 6:
                if (x + range > 19)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y].RightBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x + range, y].LeftBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x + (range - 1), y].RightBlock) == false)
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x + range, y].Data1 == "3") || (MapStruct.tile[map, x + range, y].Data1 == "10") || (MapStruct.tile[map, x + range, y].Data1 == "2"))
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x + range, y].Data1 == "17") || (MapStruct.tile[map, x + range, y].Data1 == "18"))
                {
                    return(false);
                }
                if (MapStruct.tile[map, x + range, y].Data1 == "21")
                {
                    if (!PlayerRelations.isPlayerPremmy(s))
                    {
                        return(false);
                    }
                }
                break;

            default:
                WinsockAsync.Log(String.Format("Direção nula"));
                break;
            }


            return(true);
        }
Ejemplo n.º 11
0
        //*********************************************************************************************
        // CanPlayerMove / Revisto pela última vez em 01/08/2016, criado por Allyson S. Bacon
        // Verifica se determinado jogador pode se mover no contexto em que está atualmente
        //*********************************************************************************************
        public static bool canPlayerMove(int s, byte Dir, int x = 0, int y = 0)
        {
            //EXTEND
            if (Extensions.ExtensionApp.extendMyApp
                    (MethodBase.GetCurrentMethod().Name, s, Dir, x, y) != null)
            {
                return(Convert.ToBoolean(Extensions.ExtensionApp.extendMyApp
                                             (MethodBase.GetCurrentMethod().Name, s, Dir, x, y)));
            }

            //CÓDIGO
            int map = Convert.ToInt32(PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].Map);

            if (x <= 0 || y <= 0)
            {
                x = Convert.ToInt32(PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].X);
                y = Convert.ToInt32(PlayerStruct.character[s, PlayerStruct.player[s].SelectedChar].Y);
            }

            //Tentamos nos mover
            switch (Dir)
            {
            case 8:
                if (y - 1 < 0)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y].UpBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y - 1].DownBlock) == false)
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x, y - 1].Data1 == "3") || (MapStruct.tile[map, x, y - 1].Data1 == "10"))
                {
                    return(false);
                }
                if (MapStruct.tile[map, x, y - 1].Data1 == "21")
                {
                    if (!PlayerRelations.isPlayerPremmy(s))
                    {
                        playerMove(s, Convert.ToByte(Convert.ToInt32(MapStruct.tile[map, x, y - 1].Data2)));
                        return(false);
                    }
                }
                break;

            case 2:
                if (y + 1 > 14)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y].DownBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y + 1].UpBlock) == false)
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x, y + 1].Data1 == "3") || (MapStruct.tile[map, x, y + 1].Data1 == "10"))
                {
                    return(false);
                }
                if (MapStruct.tile[map, x, y + 1].Data1 == "21")
                {
                    if (!PlayerRelations.isPlayerPremmy(s))
                    {
                        playerMove(s, Convert.ToByte(Convert.ToInt32(MapStruct.tile[map, x, y + 1].Data2)));
                        return(false);
                    }
                }
                break;

            case 4:
                if (x - 1 < 0)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y].LeftBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x - 1, y].RightBlock) == false)
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x - 1, y].Data1 == "3") || (MapStruct.tile[map, x - 1, y].Data1 == "10"))
                {
                    return(false);
                }
                if (MapStruct.tile[map, x - 1, y].Data1 == "21")
                {
                    if (!PlayerRelations.isPlayerPremmy(s))
                    {
                        playerMove(s, Convert.ToByte(Convert.ToInt32(MapStruct.tile[map, x - 1, y].Data2)));
                        return(false);
                    }
                }
                break;

            case 6:
                if (x + 1 > 19)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x, y].RightBlock) == false)
                {
                    return(false);
                }
                if (Convert.ToBoolean(MapStruct.tile[map, x + 1, y].LeftBlock) == false)
                {
                    return(false);
                }
                if ((MapStruct.tile[map, x + 1, y].Data1 == "3") || (MapStruct.tile[map, x + 1, y].Data1 == "10"))
                {
                    return(false);
                }
                if (MapStruct.tile[map, x + 1, y].Data1 == "21")
                {
                    if (!PlayerRelations.isPlayerPremmy(s))
                    {
                        playerMove(s, Convert.ToByte(Convert.ToInt32(MapStruct.tile[map, x + 1, y].Data2)));
                        return(false);
                    }
                }
                break;

            default:
                WinsockAsync.Log(String.Format("Direção nula"));
                break;
            }

            return(true);
        }