WeaponDebug.c

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

enum eDebugMode
{
    NORMAL,
    MUZZLE_FIRE,
    CAMERA_MUZZLE_HYBRID,
    COUNT
};
 
 
 
class WeaponDebug
{
    const int BUFFER_SIZE = 1000;
    const float COLLISIONS_DISTANCE_TOLERANCE = 0.01;
    const float MAX_MUZZLE_DISTANCE_TOLERANCE = 20;
    const float CAMERA_BULLET_ORIGIN_OFFSET = 1;
    const float CAMERA_TRACE_MIN_DISTANCE_TOLERANCE = 0.3;
    
    Weapon m_WeaponInHands;
    int m_BufferIndex;
    bool m_IsDrawKeyHeldDown;
    bool m_IsLMBPressed;
    bool m_IsToggleKeyPressed;
    bool m_IsFireKeyPressed;
    float m_TargetDistance;
    eDebugMode m_CurrentMode;
    vector m_AimTrailCyclic[BUFFER_SIZE];  
    vector m_AimTrailOrdered[BUFFER_SIZE];
    
    ref map<int, string> m_DebugModesNames = new map<int, string>;
    
    //ref array<Selection> m_Selections = new array<Selection>();
    
    Shape m_Shape_usti;
    Shape m_Shape_konec;
    Shape m_ShapeFireDirection1;
    Shape m_ShapeFireDirection2;
    Shape m_HitShape;
    Shape m_ShapeEye;
    Shape m_ShapeTrailLines;
    Shape m_ShapeFireDirCamera;
    Shape m_HitShape2;
    Shape m_HitShape3;
    Shape m_HitShape4;
    //Shape temp_shape;
    Shape m_PermanentLine1;
    Shape m_PermanentLine2;
    
    Shape m_PermanentShape1;
    Shape m_PermanentShape2;
    
    Weapon GetWeaponInHands()
    {
        Weapon weapon_in_hands;
        PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
        if( player && player.GetItemInHands() ) Class.CastTo(weapon_in_hands,  player.GetItemInHands());
        
        return weapon_in_hands;
    }
    
    void WeaponDebug()
    {
        m_DebugModesNames.Insert(eDebugMode.NORMAL, "Mode "+eDebugMode.NORMAL.ToString()+": shoot along the weapon barrel");
        m_DebugModesNames.Insert(eDebugMode.MUZZLE_FIRE,"Mode "+eDebugMode.MUZZLE_FIRE.ToString()+": shoot from muzzle end to camera trace hit point");
        m_DebugModesNames.Insert(eDebugMode.CAMERA_MUZZLE_HYBRID, "Mode "+eDebugMode.CAMERA_MUZZLE_HYBRID.ToString()+": shoot either from camera lens or from muzzle \n depending on the situation");
    }
    
    void ~WeaponDebug()
    {
        RemoveAllShapes(true);
        
    }
 
    void RemoveAllShapes(bool is_exit = false)
    {
        Debug.RemoveShape(m_Shape_usti);
        Debug.RemoveShape(m_Shape_konec);
        Debug.RemoveShape(m_ShapeFireDirection1);
        Debug.RemoveShape(m_ShapeFireDirection2);
        Debug.RemoveShape(m_ShapeEye);
        Debug.RemoveShape(m_ShapeTrailLines);
        Debug.RemoveShape(m_ShapeFireDirCamera);
        Debug.RemoveShape(m_HitShape);
        Debug.RemoveShape(m_HitShape2);
        Debug.RemoveShape(m_HitShape3);
        Debug.RemoveShape(m_HitShape4);
        
        if ( is_exit )
        {
            Debug.RemoveShape(m_PermanentLine1);
            Debug.RemoveShape(m_PermanentLine2);
            Debug.RemoveShape(m_PermanentShape1);
            Debug.RemoveShape(m_PermanentShape2);
        }
    }
 
 
    void OnCommandHandlerUpdate()
    {
            
        m_IsLMBPressed = false;
        m_IsFireKeyPressed = false;
        
        if (KeyState(KeyCode.KC_LWIN) == 1)
        {
            if (!m_IsDrawKeyHeldDown)
            {
                OnKeyDown(KeyCode.KC_LWIN);
            }
            m_IsDrawKeyHeldDown = true;
        }
        else
        {
            if ( m_IsDrawKeyHeldDown )
            {
                //OnKeyUp();
            }
            m_IsDrawKeyHeldDown = false;
        }
        
        if (KeyState(KeyCode.KC_Z) == 1)
        {
            ClearKey(KeyCode.KC_Z);
            CycleDebugMode();
        }
        
        if (KeyState(KeyCode.KC_X) == 1)
        {
            m_IsFireKeyPressed = true;
            ClearKey(KeyCode.KC_X);
        }
 
        if (GetMouseState(MouseState.LEFT) & MB_PRESSED_MASK)
        {
            m_IsLMBPressed = true;
        }
    }
 
