ServerBrowserEntry.c

См. документацию.

class ServerBrowserEntry extends ScriptedWidgetEventHandler
{
    protected Widget m_Root;
    protected Widget m_Favorite;
 
    //Basic info
    protected TextWidget m_ServerName;
    protected TextWidget m_ServerPopulation;
    protected TextWidget m_ServerSlots;
    protected TextWidget m_ServerPing;
    protected ImageWidget m_ServerTime; // not currently displayed
    protected ImageWidget m_ServerLock;
    protected ImageWidget m_ServerModIcon;
    protected ImageWidget m_ServerMaKIcon;
 
    //Detailed info
    protected TextWidget m_ServerShard;
    protected TextWidget m_ServerCharacterAlive;
    protected TextWidget m_ServerFriends;
    protected TextWidget m_ServerMode;
    protected TextWidget m_ServerBattleye;
    protected TextWidget m_ServerIP;
    protected TextWidget m_ServerAcceleration;
    protected TextWidget m_ServerMap;
    protected TextWidget m_ServerMods;
    protected ButtonWidget m_ServerModsExpand;
    protected ref array<string> m_Mods;
    
    protected Widget m_DetailedInfo;
    protected bool m_IsExpanded;
    protected bool m_IsFavorited;
    protected bool m_IsOnline;
 
    protected ref GetServersResultRow m_ServerData;
    protected int m_Index;
    protected ServerBrowserTab m_Tab;
    protected bool m_Selected;
    protected bool m_FirstExpand = true;
 
    void ServerBrowserEntry(Widget parent, int index, ServerBrowserTab tab)
    {
    #ifdef PLATFORM_CONSOLE
        m_Root = GetGame().GetWorkspace().CreateWidgets("gui/layouts/new_ui/server_browser/xbox/server_browser_list_entry.layout", parent);
    #else
        m_Root = GetGame().GetWorkspace().CreateWidgets("gui/layouts/new_ui/server_browser/pc/server_browser_list_entry_pages.layout", parent);
    #endif
        
        m_Root.Enable(true);
        m_Favorite = m_Root.FindAnyWidget("favorite_button");
        m_ServerName = TextWidget.Cast(m_Root.FindAnyWidget("server_name"));
        m_ServerPopulation = TextWidget.Cast( m_Root.FindAnyWidget("server_population"));
        m_ServerSlots = TextWidget.Cast(m_Root.FindAnyWidget("server_slots"));
        m_ServerPing = TextWidget.Cast(m_Root.FindAnyWidget("server_ping"));
        m_ServerTime = ImageWidget.Cast(m_Root.FindAnyWidget("server_time"));
        m_ServerLock = ImageWidget.Cast(m_Root.FindAnyWidget("lock_icon"));
        m_ServerModIcon = ImageWidget.Cast(m_Root.FindAnyWidget("modded_icon"));
        m_ServerMaKIcon = ImageWidget.Cast(m_Root.FindAnyWidget("mandk_icon"));
        
        m_ServerShard = TextWidget.Cast(m_Root.FindAnyWidget("shard_text"));
        m_ServerCharacterAlive = TextWidget.Cast(m_Root.FindAnyWidget("character_alive_text"));
        m_ServerFriends = TextWidget.Cast(m_Root.FindAnyWidget("steam_friends_text"));
        m_ServerMode = TextWidget.Cast(m_Root.FindAnyWidget("mode_text"));
        m_ServerBattleye = TextWidget.Cast(m_Root.FindAnyWidget("battlleye_text"));
        m_ServerIP = TextWidget.Cast(m_Root.FindAnyWidget("ip_text"));
        m_ServerAcceleration = TextWidget.Cast(m_Root.FindAnyWidget("server_acceleration_text"));
        m_ServerMap = TextWidget.Cast(m_Root.FindAnyWidget("server_map"));
        m_ServerMods = TextWidget.Cast(m_Root.FindAnyWidget("mods_text"));
        m_ServerModsExpand = ButtonWidget.Cast(m_Root.FindAnyWidget("mods_expand"));
 
        m_DetailedInfo = m_Root.FindAnyWidget("detailed_info");
        
        m_Root.FindAnyWidget("basic_info").Show(true);
        m_Root.FindAnyWidget("favorite_image").Update();
        m_Root.FindAnyWidget("unfavorite_image").Update();
        
        m_Index  = index;
        m_Tab = tab;
        m_IsOnline = true;
        
        m_ServerTime.LoadImageFile(0, "set:dayz_gui image:icon_sun");
        m_ServerTime.LoadImageFile(1, "set:dayz_gui image:icon_sun_accel");
        m_ServerTime.LoadImageFile(2, "set:dayz_gui image:icon_moon");
        m_ServerTime.LoadImageFile(3, "set:dayz_gui image:icon_moon_accel");
        
        m_Root.SetHandler(this);
    }
 
