cfgplayerrestrictedareahandler.c

Go to the documentation of this file.

class CfgPlayerRestrictedAreaHandler
{
    private static bool m_Initialized;
    
    static ref TStringArray m_PRAFiles = new TStringArray();
    static ref CfgPlayerRestrictedAreaJsonData m_Data = new CfgPlayerRestrictedAreaJsonData();
    
    //----------------------------------------------------------
    //load, inits, validation
    
    static bool LoadData()
    {
        if (m_Initialized)
            return true;
        
        m_Initialized = false;
        
        if (GetGame().ServerConfigGetInt( "enableCfgGameplayFile" )) //only reach into the CfgGameplayHandler if properly loaded!
            m_PRAFiles = CfgGameplayHandler.GetPlayerRestrictedAreaFiles();
        else
            m_PRAFiles = g_Game.GetMission().GetWorldData().GetDefaultPRAPaths();
        
        if (!m_PRAFiles)
            return true;
 
        string worldName;
        GetGame().GetWorldName(worldName);
    
        foreach (string filename : m_PRAFiles)
        {
            PlayerRestrictedAreaInstance area = new PlayerRestrictedAreaInstance();
            
            string errorMessage, path;
 
            path = string.Format("$mission:%1", filename);
            if (!JsonFileLoader<PlayerRestrictedAreaInstance>.LoadFile(path, area, errorMessage))
            {
                if (!FileExist(filename))
                    path = string.Format("dz/worlds/%1/ce/%2", worldName, filename);
                
                if (!JsonFileLoader<PlayerRestrictedAreaInstance>.LoadFile(path, area, errorMessage))
                {
                    ErrorEx(errorMessage);
                    continue;
                }
            }
            
            if (area != null)
                m_Data.m_Areas.Insert(area);
        }
        
        m_Initialized = m_Data.InitializeAreas();
        
        return true;
    }
    
    static bool IsInitialized()
    {
        return m_Initialized;
    }
    
    //----------------------------------------------------------
    //synchronization
    
    static void SyncDataSend(notnull PlayerIdentity identity)
    {
        GetGame().RPCSingleParam(null, ERPCs.RPC_PLAYERRESTRICTEDAREAS_SYNC, new Param1<CfgPlayerRestrictedAreaJsonData>(m_Data), true, identity);
    }
    
    static void OnRPC(ParamsReadContext ctx)
    {
        Param1<CfgPlayerRestrictedAreaJsonData> data = new Param1<CfgPlayerRestrictedAreaJsonData>(null);
        
        if (ctx.Read(data))
        {
            m_Data = data.param1;
            m_Initialized = m_Data.m_ValidatedAreas.Count() > 0;
        }
        else
        {
            ErrorEx("CfgPlayerRestrictedAreaHandler - client failed to read incoming data");
        }
    }
    
    //----------------------------------------------------------
    //main area checking methods
    
    static bool IsPointInPlayerRestrictedAreaClosest(vector point, out PlayerRestrictedAreaInstance hitArea)
    {
        if (!IsInitialized())
            return false;
        
        PlayerRestrictedAreaInstance area = GetClosestArea(point);
        if (area && IsCylinderInAreaBox(area,point) || IsPointInAreaPolygon(area,point))
        {
            hitArea = area;
            return true;
        }
        return false;
    }
    
    static bool IsPointInPlayerRestrictedArea(vector point, out PlayerRestrictedAreaInstance hitArea)
    {
        if (!IsInitialized())
            return false;
        
        foreach (PlayerRestrictedAreaInstance area : m_Data.m_ValidatedAreas)
        {
            if (IsCylinderInAreaBox(area,point) || IsPointInAreaPolygon(area,point))
            {
                hitArea = area;
                return true;
            }
        }
        
        return false;
    }
    
    //----------------------------------------------------------
    //support methods
    
    private static PlayerRestrictedAreaInstance GetClosestArea(vector point)
    {
        PlayerRestrictedAreaInstance ret;
        float closestDist = float.MAX;
        float currentDist;
        
        foreach (PlayerRestrictedAreaInstance area : m_Data.m_ValidatedAreas)
        {
            currentDist = vector.DistanceSq(point,area.GetCenterPos2D());
            if (currentDist < closestDist)
            {
                ret = area;
                closestDist = currentDist;
            }
        }
        
        return ret;
    }
    