    void OnKeyDown(KeyCode key)
    {
        if (key == KeyCode.KC_X)
        {
        }
    }
    
    void CycleDebugMode()
    {
        m_CurrentMode++;
        if ( m_CurrentMode == eDebugMode.COUNT )
        {
            m_CurrentMode = 0;
        }
    
    }
    
    void OnPostFrameUpdate()
    {
        if ( GetWeaponInHands() )
        {
            RemoveAllShapes();
            Weapon weapon = GetWeaponInHands();
            vector cameraDirection = GetGame().GetCurrentCameraDirection();
            vector cameraPosition = GetGame().GetCurrentCameraPosition();
            vector usti_hlavne_position = weapon.GetSelectionPositionMS( "usti hlavne" );//usti hlavne
            vector konec_hlavne_position = weapon.GetSelectionPositionMS( "konec hlavne" );//konec hlavne
            usti_hlavne_position = weapon.ModelToWorld(usti_hlavne_position);
            konec_hlavne_position = weapon.ModelToWorld(konec_hlavne_position);
            
            if ( m_CurrentMode == eDebugMode.NORMAL ) 
            {
                DrawLineOfFire(konec_hlavne_position,usti_hlavne_position );
            }
            
            if ( m_CurrentMode == eDebugMode.MUZZLE_FIRE ) 
            {
                DrawLineOfFireMuzzleToHit(usti_hlavne_position, cameraDirection, cameraPosition);
            }
            
            if ( m_CurrentMode == eDebugMode.CAMERA_MUZZLE_HYBRID ) 
            {
                DrawLineOfFireCameraHybrid(usti_hlavne_position, cameraDirection, cameraPosition, konec_hlavne_position);
            }
            
            if (m_IsDrawKeyHeldDown)
            {
                AddPosToCyclicBuffer(usti_hlavne_position);
                OrderTrailArray();
            }
 
            m_ShapeTrailLines = Debug.DrawLines( m_AimTrailOrdered,BUFFER_SIZE, COLOR_YELLOW, ShapeFlags.NOZBUFFER );
            
        
            DrawEyePoint(weapon);
            DrawBarrelMemoryPoints(konec_hlavne_position,usti_hlavne_position );
            DisplayGeneralInfo();
            DisplayTargetInfo();
            /*
            vector pos;
            weapon.GetProjectedCursorPos3d(pos);
            Debug.RemoveShape(temp_shape);
            temp_shape = Debug.DrawSphere(pos, 0.1, Colors.GREEN);
            */
        }
    }
 
    void DrawBarrelMemoryPoints(vector begin_point, vector end_point)
    {
        if (!m_IsDrawKeyHeldDown)
        {
            m_Shape_usti = Debug.DrawSphere(end_point, 0.011, Colors.GREEN, ShapeFlags.TRANSP|ShapeFlags.NOOUTLINE|ShapeFlags.NOZBUFFER);
            m_Shape_konec = Debug.DrawSphere(begin_point, 0.011, Colors.GREEN, ShapeFlags.TRANSP|ShapeFlags.NOOUTLINE|ShapeFlags.NOZBUFFER);
        }
    }
 
 
    void DrawLineOfFire(vector begin_point, vector end_point)
    {
        vector contact_point;
        vector contact_dir;
        vector aim_point = end_point - begin_point;
        int contact_component;
        
        aim_point = aim_point.Normalized() * 100;
        aim_point = aim_point + end_point;
        
        m_ShapeFireDirection1 = Debug.DrawLine(end_point, aim_point);
        m_ShapeFireDirection2 = Debug.DrawLine(begin_point, end_point, ShapeFlags.NOZBUFFER );
        
        if ( DayZPhysics.RaycastRV(end_point, aim_point, contact_point, contact_dir, contact_component, null, null, null, false, false, ObjIntersectFire) )
        {   
            m_HitShape = Debug.DrawSphere(contact_point, 0.04, COLOR_RED);
        }
        
        if ( m_IsFireKeyPressed )
        {
            Debug.RemoveShape(m_PermanentLine1);
            m_PermanentLine1 = Debug.DrawLine(end_point, contact_point, Colors.RED, ShapeFlags.NOZBUFFER );
        }
    }
 