    void ~ServerBrowserEntry()
    {
        delete m_Root;
    }
 
    Widget GetRoot()
    {
        return m_Root;
    }
 
    void Show(bool show)
    {
        m_Root.Show(show);
    }
    
    // Method never gets called on console!
    override bool OnClick(Widget w, int x, int y, int button)
    {
        if (!IsOnline() || w == null)
        {
            return false;
        }
 
        switch (w)
        {
        #ifdef PLATFORM_CONSOLE
            case m_Root:
            {
                m_Tab.Connect(this);
                return true;
            }
        #endif
            case m_ServerModsExpand:
            {
                string mods_text;
                if (m_Mods && m_Mods.Count() > 0)
                {
                    mods_text = m_Mods[0];
                    for (int i = 1; i < m_Mods.Count(); i++)
                    {
                        mods_text += "\n" + m_Mods[i];
                    }
                }
    
                GetGame().GetUIManager().ShowDialog("#main_menu_mods", mods_text, 0, 0, 0, 0, GetGame().GetUIManager().GetMenu());
                return true;
            }
        }
 
        return false;
    }
 
    override bool OnDoubleClick(Widget w, int x, int y, int button)
    {
        if (!IsOnline())
        {
            return false;
        }
        
        if (button == MouseState.LEFT && w == m_Root)
        {
            m_Tab.Connect(this);
            return true;
        }
 
        return false;
    }
 
    override bool OnMouseButtonUp(Widget w, int x, int y, int button)
    {
        if (button == MouseState.LEFT)
        {
            switch (w)
            {
                case m_Favorite:
                {
                    ToggleFavorite();
                    return true;
                }
                case m_Root:
                {
                    OnSelect();
                    return true;
                }
            }
        }
        return false;
    }
 
    void OnSelect()
    {
        Darken(m_Root, 0, 0);
        Select();
        SetFocus(m_Root);
        m_Tab.SetServerDetails(m_ServerData, m_IsOnline);
    }
    
    override bool OnMouseEnter(Widget w, int x, int y)
    {
        if (IsFocusable(w))
        {
            Preview(w, x, y);
            return true;
        }
 
        return false;
    }
 
    override bool OnMouseLeave(Widget w, Widget enterW, int x, int y)
    {
        if (IsFocusable(w) && !IsFocusable(enterW))
        {
            Lighten(w, enterW, x, y);
            return true;
        }
 
        return false;
    }
 
    void Focus()
    {
        SetFocus(m_Root);
    }
 
    void ServerListFocus(bool focus)
    {
        m_Tab.ServerListFocus(focus, m_IsFavorited);
    }
 
    override bool OnFocus(Widget w, int x, int y)
    {
        if (!m_Selected)
        {
            if (IsFocusable(w))
                Darken(w, x, y);
 
        #ifdef PLATFORM_CONSOLE
            if (w == m_Root)
            {
                Select();
                ServerListFocus(true);
                m_Tab.SetServerDetails(m_ServerData, m_IsOnline);
            }
        #endif
 
            return true;
        }
        return false;
    }
 
    override bool OnFocusLost(Widget w, int x, int y)
    {
    #ifdef PLATFORM_CONSOLE
        if (w == m_Root)
        {
            Deselect();
            ServerListFocus(false);
        }
    #endif
        
        if (IsFocusable(w))
        {
            Lighten(w, null, x, y);
        }
        
        return true;
        return false;
    }
 
    bool IsOnline()
    {
        return m_IsOnline;
    }
 
    bool IsFocusable(Widget w)
    {
        if (w)
            return (w == m_Root || w == m_Favorite || w == m_ServerModsExpand);
 
        return false;
    }
 