    private static bool IsCylinderInAreaBox(notnull PlayerRestrictedAreaInstance area, vector point, float cylinderRadius = 0.25, float cylinderHeight = 1)
    {
        foreach (PRAShapeBoxData boxData : area.m_PRABoxDataTranslated)
        {
            vector matPlayer4[4];
            Math3D.MatrixIdentity4(matPlayer4);
            matPlayer4[3] = point;
            if (Math3D.IntersectCylinderOBB(boxData.m_Mins,boxData.m_Maxs,boxData.m_Mat4,matPlayer4,cylinderRadius,cylinderHeight))
                return true;
        }
        
        return false;
    }
    
    private static bool IsPointInAreaPolygon(notnull PlayerRestrictedAreaInstance area, vector point)
    {
        array<float> translatedDta = new array<float>;
        foreach (array<ref array<float>> polygonData : area.PRAPolygons)
        {
            translatedDta.Clear();
            
            foreach (array<float> vertexPos : polygonData)
            {
                translatedDta.Insert(vertexPos[0]);
                translatedDta.Insert(vertexPos[1]);
            }
            
            if (Math2D.IsPointInPolygon(translatedDta,point[0],point[2]))
                return true;
        }
        
        return false;
    }
    
    //----------------------------------------------------------
    //debugs
    
    static private ref array<Shape> m_DbgShapesBoxes;
    static private ref array<Shape> m_DbgShapesPolygonLines;
    
    static void DrawBoxesDebug(bool draw)
    {
        if (!IsInitialized())
            return;
        
        if (!m_DbgShapesBoxes)
            m_DbgShapesBoxes = {};
        
        if (draw && m_DbgShapesBoxes.Count() == 0)
        {
            foreach (PlayerRestrictedAreaInstance area : m_Data.m_ValidatedAreas)
            {
                foreach (PRAShapeBoxData boxData : area.m_PRABoxDataTranslated)
                {
                    Shape shp = Debug.DrawBox(boxData.m_Mins,boxData.m_Maxs);
                    shp.SetMatrix(boxData.m_Mat4);
                    m_DbgShapesBoxes.Insert(shp);
                }
            }
        }
        else if (!draw && m_DbgShapesBoxes.Count() > 0)
        {
            foreach (Shape box : m_DbgShapesBoxes)
            {
                box.Destroy();
            }
            
            m_DbgShapesBoxes.Clear();
        }
    }
    
    static void DrawPolygonLinesDebug(bool draw)
    {
        if (!IsInitialized())
            return;
        
        if (!m_DbgShapesPolygonLines)
            m_DbgShapesPolygonLines = {};
        
        if (draw && m_DbgShapesPolygonLines.Count() == 0)
        {
            array<vector> polygonVectors = {};
            foreach (PlayerRestrictedAreaInstance area : m_Data.m_ValidatedAreas)
            {
                foreach (array<ref array<float>> polygonData : area.PRAPolygons)
                {
                    vector first;
                    vector current;
                    vector last;
                    
                    foreach (array<float> vertexPos : polygonData)
                    {
                        polygonVectors.Insert(Vector(vertexPos[0],GetGame().SurfaceY(vertexPos[0],vertexPos[1]) + 2,vertexPos[1]));
                    }
                    
                    int count = polygonVectors.Count();
                    for (int i = 0; i < count; ++i)
                    {
                        current = polygonVectors[i];
                        
                        if (i == 0)
                            first = polygonVectors[i];
                        else
                            Debug.DrawLine(last,current,COLOR_WHITE,ShapeFlags.TRANSP|ShapeFlags.NOZWRITE);
                        
                        last = current;
                    }
                    
                    m_DbgShapesPolygonLines.Insert(Debug.DrawLine(current,first,COLOR_RED,ShapeFlags.TRANSP|ShapeFlags.NOZWRITE));
                    
                    polygonVectors.Clear();
                }
            }
        }
        else if (!draw && m_DbgShapesPolygonLines.Count() > 0)
        {
            foreach (Shape item : m_DbgShapesPolygonLines)
            {
                item.Destroy();
            }
            
            m_DbgShapesPolygonLines.Clear();
        }
    }
}