    void AddPosToCyclicBuffer(vector pos)
    {
        m_AimTrailCyclic[m_BufferIndex] = pos;
        m_BufferIndex++;
        if (m_BufferIndex == BUFFER_SIZE)
        {
            m_BufferIndex = 0;         
        }
    }   
    
    void OrderTrailArray()
    {
        int unordered_index;
        
        for (int i = 0; i < BUFFER_SIZE; i++)
        {
            unordered_index = m_BufferIndex + i;
            if ( unordered_index >= BUFFER_SIZE )
            {
                unordered_index = unordered_index - BUFFER_SIZE;
            }
            m_AimTrailOrdered[i] = m_AimTrailCyclic[unordered_index];
        }
    }   
    
    void DrawEyePoint(Weapon weapon)
    {
        vector position = GetEyePointPosition(weapon);
        m_ShapeEye = Debug.DrawSphere(position, 0.009, COLOR_BLUE, ShapeFlags.TRANSP|ShapeFlags.NOOUTLINE|ShapeFlags.NOZBUFFER);
    }
 
    vector GetEyePointPosition(Weapon weapon)
    {
        string memory_point_name = weapon.ConfigGetString("memoryPointCamera");
        ItemBase optics = weapon.GetAttachedOptics();
        if (optics)
        {
            memory_point_name = optics.ConfigGetString("memoryPointCamera");
            return optics.ModelToWorld(optics.GetSelectionPositionLS( memory_point_name ));
        }
        return weapon.ModelToWorld(weapon.GetSelectionPositionLS( memory_point_name ));
        
    }
 
    void DisplayGeneralInfo()
    {
        DbgUI.Begin("sway weight", 50, 50);
        DayZPlayerImplement player = DayZPlayerImplement.Cast(GetGame().GetPlayer());
        float sway_weight = player.GetAimingModel().GetSwayWeight();
        DbgUI.Text("value: " + sway_weight.ToString());
        DbgUI.Text("Hold LWIN to draw debug line");
        DbgUI.Text("Press X to simulate fire");
        DbgUI.Text("Press Z to cycle debug modes");
        DbgUI.Text("Debug " +m_DebugModesNames.Get(m_CurrentMode) );
        DbgUI.Text("");
        DbgUI.End();
    }
 
    void DisplayTargetInfo()
    {
        DbgUI.Begin("target distance", 50,200);
        DbgUI.Text("value: " + m_TargetDistance.ToString());
        DbgUI.End();
    }
 
        
    void DrawLineOfFireMuzzleToHit(vector begin_point, vector camera_dir, vector camera_pos)
    {
        vector contact_point_cam_trace;
        vector contact_point_muzzle_trace;
        
        vector contact_dir_muzzle;
        vector contact_dir_camera;
        
        vector contact_point;
        vector contact_dir;
        
        int contact_component;
        int contact_component_muzzle;
        
        vector end_point = camera_pos + camera_dir * 1000;
        Man player = GetGame().GetPlayer();
        Object player_o;
        Class.CastTo(player_o, player);
        
        if ( DayZPhysics.RaycastRV(camera_pos, end_point, contact_point_cam_trace, contact_dir_camera, contact_component,null, null, player_o , false, false, ObjIntersectFire, 0.1) )
        {
            m_ShapeFireDirCamera = Debug.DrawLine(begin_point, contact_point_cam_trace, Colors.RED, ShapeFlags.NOZBUFFER );
            m_HitShape2 = Debug.DrawSphere(contact_point_cam_trace, 0.03, Colors.GREEN);
            m_TargetDistance =  vector.Distance( player.GetPosition(), contact_point_cam_trace);
            
            if ( m_IsFireKeyPressed )
            {
                Debug.RemoveShape(m_PermanentLine1);
                Debug.RemoveShape(m_PermanentLine2);
                m_PermanentLine1 = Debug.DrawLine(begin_point, contact_point_cam_trace, Colors.RED, ShapeFlags.NOZBUFFER );
                m_PermanentLine2 = Debug.DrawLine(camera_pos, contact_point_cam_trace, Colors.GREEN, ShapeFlags.NOZBUFFER );
            }
            
        }
        
        else
        {
            m_ShapeFireDirCamera = Debug.DrawLine(begin_point, end_point, Colors.GREEN, ShapeFlags.NOZBUFFER );
            m_TargetDistance = -1;
        }
        
        if ( DayZPhysics.RaycastRV(begin_point, contact_point_cam_trace, contact_point_muzzle_trace, contact_dir_muzzle, contact_component_muzzle, null, null, null, false, false, ObjIntersectFire, 0.0) )
        {
            m_HitShape3 = Debug.DrawSphere(contact_point_muzzle_trace, 0.03, COLOR_RED);
        }
    }
 