    void FillInfo(GetServersResultRow server_info)
    {
        m_ServerData = server_info;
        m_FirstExpand = true;
        
    #ifndef PLATFORM_CONSOLE
        m_DetailedInfo.Show(server_info.m_IsExpanded);
    #endif
        
        SetName(server_info.m_Name);
        SetPasswordLocked(server_info.m_IsPasswordProtected);
        SetPopulationEx(server_info);
        SetSlots(server_info.m_MaxPlayers);
        SetPing(server_info.m_Ping);
        SetFavorite(server_info.m_Favorite);
        SetModded(server_info.m_Modded);
        SetServerMapName();
        RefreshDLCIcon();
        
    #ifdef PLATFORM_CONSOLE
        SetMouseAndKeyboard(server_info.m_MouseAndKeyboardEnabled);
    #endif
        
#ifdef PLATFORM_WINDOWS
    #ifndef PLATFORM_CONSOLE
        SetExpand(server_info.m_IsExpanded);
        
        int pp = 0; // private
        if (server_info.m_ShardId.Length() == 3 && server_info.m_ShardId.ToInt() < 200)
        {
            pp = 1; // official
        }
        
        SetShard(pp);
        SetCharacterAlive(server_info.m_CharactersAlive);
        SetFriends(server_info.m_SteamFriends);
        SetMode(server_info.m_Disable3rdPerson);
        SetBattleye(server_info.m_AntiCheat);
        SetIP(server_info.m_Id);
        SetAcceleration(server_info.m_EnvironmentTimeMul);
    #endif
#endif
    }
 
    void UpdateEntry()
    {
        if (m_ServerData.m_IsSelected)
        {
            Darken(m_Root, 0, 0);
            Select();
            SetFocus(m_Root);
        }
        else
        {
            Lighten(m_Root, null, 0, 0);
            Deselect();
        }
    }
 
    void SetName(string name)
    {
        m_ServerName.SetText(name);
    }
 
    void SetPasswordLocked(bool locked)
    {
        m_ServerLock.Show(locked);
    }
 
    private void SetPopulationEx(GetServersResultRow serverInfo)
    {
        string popText = "";
        int population = serverInfo.m_CurrentNumberPlayers;
        int maxPlayers = serverInfo.m_MaxPlayers;
        int playersInQueue = serverInfo.m_PlayersInQueue;
        
        if (IsOnline())
        {
            // sometimes servers report a queue size even though server isn't full,
            // in which case we ignore queue size
            if (playersInQueue > 0 && population == maxPlayers)
            {
                popText = population.ToString() + "+" + playersInQueue.ToString() + "/" + maxPlayers.ToString();
            }
            else
            {
                popText = population.ToString() + "/" + maxPlayers.ToString();
            }
        }
        
        else
        {
            popText = "-";
        }
 
        m_ServerPopulation.SetText(popText);
    }
 
    void SetSlots(int slots)
    {
        if (IsOnline())
        {
            m_ServerSlots.SetText(slots.ToString());
        }
        else
        {
            m_ServerSlots.SetText("-");
        }
    }
 
    void SetPing(int ping)
    {
        int color;
        string displayValue;
        
        if (ping < 50)
            color = ARGBF(1, 0, 1, 0);
        else if(ping < 100)
            color = ARGBF(1, 0.8, 0.8, 0);
        else if( ping < 200 )
            color = ARGBF(1, 1, 0.5, 0);
        else
            color = ARGBF(1, 1, 0, 0);
        
        if (IsOnline())
        {
            displayValue = ping.ToString();
        }
        
        else
        {
            displayValue = "-";
        }
        
        m_ServerPing.SetColor(color);
        m_ServerPing.SetText(displayValue);
    }
 
    void SetTime(string time, float multiplier)
    {
        if (time != "")
        {
            TStringArray arr = new TStringArray;
            
            time.Split(":", arr);
            
            if (arr.Count() == 2)
            {
                int hour = arr.Get(0).ToInt();
                int minute = arr.Get(1).ToInt();
                
                if (hour >= 19 || hour <= 5)    //Night
                {
                    if (multiplier > 1)
                        m_ServerTime.SetImage(3);
                    else
                        m_ServerTime.SetImage(2);
                }
                else                            //Day
                {
                    if (multiplier > 1)
                        m_ServerTime.SetImage(1);
                    else
                        m_ServerTime.SetImage(0);
                }
            }
        }
    }
 
    void SetShard(int shard)
    {
        string text;
        switch (shard)
        {
            case 0:
            {
                text = "#server_browser_entry_private";
                break;
            }
            case 1:
            {
                text = "#server_browser_entry_official";
                break;
            }
        }
        m_ServerShard.SetText(text);
    }
 
    void RefreshDLCIcon()
    {
        if (m_ServerData.m_IsDLC)
        {
            bool own = GetGame().VerifyWorldOwnership(GetMapToRun());
            m_ServerModIcon.Show(true);
            m_ServerModIcon.FindWidget("Owned").Show(own);
            m_ServerModIcon.FindWidget("Unowned").Show(!own);
        }
        else
        {
            m_ServerModIcon.FindWidget("Owned").Show(false);
            m_ServerModIcon.FindWidget("Unowned").Show(false);
        }
    }
 
