سلام ، آیا این بازدید اول شماست ؟ یا
logo_forum_header

تبلیغات
×
+
سفارش تبلیغات

نمایش نتایج: از 1 به 1 از 1

موضوع: اسکریپت ArenaSpectator

  1. #1

    شماره عضویت
    13
    تاریخ عضویت
    Oct 2014
    نوشته ها
    41
    نسل
    نسل مورد علاقه
    نژاد
    نژاد  مورد علاقه
    کلاس
     کلاس  مورد علاقه
    سورس
     سورس مورد علاقه
    پچ
    پچ مورد علاقه
    پسندیده : 58
    مورد پسند : 72 بار در 27 پست
    سیستم عامل و مرورگر:

    اسکریپت ArenaSpectator

    با دورد دوباره...

    این اسکریپت این قابلیت رو داره که یه پلیر میتونه مسابقات ارنای دوپلیر رو ببینه

    اسکریپت فیکس و کامل میباشد

    اسکریپت کپی از انجمن دیگی نمی باشد!!!

    برای ترینتی کر 3.3.5 میباشد

    من سورسم نسخه 51 تریننی میباشد اگه در نسخه اخر ترینتی Erorr داد بگید تا فیکس کنم...


    کد PHP:
    #include "ScriptPCH.h"
    #include "Chat.h"
    #include "ArenaTeamMgr.h"
    #include "BattlegroundMgr.h"
    #include "WorldSession.h"
    #include "Player.h"
    #include "ArenaTeam.h"
    #include "Battleground.h"
    #include "BattlegroundMgr.h"
    #include "CreatureTextMgr.h"
    #include "Config.h"

    int8 UsingGossip;

    class 
    arena_spectator_commands : public CommandScript
    {
    public:
        
    arena_spectator_commands() : CommandScript("arena_spectator_commands") { }

        static 
    bool HandleSpectateCommand(ChatHandlerhandlerchar const* args)
        {
            
    Playertarget;
            
    uint64 target_guid;
            
    std::string target_name;
            if (!
    handler->extractPlayerTarget((char*)args, &target, &target_guid, &target_name))
                return 
    false;

            
    Playerplayer handler->GetSession()->GetPlayer();
            if (
    target == player || target_guid == player->GetGUID())
            {
                
    handler->PSendSysMessage("You can't spectate yourself.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            if (
    player->IsInCombat())
            {
                
    handler->PSendSysMessage("You are in combat.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            if (!
    target)
            {
                
    handler->PSendSysMessage("Target is not online or does not exist.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            if (
    player->GetPet())
            {
                
    handler->PSendSysMessage("You must hide your pet.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            if (
    player->GetMap()->IsBattlegroundOrArena() && !player->isSpectator())
            {
                
    handler->PSendSysMessage("You are already in a battleground or arena.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            
    MapcMap target->GetMap();
            if (!
    cMap->IsBattleArena())
            {
                
    handler->PSendSysMessage("Player is not in an Arena match.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            if (
    player->GetMap()->IsBattleground())
            {
                
    handler->PSendSysMessage("You can't do that while in a battleground.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            if (
    target->HasAura(32728) || target->HasAura(32727))
            {
                
    handler->PSendSysMessage("You can't do that. The Arena match didn't start yet.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            if (
    target->isSpectator())
            {
                
    handler->PSendSysMessage("You can't do that. Your target is a spectator.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }
            
            if (
    player->IsMounted())
            {
                
    handler->PSendSysMessage("Cannot Spectate while mounted.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }


            
    // all's well, set bg id
            // when porting out from the bg, it will be reset to 0
            
    player->SetBattlegroundId(target->GetBattlegroundId(), target->GetBattlegroundTypeId());
            
    // remember current position as entry point for return at bg end teleportation
            
    if (!player->GetMap()->IsBattlegroundOrArena())
                
    player->SetBattlegroundEntryPoint();

            
    // stop flight if need
            
    if (player->IsInFlight())
            {
                
    player->GetMotionMaster()->MovementExpired();
                
    player->CleanupAfterTaxiFlight();
            }
            
    // save only in non-flight case
            
    else
                
    player->SaveRecallPosition();

            
    // search for two teams
            
    Battleground *bGround target->GetBattleground();
            if (
    bGround->isRated())
            {
                
    uint32 slot bGround->GetArenaType() - 2;
                if (
    bGround->GetArenaType() > 3)
                    
    slot 2;
                
    uint32 firstTeamID target->GetArenaTeamId(slot);
                
    uint32 secondTeamID 0;
                
    Player *firstTeamMember  target;
                
    Player *secondTeamMember NULL;
                 for (
    Battleground::BattlegroundPlayerMap::const_iterator itr =  bGround->GetPlayers().begin(); itr != bGround->GetPlayers().end();  ++itr)
                    if (
    PlayertmpPlayer ObjectAccessor::FindPlayer(itr->first))
                    {
                        if (
    tmpPlayer->isSpectator())
                            continue;

                        
    uint32 tmpID tmpPlayer->GetArenaTeamId(slot);
                        if (
    tmpID != firstTeamID && tmpID 0)
                        {
                            
    secondTeamID tmpID;
                            
    secondTeamMember tmpPlayer;
                            break;
                        }
                    }

                    if (
    firstTeamID && secondTeamID && secondTeamMember)
                    {
                        
    ArenaTeam *firstTeam  sArenaTeamMgr->GetArenaTeamById(firstTeamID);
                        
    ArenaTeam *secondTeam sArenaTeamMgr->GetArenaTeamById(secondTeamID);
                        if (
    firstTeam && secondTeam)
                        {
                            
    handler->PSendSysMessage("You entered a Rated Arena.");
                            
    handler->PSendSysMessage("Teams:");
                             
    handler->PSendSysMessage("|cFFffffff%s|r vs |cFFffffff%s|r",  firstTeam->GetName().c_str(), secondTeam->GetName().c_str());
                             
    handler->PSendSysMessage("|cFFffffff%u(%u)|r -- |cFFffffff%u(%u)|r",  firstTeam->GetRating(),  firstTeam->GetAverageMMR(firstTeamMember->GetGroup()),
                                
    secondTeam->GetRating(), secondTeam->GetAverageMMR(secondTeamMember->GetGroup()));
                        }
                    }
            }

            
    // to point to see at target with same orientation
            
    float xyz;
            
    target->GetContactPoint(playerxyz);

            
    player->TeleportTo(target->GetMapId(), xyzplayer->GetAngle(target), TELE_TO_GM_MODE);
            
    player->SetPhaseMask(target->GetPhaseMask(), true);
            
    player->SetSpectate(true);
            
    target->GetBattleground()->AddSpectator(player->GetGUID());

            return 
    true;
        }

        static 
    bool HandleSpectateCancelCommand(ChatHandlerhandler, const char/*args*/)
        {
            
    Playerplayer =  handler->GetSession()->GetPlayer();

            if (!
    player->isSpectator() || player->isSpectateCanceled())
            {
                
    handler->PSendSysMessage("You are not a spectator.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            
    // RemoveSpectator shouldn't be needed to be done explicitly as it'll be done in the CancelSpectate func
            //player->GetBattleground()->RemoveSpectator(player->GetGUID());
            
    player->CancelSpectate();
            
    player->TeleportToBGEntryPoint();

            return 
    true;
        }

        static 
    bool HandleSpectateFromCommand(ChatHandlerhandler, const char *args)
        {
            
    Playertarget;
            
    uint64 target_guid;
            
    std::string target_name;
            if (!
    handler->extractPlayerTarget((char*)args, &target, &target_guid, &target_name))
                return 
    false;

            
    Playerplayer handler->GetSession()->GetPlayer();

            if (!
    target)
            {
                
    handler->PSendSysMessage("Player is not online or does not exist.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            if (!
    player->isSpectator())
            {
                
    handler->PSendSysMessage("You are not a spectator, spectate someone first.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            if (
    target->isSpectator() && target != player)
            {
                
    handler->PSendSysMessage("You can't do that. Your target is a spectator.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            if (
    player->GetMap() != target->GetMap())
            {
                
    handler->PSendSysMessage("You can't do that. Your target might be in a different arena match.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            if (
    target && target->HasAuraType(SPELL_AURA_MOD_STEALTH))
            {
                
    handler->PSendSysMessage("You can't target stealthed players.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            
    // check for arena preperation
            // if exists than battle didn`t begin
            
    if (target && target->HasAura(32728) || target->HasAura(32727))
            {
                
    handler->PSendSysMessage("You can't do that. The Arena match didn't start yet.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            if (
    target == player && player->getSpectateFrom())
                
    player->SetViewpoint(player->getSpectateFrom(), false);
            else
                
    player->SetViewpoint(targettrue);
            return 
    true;
        }

        
    // addon data
        
    static bool HandleSpectateResetCommand(ChatHandlerhandler, const char *args)
        {
            
    Playerplayer handler->GetSession()->GetPlayer();

            if (!
    player->isSpectator())
            {
                
    handler->PSendSysMessage("You are not a spectator.");
                
    handler->SetSentErrorMessage(true);
                return 
    false;
            }

            
    Battleground *bGround player->GetBattleground();
            if (!
    bGround)
                return 
    false;

            if (
    bGround->GetStatus() != STATUS_IN_PROGRESS)
                return 
    true;

             for (
    Battleground::BattlegroundPlayerMap::const_iterator itr =  bGround->GetPlayers().begin(); itr != bGround->GetPlayers().end();  ++itr)
                if (
    PlayertmpPlayer ObjectAccessor::FindPlayer(itr->first))
                {
                    if (
    tmpPlayer->isSpectator())
                        continue;

                    
    uint32 tmpID bGround->GetPlayerTeam(tmpPlayer->GetGUID());

                    
    // generate addon massage
                    
    std::string pName tmpPlayer->GetName();
                    
    std::string tName "";

                    if (
    Player *target tmpPlayer->GetSelectedPlayer())
                        
    tName target->GetName();

                    
    SpectatorAddonMsg msg;
                    
    msg.SetPlayer(pName);
                    if (
    tName != "")
                        
    msg.SetTarget(tName);
                    
    msg.SetStatus(tmpPlayer->IsAlive());
                    
    msg.SetClass(tmpPlayer->getClass());
                    
    msg.SetCurrentHP(tmpPlayer->GetHealth());
                    
    msg.SetMaxHP(tmpPlayer->GetMaxHealth());
                    
    Powers powerType tmpPlayer->getPowerType();
                    
    msg.SetMaxPower(tmpPlayer->GetMaxPower(powerType));
                    
    msg.SetCurrentPower(tmpPlayer->GetPower(powerType));
                    
    msg.SetPowerType(powerType);
                    
    msg.SetTeam(tmpID);
                    
    msg.SendPacket(player->GetGUID());
                }

                return 
    true;
        }

        
    ChatCommandGetCommands() const OVERRIDE
        
    {
            static 
    ChatCommand spectateCommandTable[] =
            {
                { 
    "player",         SEC_PLAYER,      true,  &HandleSpectateCommand,        ""NULL },
                { 
    "view",           SEC_PLAYER,      true,  &HandleSpectateFromCommand,    ""NULL },
                { 
    "reset",          SEC_PLAYER,      true,  &HandleSpectateResetCommand,   ""NULL },
                { 
    "leave",          SEC_PLAYER,      true,  &HandleSpectateCancelCommand,  ""NULL },
                { 
    NULL,             0,               falseNULL,                          ""NULL }
            };

            static 
    ChatCommand commandTable[] =
            {
                { 
    "spectate",       SEC_PLAYERfalse,  NULL""spectateCommandTable },
                { 
    NULL,             0,          false,  NULL""NULL }
            };
            return 
    commandTable;
        }
    };

    enum NpcSpectatorAtions {
        
    // will be used for scrolling
        
    NPC_SPECTATOR_ACTION_2V2_GAMES          1000,
        
    NPC_SPECTATOR_ACTION_3V3_GAMES          2000,
        
    NPC_SPECTATOR_ACTION_SPECIFIC           500,

        
    // NPC_SPECTATOR_ACTION_SELECTED_PLAYER + player.Guid()
        
    NPC_SPECTATOR_ACTION_SELECTED_PLAYER    3000
    };

    const 
    uint8  GamesOnPage    15;

    class 
    npc_arena_spectator : public CreatureScript
    {
    public:
        
    npc_arena_spectator() : CreatureScript("npc_arena_spectator") { }

        
    bool OnGossipHello(PlayerpPlayerCreaturepCreature)
        {
             
    pPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT,  "|TInterface\\icons\\Achievement_Arena_2v2_7:30|t Games: 2v2",  GOSSIP_SENDER_MAINNPC_SPECTATOR_ACTION_2V2_GAMES);
             
    pPlayer->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT,  "|TInterface\\icons\\Achievement_Arena_3v3_7:30|t Games: 3v3",  GOSSIP_SENDER_MAINNPC_SPECTATOR_ACTION_3V3_GAMES);
             
    pPlayer->ADD_GOSSIP_ITEM_EXTENDED(GOSSIP_ICON_CHAT,  "|TInterface\\icons\\Spell_Holy_DevineAegis:30|t Spectate Specific  Player."GOSSIP_SENDER_MAINNPC_SPECTATOR_ACTION_SPECIFIC""0,  true);
            
    pPlayer->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGEpCreature->GetGUID());
            return 
    true;
        }

        
    bool OnGossipSelect(PlayerplayerCreaturecreatureuint32 /*sender*/uint32 action)
        {
            
    player->PlayerTalkClass->ClearMenus();
            if (
    action == NPC_SPECTATOR_ACTION_SPECIFIC)
            {

            }
            if (
    action NPC_SPECTATOR_ACTION_2V2_GAMES)
            {
                
    player->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT"Refresh"GOSSIP_SENDER_MAINNPC_SPECTATOR_ACTION_2V2_GAMES);
                
    ShowPage(playeraction NPC_SPECTATOR_ACTION_2V2_GAMESfalse);
                
    player->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGEcreature->GetGUID());
            }
            else if (
    action NPC_SPECTATOR_ACTION_3V3_GAMES)
            {
                
    player->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT"Refresh"GOSSIP_SENDER_MAINNPC_SPECTATOR_ACTION_3V3_GAMES);
                
    ShowPage(playeraction NPC_SPECTATOR_ACTION_3V3_GAMEStrue);
                
    player->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGEcreature->GetGUID());
            }
            else
            {

                
    uint64 guid action NPC_SPECTATOR_ACTION_SELECTED_PLAYER;
                if (
    Playertarget ObjectAccessor::FindPlayer(guid))
                {
                    
    ChatHandler handler(player->GetSession());
                    
    char const* pTarget target->GetName().c_str();
                    
    arena_spectator_commands::HandleSpectateCommand(&handlerpTarget);
                }
            }
            return 
    true;
        }

        
    std::string GetClassNameById(uint8 id)
        {
            
    std::string sClass "";
            switch (
    id)
            {
            case 
    CLASS_WARRIOR:         sClass "Warrior ";           break;
            case 
    CLASS_PALADIN:         sClass "Paladin ";           break;
            case 
    CLASS_HUNTER:          sClass "Hunter  ";           break;
            case 
    CLASS_ROGUE:           sClass "Rogue   ";           break;
            case 
    CLASS_PRIEST:          sClass "Priest  ";           break;
            case 
    CLASS_DEATH_KNIGHT:    sClass "DKnight ";           break;
            case 
    CLASS_SHAMAN:          sClass "Shaman  ";           break;
            case 
    CLASS_MAGE:            sClass "Mage    ";           break;
            case 
    CLASS_WARLOCK:         sClass "Warlock ";           break;
            case 
    CLASS_DRUID:           sClass "Druid   ";           break;
            }
            return 
    sClass;
        }

        
    std::string GetGamesStringData(Battlegroundteamuint16 mmruint16 mmrTwo)
        {
            
    std::string teamsMember[BG_TEAMS_COUNT];
            
    uint32 firstTeamId 0;
             for (
    Battleground::BattlegroundPlayerMap::const_iterator itr =  team->GetPlayers().begin(); itr != team->GetPlayers().end();  ++itr)
                if (
    Playerplayer ObjectAccessor::FindPlayer(itr->first))
                {
                    if (
    player->isSpectator())
                        continue;

                    if (
    player->IsGameMaster())
                        continue; 

                    
    uint32 team itr->second.Team;
                    if (!
    firstTeamId)
                        
    firstTeamId team;

                    
    teamsMember[firstTeamId == team] += GetClassNameById(player->getClass());
                }

                
    std::string data teamsMember[0] + "(";
                
    std::stringstream sstwo;
                
    std::stringstream ss;
                
    ss << mmr;
                
    sstwo << mmrTwo;
                
    data += ss.str();
                
    data += ") - ";
                
    data += teamsMember[1] + "(" sstwo.str();
                
    data += ")";
                return 
    data;
        }

        
    uint64 GetFirstPlayerGuid(Battlegroundteam)
        {
             for (
    Battleground::BattlegroundPlayerMap::const_iterator itr =  team->GetPlayers().begin(); itr != team->GetPlayers().end();  ++itr)
                if (
    Playerplayer ObjectAccessor::FindPlayer(itr->first))
                    return 
    itr->first;
            return 
    0;
        }

        
    void ShowPage(Playerplayeruint16 pagebool IsTop)
        {
            
    uint32 firstTeamId 0;
            
    uint16 TypeTwo 0;
            
    uint16 TypeThree 0;
            
    uint16 mmr 0;
            
    uint16 mmrTwo 0;
            
    bool haveNextPage false;
            for (
    uint8 i 0<= MAX_BATTLEGROUND_TYPE_ID; ++i)
            {
                if (!
    sBattlegroundMgr->isArenaType(BattlegroundTypeId(i)))
                    continue;

                
    BattlegroundDataarenas sBattlegroundMgr->GetAllBattlegroundsWithTypeId(BattlegroundTypeId(i));

                if (!
    arenas || arenas->m_Battlegrounds.empty())
                    continue;

                 for (
    BattlegroundContainer::const_iterator itr =  arenas->m_Battlegrounds.begin(); itr !=  arenas->m_Battlegrounds.end(); ++itr)
                {
                    
    Battlegroundarena itr->second;
                    
    Playertarget ObjectAccessor::FindPlayer(GetFirstPlayerGuid(arena));
                    if (!
    target)
                        continue;

                    if (
    target->HasAura(32728) || target->HasAura(32727))
                        continue;

                    if (!
    arena->GetPlayersSize())
                        continue;

                    if (!
    arena->isRated())
                        continue;

                    if (
    arena->GetArenaType() == ARENA_TYPE_2v2)
                    {
                        
    mmr arena->GetArenaMatchmakerRatingByIndex(0);
                        
    firstTeamId target->GetArenaTeamId(0);
                        
    Battleground::BattlegroundPlayerMap::const_iterator citr arena->GetPlayers().begin();
                        for (; 
    citr != arena->GetPlayers().end(); ++citr)
                            if (
    Playerplrs sObjectAccessor->FindPlayer(citr->first))
                                if (
    plrs->GetArenaTeamId(0) != firstTeamId)
                                    
    mmrTwo arena->GetArenaMatchmakerRating(citr->second.Team);
                    }
                    else
                    {
                        
    mmr arena->GetArenaMatchmakerRatingByIndex(1);
                        
    firstTeamId target->GetArenaTeamId(1);
                        
    Battleground::BattlegroundPlayerMap::const_iterator citr arena->GetPlayers().begin();
                        for (; 
    citr != arena->GetPlayers().end(); ++citr)
                            if (
    Playerplrs sObjectAccessor->FindPlayer(citr->first))
                                if (
    plrs->GetArenaTeamId(1) != firstTeamId)
                                    
    mmrTwo arena->GetArenaMatchmakerRating(citr->second.Team);
                    }

                    if (
    IsTop && arena->GetArenaType() == ARENA_TYPE_3v3)
                    {
                        
    TypeThree++;
                        if (
    TypeThree > (page 1) * GamesOnPage)
                        {
                            
    haveNextPage true;
                            break;
                        }

                        if (
    TypeThree >= page GamesOnPage)
                             
    player->ADD_GOSSIP_ITEM(GOSSIP_ICON_BATTLE,  GetGamesStringData(arenammrmmrTwo), GOSSIP_SENDER_MAIN,  NPC_SPECTATOR_ACTION_SELECTED_PLAYER GetFirstPlayerGuid(arena));
                    }
                    else if (!
    IsTop && arena->GetArenaType() == ARENA_TYPE_2v2)
                    {
                        
    TypeTwo++;
                        if (
    TypeTwo > (page 1) * GamesOnPage)
                        {
                            
    haveNextPage true;
                            break;
                        }

                        if (
    TypeTwo >= page GamesOnPage)
                             
    player->ADD_GOSSIP_ITEM(GOSSIP_ICON_BATTLE,  GetGamesStringData(arenammrmmrTwo), GOSSIP_SENDER_MAIN,  NPC_SPECTATOR_ACTION_SELECTED_PLAYER GetFirstPlayerGuid(arena));
                    }
                }
            }

            if (
    page 0)
            {
                 
    player->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT"Prev..",  GOSSIP_SENDER_MAINNPC_SPECTATOR_ACTION_2V2_GAMES page 1);
                 
    player->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT"Prev..",  GOSSIP_SENDER_MAINNPC_SPECTATOR_ACTION_3V3_GAMES page 1);
            }

            if (
    haveNextPage)
            {
                 
    player->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT"Next..",  GOSSIP_SENDER_MAINNPC_SPECTATOR_ACTION_2V2_GAMES page 1);
                 
    player->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT"Next..",  GOSSIP_SENDER_MAINNPC_SPECTATOR_ACTION_3V3_GAMES page 1);
            }
        }

        
    bool OnGossipSelectCode(PlayerplayerCreaturecreatureuint32 senderuint32 action, const charcode)
        {
            if (!
    player)
                return 
    true;

            
    player->PlayerTalkClass->ClearMenus();
            
    player->CLOSE_GOSSIP_MENU();
            if (
    sender == GOSSIP_SENDER_MAIN)
            {
                switch (
    action)
                {
                case 
    NPC_SPECTATOR_ACTION_SPECIFIC// choosing a player

                    
    const charplrName code;

                    
    char playerName[50];
                    
    strcpy(playerNameplrName);

                    for (
    int i 013i++)
                    {
                        if (
    playerName[i] == NULL)
                            break;
                        if (
    == && playerName[i] > 96)
                            
    playerName[0] -= 32;
                        else if (
    playerName[i] < 97)
                            
    playerName[i] += 32;
                    }

                    if (
    Playertarget sObjectAccessor->FindPlayerByName(playerName))
                    {
                        
    ChatHandler handler(player->GetSession());
                        
    char const* pTarget target->GetName().c_str();
                        
    arena_spectator_commands::HandleSpectateCommand(&handlerpTarget);
                    }
                    
    ChatHandler(player->GetSession()).PSendSysMessage("Player is not online or does not exist.");
                    return 
    true;
                }
            }

            return 
    false;
        }
    };



    void AddSC_arena_spectator_script()
    {
        new 
    arena_spectator_commands();
        new 
    npc_arena_spectator();


    SQL
    کد PHP:
    DELETE FROM `commandWHERE `name` = 'spectate';
    INSERT  INTO `command` (`name`, `security`, `help`) VALUES ('spectate'0,  'Syntax: .spectate $subcommand.\nUse .help sppectate');
    DELETE FROM `commandWHERE `name` = 'spectate view';
    INSERT  INTO `command` (`name`, `security`, `help`) VALUES ('spectate view'0,  'Syntax: .spectate view #player\nAllow player to spectate arena from  anotherplayer.');
    DELETE FROM `commandWHERE `name` = 'spectate leave';
    INSERT  INTO `command` (`name`, `security`, `help`) VALUES ('spectate leave',  0'Syntax: .spectate leave\nDisable spectator mode.');
    DELETE FROM `commandWHERE `name` = 'spectate player';
    INSERT  INTO `command` (`name`, `security`, `help`) VALUES ('spectate player',  0'Syntax: .spectate player #player\nAllow to spectate player.');
    DELETE FROM `commandWHERE `name` = 'spectate reset';
    INSERT INTO `command` (`name`, `security`, `help`) VALUES ('spectate reset'0'Syntax: .spectate reset\nSend addon data.');
    UPDATE  `gameobject_templateSET `flags` = 36 WHERE entry IN (185918185917,  183970183971183972183973183977183979183978183980192642,  192643); 
    بدرود

    2 کاربر پست Mr_Mohammad عزیز را پسندیده اند .

    Nightprince (10-29-2014),ubite (02-01-2015)

    ویرایش توسط Mr_Mohammad : 10-29-2014 در ساعت 06:00 PM
    مشکل ما اینه که میخوایم تو دنیایی مجازی کاربر برتر بشیم
    که اگه یه روز اینترنت نداشته باشیم فراموزش میشیم
    داداش گلم
    سعی کن تو دنیای واقعی ت برتر باشی
    نه اینجا که یه مشت بچه مچه شدن شاخ

  2. # ADS
    سیستم تبلیغات
    تاریخ عضویت
    01/01/2014
    نوشته ها
    پستی ندارد.
     

کلمات کلیدی این موضوع

مجوز های ارسال و ویرایش

  • شما نمیتوانید موضوع جدیدی ارسال کنید
  • شما امکان ارسال پاسخ را ندارید
  • شما نمیتوانید فایل پیوست کنید.
  • شما نمیتوانید پست های خود را ویرایش کنید
  •