    void DrawLineOfFireCameraHybrid(vector usti_hlavne_position, vector camera_dir, vector camera_pos, vector konec_hlavne_position)
    {
        bool muzzle_shot;
        vector contact_point_cam_trace;
        vector contact_point_muzzle_trace;
        
        vector aim_at_position;
        
        vector contact_dir_muzzle;
        vector contact_dir;
        
        vector contact_point;
        
        int contact_component;
        int contact_component_muzzle;
        
        float distance_to_aim_at;
        vector end_point = camera_pos + camera_dir * 100;
        vector start_point = camera_pos + (CAMERA_BULLET_ORIGIN_OFFSET * camera_dir);
        vector weapon_aim_direction = usti_hlavne_position - konec_hlavne_position;
        weapon_aim_direction.Normalize();
        
        Man player = GetGame().GetPlayer();
        Object player_o;
        Class.CastTo(player_o, player);
 
        if ( DayZPhysics.RaycastRV(start_point, end_point, contact_point_cam_trace, contact_dir, contact_component,null, null, player_o , false, false, ObjIntersectFire) )
        {
            m_TargetDistance = vector.Distance(start_point, contact_point_cam_trace);
            aim_at_position = contact_point_cam_trace;
            
            if ( DayZPhysics.RaycastRV(usti_hlavne_position, contact_point_cam_trace, contact_point_muzzle_trace, contact_dir, contact_component,null, null, player_o , false, false, ObjIntersectFire, 0.05) )
            {
                float collision_distance = vector.Distance(contact_point_cam_trace, contact_point_muzzle_trace);
                float muzzle_collision_distance = vector.Distance(usti_hlavne_position, contact_point_muzzle_trace);
                
                if ((collision_distance > 2 && muzzle_collision_distance < MAX_MUZZLE_DISTANCE_TOLERANCE) || m_TargetDistance < CAMERA_TRACE_MIN_DISTANCE_TOLERANCE)
                {
                    muzzle_shot = true;
                    aim_at_position = contact_point_muzzle_trace;
                }
            }
        }
        
        
        
        distance_to_aim_at = vector.Distance(camera_pos, aim_at_position);
        
        if ( m_IsFireKeyPressed )
        {
            Debug.RemoveShape(m_PermanentLine1);
            Debug.RemoveShape(m_PermanentLine2);
            Debug.RemoveShape(m_PermanentShape1);
            
            vector contact_point_temp;
            
            if (muzzle_shot)
            {
                m_PermanentLine1 = Debug.DrawLine(usti_hlavne_position, usti_hlavne_position + weapon_aim_direction * 5, Colors.RED, ShapeFlags.NOZBUFFER );
                m_PermanentLine2 = Debug.DrawLine(camera_pos, contact_point_cam_trace, Colors.GREEN, ShapeFlags.NOZBUFFER );
                PrintString("muzle shot");
            }
            else
            {
                vector dir = contact_point_cam_trace - camera_pos;
                dir.Normalize();
                dir = dir * 100;
                float dst = vector.Distance(camera_pos, contact_point_cam_trace);
                float dist2 = vector.Distance(camera_pos, contact_point_cam_trace);
                
                //m_PermanentShape1 = Debug.DrawSphere(start_point, 0.015,Colors.GREEN);
                m_PermanentLine1 = Debug.DrawLine(start_point, contact_point_cam_trace + dir, Colors.RED, ShapeFlags.NOZBUFFER );
                PrintString("camera shot");
            }
        }
        
        float clamped_distance = Math.Clamp(distance_to_aim_at, 0 , 100);
        float distance_normalized = Math.InverseLerp(0, 100, clamped_distance);
        float hit_sphere_size = Math.Lerp(0.025, 0.75, distance_normalized);
        
        Debug.RemoveShape(m_HitShape4);
        Debug.RemoveShape(m_HitShape);
        m_HitShape = Debug.DrawSphere(contact_point_cam_trace, 0.20,Colors.GREEN, ShapeFlags.TRANSP);
        m_HitShape4 = Debug.DrawSphere(aim_at_position, hit_sphere_size);
    
    }
    
}