    void SetCharacterAlive(string char_alive)
    {
        if (char_alive == "")
            m_ServerCharacterAlive.SetText("#STR_server_browser_char_not_alive");
        else
            m_ServerCharacterAlive.SetText(char_alive);
    }
 
    void SetFriends(string friends_text)
    {
        m_ServerFriends.SetText(friends_text);
    }
 
    void SetMode(int mode)
    {
        string text;
        switch (mode)
        {
            case 0:
            {
                text = "#server_browser_entry_person_both";
                break;
            }
            case 1:
            {
                text = "#server_browser_entry_person_first";
                break;
            }
        }
        m_ServerMode.SetText(text);
    }
 
    void SetBattleye(bool battleye)
    {
        if (battleye)
        {
            m_ServerBattleye.SetText("#server_browser_entry_enabled");
            m_ServerBattleye.SetColor(ARGBF(1, 0, 1, 0));
        }
        else
        {
            m_ServerBattleye.SetText("#server_browser_entry_disabled");
            m_ServerBattleye.SetColor(ARGBF(1, 1, 0, 0));
        }
    }
 
    void SetIP(string ip)
    {
        m_ServerIP.SetText(ip);
    }
 
    string GetIP()
    {
        return m_ServerData.GetIP();
    }
 
    int GetPort()
    {
        return m_ServerData.m_HostPort;
    }
 
    int GetSteamQueryPort()
    {
        return m_ServerData.m_SteamQueryPort;
    }
 
    string GetServerID()
    {
        return m_ServerData.m_Id;
    }
 
    string GetMapToRun()
    {
        return m_ServerData.m_MapNameToRun;
    }
 
    void SetFavorite(bool favorite)
    {
        m_IsFavorited = favorite;
        m_Root.FindAnyWidget("favorite_image").Show(favorite);
        m_Root.FindAnyWidget("unfavorite_image").Show(!favorite);     
    }
 
    void SetAcceleration(float mult)
    {
        if (mult > 1)
        {
            m_ServerAcceleration.Show(true);
            m_ServerAcceleration.SetText(mult.ToString() + "x");
        }
        else
        {
            m_ServerAcceleration.Show(false);
        }
    }
 
    void SetModded(bool is_modded)
    {
        m_ServerModIcon.Show(is_modded);
    }
 
    void SetServerMapName()
    {
        string displayValue = "-";
 
        if (IsOnline())
        {
            displayValue = ServerBrowserHelperFunctions.GetMapDisplayName(m_ServerData.m_MapNameToRun);
        }
        
        m_ServerMap.SetText(displayValue);
    }
 
    void SetMods(array<string> mods)
    {
        m_Mods = mods;
 
        if (mods && mods.Count() > 0)
        {
            string mods_text = mods[0];
            for (int i = 1; i < mods.Count(); i++)
                mods_text += ", " + mods[i];
    
            m_ServerMods.SetText(mods_text);
        }
 
    #ifdef PLATFORM_WINDOWS
        m_ServerModsExpand.Show((mods && mods.Count() > 0));
    #endif
    }
    
    void SetMouseAndKeyboard(bool is_mkenabled)
    {
        m_ServerMaKIcon.Show(is_mkenabled);
    }
    
    void SetIsOnline(bool isOnline)
    {
        m_IsOnline = isOnline;
    }
    
    bool ToggleFavorite()
    {
        m_IsFavorited = !m_IsFavorited;
        string ip = m_ServerData.GetIP();
#ifdef PLATFORM_WINDOWS 
        //Save Data PC
        m_Tab.GetRootMenu().AddFavorite(ip, m_ServerData.m_SteamQueryPort, m_IsFavorited);
    
    #ifdef PLATFORM_CONSOLE
        OnlineServices.SetServerFavorited(ip, 0, m_ServerData.m_SteamQueryPort, m_IsFavorited);
    #else
        OnlineServices.SetServerFavorited(ip, m_ServerData.m_HostPort, m_ServerData.m_SteamQueryPort, m_IsFavorited);
    #endif
#else
        //Save Data Console     
        m_IsFavorited = m_Tab.GetRootMenu().SetFavoriteConsoles(ip, m_ServerData.m_HostPort, m_IsFavorited);
        //Refresh favorites server list when entry is unfavorited
        ServerBrowserFavoritesTabConsolePages sbf = ServerBrowserFavoritesTabConsolePages.Cast(m_Tab);
        if (!m_IsFavorited && sbf)
        {
            sbf.SetFavoriteChanged(true);
            sbf.RefreshServerList();
        }
#endif
        
        m_Root.FindAnyWidget("unfavorite_image").Show(!m_IsFavorited);
        m_Root.FindAnyWidget("favorite_image").Show(m_IsFavorited);
        
        return m_IsFavorited;
    }
    
