◆ OnRPC() [1/2]

override void CGame::OnRPC	(	PlayerIdentity	sender,
		Object	target,
		int	rpc_type,
		ParamsReadContext	ctx )
inlineprotected
См. определение в файле DayZGame.c строка 3086
    {
        super.OnRPC(sender, target, rpc_type, ctx);
        Event_OnRPC.Invoke(sender, target, rpc_type, ctx);
        
        //Print("["+ g_Game.GetTime().ToString() +"] => DayZGame::OnRPC = "+ EnumTools.EnumToString(ERPCs,rpc_type));
        
        if (target)
        {
            // call rpc on target
            target.OnRPC(sender, rpc_type, ctx);
        }
        else
        {
            switch (rpc_type)
            {
                #ifndef SERVER
                #ifndef NO_GUI
                case ERPCs.RPC_CFG_GAMEPLAY_SYNC:
                {
                    CfgGameplayHandler.OnRPC(null, ctx);
                    break;
                }
                case ERPCs.RPC_UNDERGROUND_SYNC:
                {
                    UndergroundAreaLoader.OnRPC(ctx);
                    break;
                }
                case ERPCs.RPC_PLAYERRESTRICTEDAREAS_SYNC:
                {
                    CfgPlayerRestrictedAreaHandler.OnRPC(ctx);
                    break;
                }
                case ERPCs.RPC_SEND_NOTIFICATION:
                {
                    NotificationType type;
                    float show_time;
                    string detail_text;
                    
                    ctx.Read(type);
                    ctx.Read(show_time);
                    ctx.Read(detail_text);
                    
                    NotificationSystem.AddNotification(type, show_time, detail_text);
                    break;
                }
                case ERPCs.RPC_SEND_NOTIFICATION_EXTENDED:
                {
                    float show_time_ext;
                    string title_text_ext;
                    string detail_text_ext;
                    string icon_ext;
                    
                    ctx.Read(show_time_ext);
                    ctx.Read(title_text_ext);
                    ctx.Read(detail_text_ext);
                    ctx.Read(icon_ext);
                    
                    NotificationSystem.AddNotificationExtended(show_time_ext, title_text_ext, detail_text_ext, icon_ext);
                    break;
                }
                
                
                case ERPCs.RPC_SOUND_HELICRASH:
                {
                    bool playSound;
                    vector pos;
                    string sound_set;
                    
                    //Helicrash is a world event, we want anyone to be able to hear it
                    Param3<bool, vector, int> playCrashSound = new Param3<bool, vector, int>(false, "0 0 0",0);
                    if (ctx.Read(playCrashSound))
                    {
                        playSound = playCrashSound.param1;
                        pos = playCrashSound.param2;
                        sound_set = CrashSoundSets.GetSoundSetByHash(playCrashSound.param3);
                    }
                    
                    if (playSound)
                    {
                        m_CrashSound = SEffectManager.PlaySound(sound_set, pos, 0.1, 0.1);
                        m_CrashSound.SetAutodestroy(true);
                    }
                
                break;
                }
                //Random off map artillery barrage
                case ERPCs.RPC_SOUND_ARTILLERY:
                {
                    vector position;
                    Param1<vector> playArtySound = new Param1<vector>(vector.Zero);
                    if (ctx.Read(playArtySound))
                    {
                        position = playArtySound.param1;
                        if (position == vector.Zero)
                            break;
                    }
                    else
                        break;
                    
                    if (!g_Game.GetPlayer())
                        break;
                    
                    if (vector.DistanceSq(g_Game.GetPlayer().GetPosition(), position) <= (MIN_ARTY_SOUND_RANGE * MIN_ARTY_SOUND_RANGE))
                        break;
                    
                    m_ArtySound = SEffectManager.PlaySound("Artillery_Distant_Barrage_SoundSet", position, 0.1, 0.1);
                    m_ArtySound.SetAutodestroy(true);
                
                break;
                }
                case ERPCs.RPC_SOUND_CONTAMINATION:
                {
                    vector soundPos;
                    
                    Param1<vector> playContaminatedSound = new Param1<vector>(vector.Zero);
                    if (ctx.Read(playContaminatedSound))
                    {
                        soundPos = playContaminatedSound.param1;
                        if (soundPos == vector.Zero)
                            break;
                    }
                    else
                        break;
                    
                    if (!g_Game.GetPlayer())
                        break;
                    
                    EffectSound closeArtySound = SEffectManager.PlaySound("Artillery_Close_SoundSet", soundPos);
                    closeArtySound.SetAutodestroy(true);
                    
                    // We add camera shake upon shell detonation
                    float distance_to_player = vector.DistanceSq(soundPos, g_Game.GetPlayer().GetPosition());
                    if (distance_to_player <= GameConstants.CAMERA_SHAKE_ARTILLERY_DISTANCE2)
                    {
                        float strength_factor = Math.InverseLerp(GameConstants.CAMERA_SHAKE_ARTILLERY_DISTANCE, 0, Math.Sqrt(distance_to_player));
                        DayZPlayerCamera camera = g_Game.GetPlayer().GetCurrentCamera();
                        if (camera)
                            camera.SpawnCameraShake(strength_factor * 4);
                    }
                    
                    ParticleManager.GetInstance().PlayInWorld(ParticleList.CONTAMINATED_AREA_GAS_SHELL, soundPos);
                    break;
                }
                // Single artillery shot to announce dynamic contaminated area
                case ERPCs.RPC_SOUND_ARTILLERY_SINGLE:
                {
                    vector soundPosition;
                    vector delayedSoundPos;
                    float soundDelay;
                    
                    Param3<vector, vector, float> playArtyShotSound = new Param3<vector, vector, float>(vector.Zero, vector.Zero, 0);
                    if (ctx.Read(playArtyShotSound))
                    {
                        soundPosition = playArtyShotSound.param1;
                        delayedSoundPos = playArtyShotSound.param2;
                        soundDelay = playArtyShotSound.param3;
                        if (soundPosition == vector.Zero)
                            break;
                    }
                    else
                        break;
                    
                    if (!g_Game.GetPlayer())
                        break;
                    
                    m_ArtySound = SEffectManager.PlaySound("Artillery_Distant_SoundSet", soundPosition, 0.1, 0.1);
                    m_ArtySound.SetAutodestroy(true);
                    
                    // We remove the amount of time the incoming sound lasts
                    soundDelay -= 5;
                    // We convert to milliseconds
                    soundDelay *= 1000;
                    GetCallQueue(CALL_CATEGORY_GAMEPLAY).CallLater(DelayedMidAirDetonation, soundDelay, false, delayedSoundPos[0], delayedSoundPos[1], delayedSoundPos[2]);
                    break;
                }
                case ERPCs.RPC_SET_BILLBOARDS:
                {
                    if (!m_BillboardSetHandler)
                        m_BillboardSetHandler = new BillboardSetHandler();
                    
                    Param1<int> indexP = new Param1<int>(-1);
                    if (ctx.Read(indexP))
                    {
                        int index = indexP.param1;
                        m_BillboardSetHandler.OnRPCIndex(index);
                    }
                    break;
                }
                #endif
                #endif
 
                case ERPCs.RPC_USER_SYNC_PERMISSIONS:
                {
                    map<string, bool> mute_list;
                    if (ctx.Read(mute_list))
                    {
                        for (int i = 0; i < mute_list.Count(); i++)
                        {
                            string uid = mute_list.GetKey(i);
                            bool mute = mute_list.GetElement(i);
                            MutePlayer(uid, sender.GetPlainId(), mute);
                        }
                    }
                    break;
                }
                
                /*
                case ERPCs.RPC_SERVER_RESPAWN_MODE:
                {
                    int mode;
                    if (ctx.Read(mode) && !IsServer())
                    {
                        GetMission().SetRespawnModeClient(mode);
                    }
                }
                */
 
                #ifdef DEVELOPER
                case ERPCs.DEV_SET_WEATHER:
                {
                    Param1<DebugWeatherRPCData> p1data = new Param1<DebugWeatherRPCData>(null);
                    
                    if ( ctx.Read(p1data) )
                    {
                        DebugWeatherRPCData data = p1data.param1;
                        
                        if (data.m_FogValue >= 0)
                            g_Game.GetWeather().GetFog().Set(data.m_FogValue, data.m_FogInterpolation, data.m_FogDuration);
                        
                        if (data.m_OvercastValue >= 0)
                            g_Game.GetWeather().GetOvercast().Set(data.m_OvercastValue, data.m_OvercastInterpolation, data.m_OvercastDuration);
                        
                        if (data.m_RainValue >= 0)
                            g_Game.GetWeather().GetRain().Set(data.m_RainValue, data.m_RainInterpolation, data.m_RainDuration);
                        
                        if (data.m_SnowfallValue >= 0)
                            g_Game.GetWeather().GetSnowfall().Set(data.m_SnowfallValue, data.m_SnowfallInterpolation, data.m_SnowfallDuration);
                        
                        if (data.m_VolFogDistanceDensity >= 0)
                            g_Game.GetWeather().SetDynVolFogDistanceDensity(data.m_VolFogDistanceDensity, data.m_VolFogDistanceDensityTime);
                        
                        if (data.m_VolFogHeightDensity >= 0)
                            g_Game.GetWeather().SetDynVolFogHeightDensity(data.m_VolFogHeightDensity, data.m_VolFogHeightDensityTime);
                        
                        if (data.m_VolFogHeightBias >= -500)
                            g_Game.GetWeather().SetDynVolFogHeightBias(data.m_VolFogHeightBias, data.m_VolFogHeightBiasTime);
                        
                        if (data.m_WindMagnitudeValue >= 0)
                            g_Game.GetWeather().GetWindMagnitude().Set(data.m_WindMagnitudeValue, data.m_WindDInterpolation, data.m_WindDDuration);
                        
                        if (data.m_WindDirectionValue >= -3.14)
                            g_Game.GetWeather().GetWindDirection().Set(data.m_WindDirectionValue, data.m_WindDInterpolation, data.m_WindDDuration);
                    }
                    else
                    {
                        ErrorEx("Failed to read weather debug data");
                    }
                    break;
                }
                #endif
                
                
                #ifdef DIAG_DEVELOPER
                #ifdef SERVER
                case ERPCs.DIAG_CAMERATOOLS_CAM_DATA:
                {
                    if (!m_CameraToolsMenuServer)
                    {
                        m_CameraToolsMenuServer = new CameraToolsMenuServer;
                    }
                    m_CameraToolsMenuServer.OnRPC(rpc_type, ctx);
                    break;
                }
                
                case ERPCs.DIAG_CAMERATOOLS_CAM_SUBSCRIBE:
                {
                    if (!m_CameraToolsMenuServer)
                    {
                        m_CameraToolsMenuServer = new CameraToolsMenuServer;
                    }
                    m_CameraToolsMenuServer.OnRPC(rpc_type, ctx);
                    break;
                }
 
                #endif
                #endif
 
            }
            // global rpc's handling
        }
    }