public void OnVertified(VerifiedEventArgs ev)
{
Timing.CallDelayed(0.3f, () =>
{
Map.ClearBroadcasts();
switch (OnlySpecificPlayersBeDisplayedMode)
{
case 0:
OnlySpecificPlayersBeDisplayedMode0(true, ev.Player);
break;
case 1:
OnlySpecificPlayersBeDisplayedMode1(true, ev.Player);
break;
case 2:
OnlySpecificPlayersBeDisplayedMode2(true, ev.Player);
break;
default:
Log.Warn("The OnlySpecificPlayersBeDisplayedMode config variable can only be 0 - off, 1 - the players given should be displayed with a costume mesage and so do the others with the default, 2 - only the players given should be displayed only with the message given.");
break;
}
});
}
private void Spawn()
{
float chances = 0;
for (int i = 0; i < _enemiesPool.Length; ++i)
{
chances += _enemiesPool[i].Chances;
}
float random = Random.Range(0, chances);
for (int i = 0; i < _enemiesPool.Length; ++i)
{
chances -= _enemiesPool[i].Chances;
if (chances <= random)
{
Enemy enemy = _enemiesPool[i].Activate(new Vector3(
Random.Range(_minSpawnPositionX, _maxSpawnPositionX),
2f,
_spawnPositionZ));
_enemyList.Add(enemy);
break;
}
}
_spawnCoroutine = Timing.CallDelayed(
Random.Range(_minDelay, _maxDelay),
Spawn);
}
private void OnMedicalItemDeEquipped(DequippedMedicalItemEventArgs ev)
{
if (!Check(ev.Player.CurrentItem))
{
return;
}
if (scp1499Players.ContainsKey(ev.Player))
{
scp1499Players[ev.Player] = ev.Player.Position;
}
else
{
scp1499Players.Add(ev.Player, ev.Player.Position);
}
ev.Player.Position = scp1499DimensionPos;
ev.Player.ReferenceHub.playerEffectsController.DisableEffect <Scp268>();
if (Duration > 0)
{
Timing.CallDelayed(Duration, () =>
{
SendPlayerBack(ev.Player);
});
}
}
private void OnThrowingGrenade(ThrowingGrenadeEventArgs ev)
{
if (CheckItem(ev.Player.CurrentItem))
{
ev.IsAllowed = false;
Grenade grenadeComponent = ev.Player.GrenadeManager.availableGrenades[0].grenadeInstance.GetComponent <Grenade>();
Timing.CallDelayed(1f, () =>
{
Vector3 pos = ev.Player.CameraTransform.TransformPoint(grenadeComponent.throwStartPositionOffset);
if (ExplodeOnCollision)
{
var grenade = SpawnGrenade(pos, ev.Player.CameraTransform.forward * 9f, 1.5f, GetGrenadeType(ItemType)).gameObject;
CollisionHandler collisionHandler = grenade.gameObject.AddComponent <CollisionHandler>();
collisionHandler.owner = ev.Player.GameObject;
collisionHandler.grenade = grenadeComponent;
TrackedGrenades.Add(grenade);
}
else
{
SpawnGrenade(pos, ev.Player.CameraTransform.forward * 9f, FuseTime, GetGrenadeType(ItemType));
}
ev.Player.RemoveItem(ev.Player.CurrentItem);
});
}
}
private void OnEnterPocketDimension(EnteringPocketDimensionEventArgs ev)
{
Log.Debug($"{ev.Player.Nickname} Entering Pocket Dimension.", Plugin.Singleton.Config.Debug);
if (onCooldown)
{
Log.Debug($"{ev.Player.Nickname} - Not spawning, on cooldown.", Plugin.Singleton.Config.Debug);
return;
}
if (isDropped && ev.Position.y < -1900f)
{
Log.Debug($"{ev.Player.Nickname} - EPD checks passed.", Plugin.Singleton.Config.Debug);
foreach (PocketDimensionTeleport teleport in teleports)
{
Log.Debug($"{ev.Player.Nickname} - Checking teleporter..", Plugin.Singleton.Config.Debug);
if (teleport.type == PocketDimensionTeleport.PDTeleportType.Exit)
{
onCooldown = true;
Log.Debug($"{ev.Player.Nickname} - Valid exit found..", Plugin.Singleton.Config.Debug);
Vector3 tpPos = teleport.transform.position;
float dist = Vector3.Distance(tpPos, ev.Position);
Vector3 spawnPos = Vector3.MoveTowards(tpPos, ev.Position, dist / 2);
Log.Debug($"{ev.Player.Nickname} - TP: {tpPos}, Dist: {dist}, Spawn: {spawnPos}", Plugin.Singleton.Config.Debug);
Pickup coin = Exiled.API.Extensions.Item.Spawn(ItemType.Coin, 0f, spawnPos);
Timing.CallDelayed(2f, () => coin.Delete());
Timing.CallDelayed(120f, () => onCooldown = false);
}
}
}
}
private void OnPlayerJoin(JoinedEventArgs ev)
{
if (IntercomText != null)
{
Timing.CallDelayed(2f, () => ReferenceHub.HostHub.GetComponent <Intercom>().CustomContent = IntercomText);
}
}
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
Player player;
if (!sender.CheckPermission("manager.spawn"))
{
response = "You don't have enough permissions.";
return(false);
}
else if (arguments.Count != 1 || !int.TryParse(arguments.At(0), out int id))
{
response = "Incorrect arguments. Try: spawnmanager";
return(false);
}
else if ((player = Player.Get(id)) == null)
{
response = $"Player with the id {id} can't be found.";
return(false);
}
else if (EventHandlers.manager.Count != 0)
{
response = "There is already a Manager in this facility!";
return(false);
}
else
{
Timing.CallDelayed(1f, delegate()
{
EventHandlers.spawnmanager(player);
});
}
response = $"Done, {player.Nickname} is now the Manager!!";
return(true);
}
private static void Postfix(GameObject player)
{
try
{
if (!API.Features.Player.Dictionary.TryGetValue(player, out API.Features.Player newPlayer))
{
newPlayer = new API.Features.Player(ReferenceHub.GetHub(player));
API.Features.Player.Dictionary.Add(player, newPlayer);
}
API.Features.Log.Debug($"Player {newPlayer?.Nickname} ({newPlayer?.UserId}) connected with the IP: {newPlayer?.IPAddress}");
if (PlayerManager.players.Count >= CustomNetworkManager.slots)
{
API.Features.Log.Debug($"Server is full!");
}
Timing.CallDelayed(0.25f, () =>
{
if (newPlayer != null && newPlayer.IsMuted)
{
newPlayer.ReferenceHub.characterClassManager.SetDirtyBit(1UL);
}
});
var ev = new JoinedEventArgs(API.Features.Player.Get(player));
Player.OnJoined(ev);
}
catch (Exception exception)
{
API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.Joined: {exception}\n{exception.StackTrace}");
}
}
public void OnRoundStart()
{
allowSwaps = true;
isRoundStarted = true;
Timing.CallDelayed(plugin.Config.SwapTimeout, () => allowSwaps = false);
Timing.CallDelayed(1f, () => BroadcastMessage());
}
protected override void OnReloadingWeapon(ReloadingWeaponEventArgs ev)
{
if (CheckItem(ev.Player.CurrentItem))
{
if (Plugin.Singleton.Config.ItemConfigs.GlCfg.UseGrenades)
{
ev.IsAllowed = false;
Log.Debug($"{ev.Player.Nickname} is reloading a {Name}!", Plugin.Singleton.Config.Debug);
foreach (Inventory.SyncItemInfo item in ev.Player.Inventory.items.ToList())
{
if (item.id == ItemType.GrenadeFrag)
{
ev.Player.ReferenceHub.weaponManager.scp268.ServerDisable();
Reload(ev.Player);
ev.Player.Inventory.items.ModifyDuration(ev.Player.Inventory.GetItemIndex(), ClipSize);
Log.Debug($"{ev.Player.Nickname} successfully reloaded a {Name}.",
Plugin.Singleton.Config.Debug);
Timing.CallDelayed(4.5f, () => { Reload(ev.Player); });
ev.Player.RemoveItem(item);
break;
}
}
Log.Debug($"{ev.Player.Nickname} was unable to reload their {Name} - No grenades in inventory.",
Plugin.Singleton.Config.Debug);
}
else
{
base.OnReloadingWeapon(ev);
}
}
}
public override void OnWork(CuboController user)
{
PlayerCommands.Get().OnCuboDestroyed();
user.GetComponentInChildren <Selectable>().enabled = false;
GameObject model = user.model;
model.transform.DOPunchScale(new Vector3(1.025f, 0.8f, 1.025f), 0.25f, 0, 2f);
Sequence seq = DOTween.Sequence();
seq.Append(model.transform.DOLocalMoveY(5f, sacrificeTime).SetEase(Ease.InQuad));
seq.Join(model.transform.DOScale(0f, sacrificeTime - 0.4f).SetEase(Ease.InQuad).SetDelay(0.4f));
seq.Play();
Camera.main.GetComponent <AudioSource>().PlayOneShot(sacrificeNoise);
Timing.CallDelayed(sacrificeTime + 0.1f, delegate
{
Instantiate(workFxObj, transform.position + Vector3.up * 17f, Quaternion.LookRotation(Vector3.up, Vector3.left));
power++;
UIStatic.SetInt(UIStatic.CUR_SACRIFICE, power);
Destroy(user.gameObject);
if (power >= goalPower)
{
PlayerCommands.Get().Win();
}
});
}
internal static void OnJoin(VerifiedEventArgs ev)
{
if (ev.Player?.UserId == null || ev.Player.IsHost || !ev.Player.IsVerified || ev.Player.IPAddress == "127.0.0.WAN" || ev.Player.IPAddress == "127.0.0.1")
{
return;
}
if (firstJoin)
{
firstJoin = false;
Verification.UpdateID();
}
Timing.CallDelayed(.2f, () =>
{
StatHandler.SendRequest(RequestType.UserData, Helper.HandleId(ev.Player));
});
if (!Round.IsStarted && Players.Contains(ev.Player.RawUserId) || ev.Player.DoNotTrack)
{
return;
}
StatHandler.SendRequest(RequestType.Join, "{\"playerid\": \"" + Helper.HandleId(ev.Player) + "\"}");
Players.Add(ev.Player.RawUserId);
}
internal static void OnRoleChanged(ChangingRoleEventArgs ev)
{
if (ev.Player?.UserId == null || ev.Player.IsHost || !ev.Player.IsVerified || ev.Player.IPAddress == "127.0.0.WAN" || ev.Player.IPAddress == "127.0.0.1")
{
return;
}
if (ev.NewRole != RoleType.None && ev.NewRole != RoleType.Spectator)
{
Timing.CallDelayed(.5f, () => ev.Player.SpawnCurrentHat());
}
if (PauseRound || Round.ElapsedTime.Seconds < 5 || !RoundSummary.RoundInProgress() || !Helper.IsPlayerValid(ev.Player, true, false))
{
return;
}
if (ev.IsEscaped)
{
StatHandler.SendRequest(RequestType.Escape, "{\"playerid\": \"" + Helper.HandleId(ev.Player) + "\", \"role\": \"" + ((int)ev.Player.Role).ToString() + "\"}");
}
if (ev.NewRole == RoleType.None || ev.NewRole == RoleType.Spectator)
{
return;
}
StatHandler.SendRequest(RequestType.Spawn, "{\"playerid\": \"" + Helper.HandleId(ev.Player) + "\", \"spawnrole\": \"" + ((int)ev.NewRole).ToString() + "\"}");
}
private void Player_PlayerSetClassEvent(PlayerSetClassEventArgs ev)
{
Timing.CallDelayed(0.01f, () =>
{
if (CustomLoadout.Config.RoleInventory.Any((_) => _.RoleID == ev.Player.RoleID))
{
var loadout = CustomLoadout.Config.RoleInventory.FirstOrDefault((_) => _.RoleID == ev.Player.RoleID);
if (loadout is null)
{
return;
}
uint ammo5 = loadout.AmmoConfig.ReplaceAmmo ? loadout.AmmoConfig.Ammo5 : ev.Player.Ammo5;
uint ammo7 = loadout.AmmoConfig.ReplaceAmmo ? loadout.AmmoConfig.Ammo7 : ev.Player.Ammo7;
uint ammo9 = loadout.AmmoConfig.ReplaceAmmo ? loadout.AmmoConfig.Ammo9 : ev.Player.Ammo9;
if (loadout.ReplaceDefault)
{
ev.Player.Inventory.Clear();
}
foreach (var item in loadout.Items)
{
if (UnityEngine.Random.Range(0f, 100f) <= item.Chance)
{
ev.Player.Inventory.AddItem(item.Item.Parse());
}
ev.Player.Ammo5 = ammo5;
ev.Player.Ammo7 = ammo7;
ev.Player.Ammo9 = ammo9;
}
}
});
}
private IEnumerator <float> Check079(float delay = 1f)
{
if (Map.ActivatedGenerators != 5 && canChange)
{
yield return(Timing.WaitForSeconds(delay));
IEnumerable <Player> enumerable = Player.List.Where(x => x.Team == Team.SCP);
if (!Lone079.instance.Config.CountZombies)
{
enumerable = enumerable.Where(x => x.Role != RoleType.Scp0492);
}
List <Player> pList = enumerable.ToList();
if (pList.Count == 1 && pList[0].Role == RoleType.Scp079)
{
Player player = pList[0];
int level = player.Level;
RoleType role = scp079Respawns[rand.Next(scp079Respawns.Count)];
if (is106Contained && role == RoleType.Scp106)
{
role = RoleType.Scp93953;
}
player.SetRole(role);
Timing.CallDelayed(1f, () => player.Position = scp939pos);
player.Health = !Lone079.instance.Config.ScaleWithLevel ? player.MaxHealth * (Lone079.instance.Config.HealthPercent / 100f) : player.MaxHealth * ((Lone079.instance.Config.HealthPercent + ((level - 1) * 5)) / 100f);
player.Broadcast(10, "<i>You have been respawned as a random SCP with half health because all other SCPs have died.</i>");
}
}
}
public override void OnEnable()
{
CheckDiscordIntegration();
isEnabled = Config.GetBool("dabm_enable", true);
language = Config.GetString("dabm_language");
LoadTranslations();
CheckNewVersion("https://pastebin.com/raw/f1Rimvcd", "1.0.4", "https://pastebin.com/raw/YRjySYAG", getName);
Timing.CallDelayed(1f, () =>
{
if (!isEnabled)
{
Log.Info($"{msgconfigdis}");
return;
}
if (!hasDiscordIntegration)
{
Log.Info($"{msgnodiscordint}");
}
LoadConfig();
Log.Info($"{msgconfigenabled}");
EventHandlers = new EventHandlers(this);
Events.PlayerBannedEvent += EventHandlers.OnPlayerBan;
Events.RemoteAdminCommandEvent += EventHandlers.OnRACommand;
});
}
//Do not use this as plugin command handler, this is only meant to handle the EXILED reload command, handle commands similarly from within your plugin.
public static void CommandHandler(ref RACommandEvent ev)
{
string[] args = ev.Command.Split(' ');
switch (args[0].ToLower())
{
case "reloadplugins":
ev.Allow = false;
PluginManager.ReloadPlugins();
ev.Sender.RAMessage("Reloading ploogins...");
break;
case "reloadconfigs":
ev.Allow = false;
Plugin.Config.Reload();
ev.Sender.RAMessage("Configs have been reloaded!");
break;
case "reconnectrs":
ev.Allow = false;
PlayerManager.localPlayer.GetComponent <PlayerStats>()?.Roundrestart();
Timing.CallDelayed(1.5f, Application.Quit);
break;
}
}
public static void MakeNobody(Player nobody, Vector3 spawn_pos)
{
nobody.Role = RoleType.Tutorial;
nobody.MaxHealth = Plugin.Instance.Config.NobodyHealth;
nobody.Health = nobody.MaxHealth;
foreach (ItemType item in Plugin.Instance.Config.NobodyStartItems)
{
nobody.AddItem(item);
}
nobody.Ammo[(int)AmmoType.Nato556] = Plugin.Instance.Config.Nobody5Ammo;
nobody.Ammo[(int)AmmoType.Nato762] = Plugin.Instance.Config.Nobody7Ammo;
nobody.Ammo[(int)AmmoType.Nato9] = Plugin.Instance.Config.Nobody9Ammo;
Timing.CallDelayed(0.5f, () =>
{
nobody.ReferenceHub.playerMovementSync.AddSafeTime(1.0f);
nobody.Position = spawn_pos + new Vector3(0, 0.75f, 0);
});
nobody.Broadcast(5, Plugin.Instance.Config.NobodyPrivateBroadcast);
if (Plugin.Instance.Config.NobodyCmdMessage.Length != 0)
{
nobody.SendConsoleMessage(Plugin.Instance.Config.NobodyCmdMessage, "yellow");
}
Map.Broadcast(5, Plugin.Instance.Config.NobodyGlobalBroadcast);
if (Plugin.Instance.Config.NobodyCassieAnnouncement.Length != 0)
{
Cassie.Message(Plugin.Instance.Config.NobodyCassieAnnouncement, false, false);
}
}
private void OnUsingItem(UsedItemEventArgs ev)
{
Log.Debug($"{ev.Player.Nickname} used a medical item: {ev.Item}", CustomItems.Instance.Config.IsDebugEnabled);
if (!Check(ev.Player.CurrentItem))
{
return;
}
Timing.CallDelayed(1.5f, () =>
{
Log.Debug($"{ev.Player.Nickname} used a {Name}", CustomItems.Instance.Config.IsDebugEnabled);
foreach (Exiled.API.Features.Player player in Exiled.API.Features.Player.List)
{
if (player.Role == RoleType.Scp096)
{
Log.Debug($"{ev.Player.Nickname} - {Name} found an 096: {player.Nickname}", CustomItems.Instance.Config.IsDebugEnabled);
if (!(player.CurrentScp is Scp096 scp096))
{
continue;
}
Log.Debug($"{player.Nickname} 096 component found.", CustomItems.Instance.Config.IsDebugEnabled);
if ((!scp096.HasTarget(ev.Player.ReferenceHub) ||
scp096.PlayerState != Scp096PlayerState.Enraged) &&
scp096.PlayerState != Scp096PlayerState.Enraging &&
scp096.PlayerState != Scp096PlayerState.Attacking)
{
continue;
}
Log.Debug($"{player.Nickname} 096 checks passed.", CustomItems.Instance.Config.IsDebugEnabled);
scp096.EndEnrage();
ev.Player.Hurt(new UniversalDamageHandler(-1f, DeathTranslations.Poisoned));
return;
}
public static void TrySpawnNobody()
{
if (Plugin.Instance.Random.Next(0, 100) < Plugin.Instance.Config.NobodyChance)
{
handle = Timing.CallDelayed(Plugin.Instance.Random.Next(Plugin.Instance.Config.NobodyMinTime, Plugin.Instance.Config.NobodyMaxTime), () => SpawnNobody());
}
}
public static void Load(Harmony harmony)
{
Logger.Info("Loading Exiled plugins");
harmony.Patch(AccessTools.Method(typeof(Paths), nameof(Paths.Reload)), new HarmonyMethod(typeof(ExiledLoader), nameof(PathsPatch)));
Paths.Reload();
File.Open(Paths.Config, FileMode.OpenOrCreate, FileAccess.Read).Dispose();
Timing.CallDelayed(0.25f, () =>
{
var modDescription = BuildInfoCommand.ModDescription;
global::Exiled.Loader.Loader.Config.Environment = EnvironmentType.Production;
global::Exiled.Loader.Loader.Run();
var mod = SixModLoader.Instance.ModManager.GetMod <ExiledMod>();
BuildInfoCommand.ModDescription = modDescription + $"\nExiled compatibility: {mod.Info.Version} - {mod.Instance.Loaded}";
try
{
EventManager.Instance.Register(new EventsCompatibility());
}
catch (Exception e) when(e is InvalidOperationException || e is TypeLoadException || e is FileNotFoundException)
{
Logger.Warn("Exiled Events plugin not found!\n" + e);
}
harmony.Patch(AccessTools.Method(typeof(SixModLoaderCommand.ModsCommand), nameof(SixModLoaderCommand.ModsCommand.Execute)), postfix: new HarmonyMethod(typeof(ExiledLoader), nameof(ModsCommandPatch)));
});
}
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
if (!((CommandSender)sender).CheckPermission("fctrl.respawn"))
{
response = "Access denied.";
return(false);
}
if (arguments.Count() < 1)
{
response = "Proper usage: \"forcerespawn (mtf/chaos)\"";
return(false);
}
if (arguments.At(0).ToLower() != "mtf" && arguments.At(0).ToLower() != "chaos")
{
response = "Provided argument must be \"mtf\" or \"chaos\".";
return(false);
}
SpawnableTeamType spawningTeam = (arguments.At(0).ToLower() == "mtf" ? SpawnableTeamType.NineTailedFox : SpawnableTeamType.ChaosInsurgency);
float length = (spawningTeam == SpawnableTeamType.NineTailedFox ? 18f : 13f);
RespawnManager.Singleton.RestartSequence(); // Prevent the opposite team from spawning while the forced team's animation is playing.
RespawnEffectsController.ExecuteAllEffects(RespawnEffectsController.EffectType.Selection, spawningTeam);
Timing.CallDelayed(length, () =>
{
RespawnManager.Singleton.ForceSpawnTeam(spawningTeam);
});
response = $"Forcing {spawningTeam} spawn...";
return(true);
}
public override void Process(Npc npc, Player player, Dictionary <string, string> args)
{
switch (args["direction"])
{
case "forward":
npc.Move(Npc.MovementDirection.FORWARD);
break;
case "backward":
npc.Move(Npc.MovementDirection.BACKWARD);
break;
case "right":
npc.Move(Npc.MovementDirection.RIGHT);
break;
case "left":
npc.Move(Npc.MovementDirection.LEFT);
break;
case "jump":
npc.NPCPlayer.ReferenceHub.animationController.Networkspeed = new UnityEngine.Vector2(1, 1);
npc.AttachedCoroutines.Add(Timing.CallDelayed(float.Parse(args["duration"].Replace('.', ',')), () => npc.NPCPlayer.ReferenceHub.animationController.NetworkcurAnim = 0));
break;
default:
npc.Move(Npc.MovementDirection.NONE);
break;
}
npc.MovementCoroutines.Add(Timing.CallDelayed(float.Parse(args["duration"].Replace('.', ',')), () => npc.Move(Npc.MovementDirection.NONE)));
}
internal static void CallEvent(ReferenceHub hub, out API.Features.Player player)
{
try
{
#if DEBUG
API.Features.Log.Debug("Creating new player object");
#endif
player = new API.Features.Player(hub);
#if DEBUG
API.Features.Log.Debug($"Object exists {player is not null}");
API.Features.Log.Debug($"Creating player object for {hub.nicknameSync.Network_displayName}", true);
#endif
API.Features.Player.UnverifiedPlayers.Add(hub, player);
API.Features.Player p = player;
Timing.CallDelayed(0.25f, () =>
{
if (p.IsMuted)
{
p.ReferenceHub.characterClassManager.SetDirtyBit(2UL);
}
});
Handlers.Player.OnJoined(new JoinedEventArgs(player));
}
catch (Exception e)
{
API.Features.Log.Error($"{nameof(CallEvent)}: {e}\n{e.StackTrace}");
player = null;
}
}
internal void OnDied(DiedEventArgs ev)
{
if (IsLobby && (GameCore.RoundStart.singleton.NetworkTimer > 1 || GameCore.RoundStart.singleton.NetworkTimer == -2))
{
Timing.CallDelayed(Config.SpawnDelay, () => ev.Target.Role = Config.RolesToChoose[Random.Range(0, Config.RolesToChoose.Count)]);
Timing.CallDelayed(Config.SpawnDelay * 2.5f, () =>
{
if (!Config.MultipleRooms)
{
ev.Target.Position = choosedSpawnPos;
}
else
{
ev.Target.Position = possibleSpawnPoses[Random.Range(0, possibleSpawnPoses.Count)];
}
if (Config.MovementBoost != 0)
{
ev.Target.EnableEffect <MovementBoost>();
ev.Target.ChangeEffectIntensity <MovementBoost>(50);
}
Timing.CallDelayed(0.3f, () =>
{
ev.Target.ResetInventory(Config.Inventory);
foreach (var ammo in Config.Ammo)
{
ev.Target.Ammo[ammo.Key.GetItemType()] = ammo.Value;
}
});
});
}
}
public static void SpawnPlayer(Player player, bool full = true)
{
player.SessionVariables.Add("IsSH", null);
player.Role.Type = RoleType.Tutorial;
player.Health = config.SerpentsHandModifiers.Health;
player.MaxHealth = (int)config.SerpentsHandModifiers.Health;
player.UnitName = config.SpawnManager.UnitNames[UnityEngine.Random.Range(0, config.SpawnManager.UnitNames.Count)];
player.CustomInfo = config.SerpentsHandModifiers.RoleName;
player.ReferenceHub.nicknameSync.ShownPlayerInfo &= ~PlayerInfoArea.Nickname;
player.ReferenceHub.nicknameSync.ShownPlayerInfo &= ~PlayerInfoArea.UnitName;
player.ReferenceHub.nicknameSync.ShownPlayerInfo &= ~PlayerInfoArea.Role;
player.Broadcast(config.SpawnManager.SpawnBroadcast);
if (full)
{
Timing.CallDelayed(0.4f, () =>
{
player.ResetInventory(config.SerpentsHandModifiers.SpawnItems);
foreach (var ammo in config.SerpentsHandModifiers.SpawnAmmo)
{
player.Ammo[ammo.Key.GetItemType()] = ammo.Value;
}
});
}
Timing.CallDelayed(1.7f, () => player.Position = config.SpawnManager.SpawnPos);
}
public override void Attack()
{
if (!isOnCooldown)
{
GameObject bullet = Utils.Instantiate(prefab, gameObject.transform.position, Quaternion.identity);
Rigidbody2D rb = bullet.AddComponent <Rigidbody2D>();
rb.gravityScale = 0f;
if (PlayerController.singleton.movement.normalized != Vector2.zero)
{
bullet.transform.up = PlayerController.singleton.movement.normalized;
rb.AddForce(PlayerController.singleton.movement.normalized * 2000f);
}
else
{
Vector2 velocity = new Vector2(PlayerController.singleton.render.flipX ? -1 : 1, 0);
bullet.transform.up = velocity;
rb.AddForce(velocity * 2000f);
}
SfxController.singleton.sniperShot.Play();
isOnCooldown = true;
Timing.CallDelayed(shootDelay, () => isOnCooldown = false);
}
}
protected override void OnEnter(ProcedureOwner procedureOwner, object userData)
{
base.OnEnter(procedureOwner, userData);
GameCore.Input.Subscribe(InputEventType.On_SimpleTap, OnSimpleTap);
addLogicHandler(new CraftCameraLogicHandler());
Timing.CallDelayed(0.2f, () =>
{
var data = GameCore.WorldMap.GetLogicHandler <WorldMapSystemLogicHandler>(WorldMapSystemLogicHandler.HandlerID).GetCameraSetting();
GameCore.Event.Fire(this, FocusWorldPosWithLerpValueEventArgs.Create(GameCore.NetData.SelfCastle.Position, data.focusCastleLerpValue));
// 產生 preview hex 的 entity:
selectGridEntity.Release();
selectGridEntity.LoadEntity(new MiscEntityData(GameCore.Entity.GenerateSerialId(), gridHexAssetName)
{
Position = GameCore.NetData.SelfCastle.Position
},
(entity) =>
{
entity.OnZoom(0);
});
});
uiSerialId = GameCore.UI.OpenUIForm(UIFormId.UISelectBuildGrid);
}
internal static void SpawnItemToSpawn(Locker.ItemToSpawn toSpawn, Locker locker, bool locked)
{
for (int i = 0; i <= toSpawn._amount; i++)
{
var item = new Synapse.Api.Items.SynapseItem(toSpawn._id, 0f, 0, 0, 0);
item.Drop(toSpawn._pos);
item.pickup.SetupPickup(item.ItemType, item.Durabillity, item.pickup.ownerPlayer, item.pickup.weaponMods, item.pickup.position, toSpawn._rot);
item.pickup.RefreshDurability(true, true);
item.pickup.Locked = locked;
item.pickup.Chamber = toSpawn.chamberId;
locker.AssignPickup(item.pickup);
var rb = item.pickup.GetComponent <Rigidbody>();
rb.velocity = Vector3.zero;
if (locker.enableSorting && locker.sortingTarget != null)
{
rb.useGravity = false;
var normalized = (item.Position - locker.sortingTarget.transform.position).normalized;
rb.velocity = normalized * locker.sortingForce;
rb.angularVelocity = locker.sortingTorque;
Timing.CallDelayed(0.5f, () => rb.useGravity = true);
return;
}
rb.useGravity = true;
}
}
public void OnWaitingForPlayers()
{
// Fix for Exiled 5.0.0-beta.3
Timing.CallDelayed(0.6f, () =>
{
Room room939 = Room.Get(RoomType.Hcz939);
var firstscp939door = Door.List.GetClosestDoor(room939);
Scp939Doors.Add(firstscp939door);
Scp939Doors.Add(Door.List.GetClosestDoor(room939, firstscp939door, false));
// Scp096 Door
var door096 = Door.Get("096");
Scp096Door = Door.List.GetClosestDoor(door096);
// Scp049 Door
var door049 = Door.Get("049_ARMORY");
Scp049Door = Door.List.GetClosestDoor(door049);
// Scp173 Door
Scp173Door = Door.Get("173_CONNECTOR");
foreach (var affectedoor in plugin.Config.AffectedDoors)
{
affectedoor.Doors.Clear();
foreach (var door in Door.Get(x => x.Type == affectedoor.DoorType))
{
affectedoor.Doors.Add(door);
}
}
Methods.LockAffectedDoors();
});
}