    bool ToggleExpand()
    {
        return SetExpand(!m_IsExpanded);
    }
    
    bool SetExpand(bool expand)
    {
        m_IsExpanded = expand;
        m_Root.FindAnyWidget("collapse_image").Show(m_IsExpanded);
        m_Root.FindAnyWidget("expand_image").Show(!m_IsExpanded);
        m_DetailedInfo.Show(m_IsExpanded);
        
        if (m_ServerData)
        {
            m_ServerData.m_IsExpanded = m_IsExpanded;
        }
        
        if (expand && m_FirstExpand)
        {
            if (m_ServerData.m_Modded)
            {
                OnlineServices.GetServerModList(m_ServerData.m_Id);
            }
 
            m_FirstExpand = false;
        }
        
        return m_IsExpanded;
    }
    
    void Select(bool notify = true)
    {
        if (!m_Selected)
        {
            if (notify)
            {
                m_Tab.SelectServer(this);
            }
            
            m_ServerData.m_IsSelected = true;
            m_Selected = true;
        }
    }
    
    void Deselect()
    {
        if (m_Selected)
        {
            m_ServerData.m_IsSelected = false;      
            m_Selected = false;
            
            Lighten(m_Root, null, 0, 0);
        }
    }
    
    void UpdateColors()
    {
        float alpha = 1;
        int maxPlayers = m_ServerData.m_MaxPlayers;
        int whiteColor = ARGBF(1, 1, 1, 1);
        int populationColor = whiteColor;
        int populationOutline = 1;
        
        if (IsOnline())
        {   
            if (maxPlayers > 0)
            {
                int population = m_ServerData.m_CurrentNumberPlayers;
                float pop_percentage = population / maxPlayers;
    
                if (pop_percentage >= 1)
                {
                    populationColor = ARGBF(1, 1, 0, 0);
                }
                else if (pop_percentage >= 0.8)
                {
                    populationColor = ARGBF(1, 1, 0.5, 0);
                }
            }
        }
        else
        {
            alpha = 0.5;
            populationOutline = 0;
                        
            m_ServerPing.SetColor(whiteColor);
        }
        
        m_ServerTime.Show(IsOnline());
        m_ServerName.SetColor(whiteColor);
        m_ServerName.SetAlpha(alpha);
        m_ServerPopulation.SetBold(IsOnline());
        m_ServerPopulation.SetColor(populationColor);
        m_ServerPopulation.SetOutline(populationOutline);
        m_ServerPopulation.SetAlpha(alpha);
        m_ServerSlots.SetAlpha(alpha);
        m_ServerPing.SetAlpha(alpha);
        m_Root.SetAlpha(alpha);
    }
    
    //Coloring functions (Until WidgetStyles are useful)
    void Preview(Widget w, int x, int y)
    {
        if (m_Selected)
            return;
        
        switch (w)
        {
            case m_Root:
            case m_Favorite:
            {
                m_Root.SetColor(ARGB(255, 0, 0, 0));
                m_Root.SetAlpha(1);
                UpdateColors();
                
                m_ServerName.SetColor(ARGB(255, 255, 0, 0));
                if (!IsOnline())
                {
                    m_ServerName.SetAlpha(0.5);
                }
                break;
            }
        }
    }
    
    //Coloring functions (Until WidgetStyles are useful)
    void Darken(Widget w, int x, int y)
    {
        if (m_Selected)
            return;
        
        switch (w)
        {
            case m_Root:
            case m_Favorite:
            {
                m_Root.SetColor(ARGB(255, 200, 0, 0));
                SetPopulationEx(m_ServerData);
                UpdateColors();
                break;
            }
        }
    }
    
    void Lighten(Widget w, Widget enterW, int x, int y)
    {
        float alpha = 0.3;
        
        if (GetFocus() == w || m_Selected)
        {
            return;
        }
        
        if (w == m_Root && (m_Favorite && enterW == m_Favorite))
        {
            return;
        }
 
        m_Root.SetColor(ARGB(255, 0, 0, 0));          
        SetPopulationEx(m_ServerData);
        UpdateColors();
        
        if (m_Index % 2)
        {
            alpha = 0;
        }
        
        m_Root.SetAlpha(alpha);
    }
    
    GetServersResultRow GetServerData()
    {
        return m_ServerData;
    }
 
    // DEPRECATED
    string GetMapName();
    
    // DEPRECATED
    void SetMapName(string mapName);
    
    // DEPRECATED
    void SetPopulation(int population, int slots);
}