public static AmmoBox GetFromDS(DataStructure part_data, DataStructure specific_data, Transform parent)
{
GameObject box_obj = Object.Instantiate(part_data.Get <GameObject>("source"));
box_obj.transform.position = parent.position + parent.rotation * specific_data.Get <Vector3>("position");
box_obj.transform.rotation = parent.rotation * specific_data.Get <Quaternion>("rotation");
box_obj.transform.SetParent(parent, true);
if (!Globals.ammunition_insts.ContainsKey(part_data.Get <string>("ammotype")))
{
throw new System.Exception(string.Format("No such ammo: {0}", part_data.Get <string>("ammotype")));
}
AmmoBox box_instance = new AmmoBox((float)part_data.Get <ushort>("hp"), box_obj, part_data.Get <float>("mass"))
{
AmmoType = Globals.ammunition_insts[part_data.Get <string>("ammotype")],
Ammunition = part_data.Get <System.UInt16>("ammo"),
description_ds = part_data,
};
box_instance.HP = specific_data.Get("hp", box_instance.InitHP, quiet: true);
box_instance.main_component = specific_data.Get("main component", true, quiet: true);
box_instance.Ammunition = (uint)specific_data.Get("ammo", (int)box_instance.FullAmmunition, quiet: true);
BulletCollisionDetection box_behaviour = Loader.EnsureComponent <BulletCollisionDetection>(box_obj);
box_behaviour.Part = box_instance;
return(box_instance);
}
void PlayerPhysicalMovement_OnCollidedWithSomething(GameObject e)
{
AmmoBox box = e.GetComponent <AmmoBox>();
FoodCrate foodCrate = e.GetComponent <FoodCrate>();
if (box != null)
{
bool needsToReload = false;
if (Ammo == 0)
{
needsToReload = true;
}
Ammo += box.Ammo;
GameObject.Destroy(box.gameObject);
if (needsToReload)
{
OnReceivedAmmo(this);
}
}
if (foodCrate != null)
{
Food += foodCrate.Food;
GameObject.Destroy(foodCrate.gameObject);
}
}
public void SpawnAmmoBox()
{
AmmoBox ammoBox = _ammoBoxScene.Instance() as AmmoBox;
GetNode("AmmoBoxHolder").AddChild(ammoBox);
ammoBox.Position = new Vector2(GD.Randi() % 2200, 400);
}
public void on_raycast_collision(RaycastHit hit)
{
if (hit.collider.tag == "Weapon" && weapon_slots.can_pickup())
{
weapon_slots.pick_up(hit.collider.gameObject);
weapon_script = weapon_slots.get_script();
}
else if (hit.collider.tag == "Backpack" && backpack_slot.can_pickup())
{
backpack_slot.pick_up(hit.collider.gameObject);
}
else if (hit.collider.tag == "Ammo")
{
AmmoBox ammobox = hit.collider.gameObject.GetComponent <AmmoBox>();
ammobox.on_pickup();
player_inventory.pick_up(ammobox); //w inventory musze wiedzieci ile mam ammo i usuwac puste pudelka (to juz chyba zrobione)
}
else if (hit.collider.tag == "Item")
{
Debug.Log("item hit");
Item item = hit.collider.gameObject.GetComponent <Item>();
item.on_pickup();
player_inventory.pick_up(item);
}
}
public static bool Prefix(AmmoBox __instance)
{
int[] ammoTypes = __instance._ccm.Classes.SafeGet(__instance._ccm.CurClass).ammoTypes;
switch (EventHandlers.eventmode)
{
case SANYA_GAME_MODE.CLASSD_INSURGENCY:
{
if (__instance._ccm.CurClass == RoleType.ClassD && Configs.classd_insurgency_classd_ammo.Count > 0)
{
ammoTypes = Configs.classd_insurgency_classd_ammo.ToArray();
}
break;
}
}
__instance.Networkamount = string.Concat(new object[]
{
ammoTypes[0],
":",
ammoTypes[1],
":",
ammoTypes[2]
});
return(false);
}
void Start()
{
ammoBox = GetComponent <AmmoBox>();
healthBox = GetComponent <HealthBox>();
traitComponent = GetComponent <TraitComponent>();
UpdateParams();
}
private void CheckAmmoBoxCollision()
{
if (AmmoBox == null || !AmmoBox.CollidePlayer(Player))
{
return;
}
Ammo += 5;
AmmoBox = null;
OnCollideBonus(new ModelEventArgs());
}
override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
BotUtility botUtility = animator.GetComponentInParent <BotUtility>();
AmmoBox target = botUtility.FindClosestAmmo();
if (!botUtility.NavigateTo(target))
{
animator.SetTrigger("failed");
}
}
private void MoveAmmoBox()
{
if (AmmoBox == null)
{
return;
}
AmmoBox.Move();
if (AmmoBox.Y >= Height)
{
AmmoBox = null;
}
}
private void SpawnAmmoBox()
{
// Spawn each type of ammo boxes
// Create powerUP object
AmmoBox box = Instantiate(AmmoManager.instance.ammoBoxes[UnityEngine.Random.Range(0, AmmoManager.instance.ammoBoxes.Length)], ammoBoxSpawnPoint.position, Quaternion.identity);
// On pickup summon next
box.OnPickUP += AmmoBoxPhase;
// If player does not pick up in time - spawn new
box.OnDestroy += AmmoBoxPhase;
}
public void PickAmmo(AmmoBox ammo)
{
if (inventoryAmmos.ContainsKey(ammo.ammoType))
{
inventoryAmmos[ammo.ammoType] += ammo.count;
}
else
{
inventoryAmmos.Add(ammo.ammoType, ammo.count);
}
state = AIState.WalkingOnPath;
}
public void AddAmmoFromBox(AmmoBox ammoBox)
{
int addToAmmo = ammoBox.GetAmmo();
if (ammoBox.GetAmmoType() == WeaponAmmo.Pistol)
{
pistolAmmo += addToAmmo;
}
else
{
rifleAmmo += addToAmmo;
}
}
void LateUpdate()
{
if (Owner.IsAlive == false)
{
return;
}
AmmoBox a = Mission.Instance.GameZone.GetNearestDroppedAmmoClip(Owner, 0.1f);
if (a != null)
{
Owner.WeaponComponent.AddAmmoToWeapon(a);
}
}
public void ServerDropAll()
{
foreach (Inventory.SyncItemInfo syncItemInfo in this.items)
{
this.SetPickup(syncItemInfo.id, syncItemInfo.durability, base.transform.position, this.kamera.transform.rotation, base.transform.rotation);
}
AmmoBox component = base.GetComponent <AmmoBox>();
for (int i = 0; i < 3; i++)
{
if (component.GetAmmo(i) != 0)
{
this.SetPickup(component.types[i].inventoryID, (float)component.GetAmmo(i), base.transform.position, this.kamera.transform.rotation, base.transform.rotation);
}
}
this.items.Clear();
component.Networkamount = "0:0:0";
}
private AmmoBox FindClosestAmmo(int ammoType)
{
distanceToAmmo = float.PositiveInfinity;
AmmoBox closestBox = null;
foreach (AmmoBox ammoBox in AmmoBox.ammoBoxes)
{
if (ammoBox.enabled && ammoBox.ammoType == ammoType)
{
if (Vector3.Distance(ammoBox.transform.position, this.transform.position) < distanceToAmmo)
{
distanceToAmmo = Vector3.Distance(ammoBox.transform.position, this.transform.position);
closestBox = ammoBox;
}
}
}
return(closestBox);
}
public override void AddAmmoToWeapon(AmmoBox a)
{
if (Owner.IsServer == false)
{
return;
}
if (Weapons.ContainsKey(a.ForWeaponType) && Weapons[a.ForWeaponType].IsFull == false)
{
Weapons[a.ForWeaponType].AddAmmo(a.Ammo);
a.Disable();
Owner.NetworkView.RPC("ClientSetAmmo",
Owner.NetworkView.owner,
a.ForWeaponType,
Weapons[a.ForWeaponType].ClipAmmo,
Weapons[a.ForWeaponType].WeaponAmmo);
}
}
private static bool Prefix(AmmoBox __instance, int type, uint toDrop)
{
try
{
if (!__instance._iawRateLimit.CanExecute(true))
{
return(false);
}
toDrop = Math.Min(toDrop, __instance.amount[type]);
if (toDrop < 15u)
{
return(false);
}
var player = __instance.GetPlayer();
var item = player.ItemInHand;
SynapseController.Server.Events.Player.InvokePlayerDropAmmoEvent(player, item, ref toDrop, ref type, out var allow);
if (item != null)
{
SynapseController.Server.Events.Player.InvokePlayerItemUseEvent(player, item, Api.Events.SynapseEventArguments.ItemInteractState.Finalizing, ref allow);
}
if (!allow)
{
return(false);
}
__instance.amount[type] -= toDrop;
__instance._inv.SetPickup(__instance.types[type].inventoryID, toDrop, __instance.transform.position, __instance._inv.camera.transform.rotation, 0, 0, 0);
return(false);
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-Event: PlayerAmmoDrop failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
return(false);
}
}
public void TakeAmmo(AmmoBox ammo)
{
int type = (int)ammo.ammoType;
if (currentAmmo[type] >= maxAmmo[type])
{
return;
}
int cap = ammo.ammoCount + currentAmmo[type];
if (cap <= maxAmmo[type])
{
currentAmmo[type] = cap;
Destroy(ammo.gameObject);
}
else
{
currentAmmo[type] = maxAmmo[type];
ammo.ammoCount = cap - maxAmmo[type];
}
playerController.audioSource.PlayOneShot(ammoPickupSound);
onAmmoChange();
}
void Osuma(PhysicsObject ammus, PhysicsObject kohde)
{
bool tuhotaankoAmmus = true;
rynkky.Ammo.Value--;
pisteLaskuri.Value = rynkky.Ammo.Value;
if (kohde.Tag.Equals("vihu"))
{
Random ohi = new Random();
int dodged = ohi.Next(1, 10);
if (dodged > 6)
{
kohde.Tag = "dodged";
}
else
{
kohde.Tag = "osui";
}
int monsterinSijainti = 0;
Monsteri jotain = vihut[monsterinSijainti];
while (monsterinSijainti < vihut.Capacity)
{
if (vihut[monsterinSijainti].Tag.Equals("dodged"))
{
jotain = vihut[monsterinSijainti];
break;
}
if (vihut[monsterinSijainti].Tag.Equals("osui"))
{
jotain = vihut[monsterinSijainti];
break;
}
monsterinSijainti++;
}
if (jotain.Tag.Equals("dodged"))
{
tuhotaankoAmmus = false;
jotain.nopeus += 30;
FollowerBrain VihunAivot = new FollowerBrain(pelaaja1)
{
Speed = jotain.nopeus,
DistanceFar = 900,
DistanceClose = 10
};
jotain.Brain = VihunAivot;
}
if (jotain.Tag.Equals("osui"))
{
jotain.Elamat -= 25;
if (jotain.Elamat <= 0)
{
vihollisteMaara--;
vihut.Remove(vihut[monsterinSijainti]);
jotain.Destroy();
rynkky.Ammo.Value += 10;
pisteLaskuri.Value = rynkky.Ammo.Value;
//vihun taposta ammobox
ammo = new AmmoBox(30, 30);
ammo.Tag = "Ammo";
ammo.Image = ammoBox;
AddCollisionHandler(pelaaja1, ammo, Keraa);
if (ammo.ammoBoxiKentalla == false)
{
ammo.ammoBoxiKentalla = true;
ammo.Position = jotain.Position;
Add(ammo);
}
}
}
jotain.Tag = "vihu";
}
//pisteLaskuri.Value--;
if (tuhotaankoAmmus)
{
ammus.Destroy();
}
if (vihollisteMaara == 0)
{
Kierros();
}
}
public static void Reload(this IAmmoBoxReloadable firearm, AmmoBox ammo)
{
}
void OpenAmmoBox(AmmoBox ammoBox)
{
ammoBox.OpenBox();
playerInventory.AddAmmoFromBox(ammoBox);
CollisionInteraction?.Invoke(null);
}
public void Initialize(int pregiven_id = -1)
{
//Read the data
DataStructure data = data_ == null ? data_ = DataStructure.Load(config_path, "data", null) : data_;
// Variables used to place weapons
Dictionary <string, Turret[]> weapon_arrays = new Dictionary <string, Turret[]> ();
//First set up some basic things
Ship own_ship = new Ship(gameObject, friendly, data.Get <string>("name"), pregiven_id);
ShipControl ship_control = Loader.EnsureComponent <ShipControl> (gameObject);
RCSFiring rcs_comp = Loader.EnsureComponent <RCSFiring> (gameObject);
own_ship.control_script = ship_control;
own_ship.rcs_script = rcs_comp;
own_ship.config_path = config_path;
own_ship.TurretAim = own_ship.Target = Target.None;
ship_control.myship = own_ship;
// AI
LowLevelAI ai = Loader.EnsureComponent <LowLevelAI>(gameObject);
ai.Start_();
ai.HasHigherAI = !player;
HighLevelAI high_ai = own_ship.high_ai;
//high_ai.Load(child.GetChild("ai data"));
high_ai.low_ai = ai;
// Instantiates normal UI marker
TgtMarker.Instantiate(own_ship, 1);
foreach (KeyValuePair <string, DataStructure> child_pair in data_.children)
{
// Do this for each "command" in the datafile
DataStructure child = child_pair.Value;
string comp_name = child.Name;
DataStructure part_data;
if (child.Contains <string>("part"))
{
string part_name = child.Get <string>("part");
part_data = Globals.parts.Get <DataStructure>(part_name);
}
else
{
part_data = child;
}
switch (comp_name)
{
case "rcs":
ship_control.RCS_ISP = child.Get <float>("isp");
rcs_comp.rcs_mesh = child.Get <GameObject>("mesh");
rcs_comp.strength = child.Get <float>("thrust");
rcs_comp.angular_limitation = child.Get <float>("angular limitation", 1);
rcs_comp.positions = child.Get <Vector3[]>("positions");
rcs_comp.directions = child.Get <Quaternion[]>("orientations");
break;
case "ship":
if (rcs_comp != null)
{
rcs_comp.center_of_mass = child.Get <Vector3>("centerofmass");
}
own_ship.offset = child.Get <Vector3>("centerofmass");
break;
case "AI":
high_ai.Load(child.GetChild("ai data"));
break;
case "engine":
if (!include_parts)
{
break;
}
Engine.GetFromDS(part_data, child, transform);
break;
case "tank":
if (!include_parts)
{
break;
}
FuelTank.GetFromDS(part_data, child, transform);
break;
case "fix weapon":
if (!include_parts)
{
break;
}
Weapon.GetFromDS(part_data, child, transform);
break;
case "ammobox":
if (!include_parts)
{
break;
}
AmmoBox.GetFromDS(part_data, child, transform);
break;
case "missiles":
if (!include_parts)
{
break;
}
MissileLauncher.GetFromDS(part_data, child, transform);
break;
case "armor":
if (!include_parts)
{
break;
}
Armor.GetFromDS(child, own_ship);
break;
default:
if (comp_name.StartsWith("turr-"))
{
if (!include_parts)
{
break;
}
var tg = TurretGroup.Load(child, own_ship);
weapon_arrays [comp_name.Substring(5)] = tg.TurretArray;
ship_control.turretgroup_list.Add(new TurretGroup(Target.None, tg.TurretArray, tg.name)
{
own_ship = own_ship
});
}
break;
}
}
// Initializes parts
foreach (BulletCollisionDetection part in GetComponentsInChildren <BulletCollisionDetection>())
{
part.Initialize();
}
ship_control.turrets = weapon_arrays;
}
private static bool Prefix(CharacterClassManager __instance, bool lite = false, bool escape = false)
{
Role role = __instance.Classes.SafeGet(__instance.CurClass);
if (!__instance._wasAnytimeAlive && __instance.CurClass != RoleType.Spectator && __instance.CurClass != RoleType.None)
{
__instance._wasAnytimeAlive = true;
}
__instance.InitSCPs();
__instance.AliveTime = 0f;
switch (role.team)
{
case Team.MTF:
AchievementManager.Achieve("arescue");
break;
case Team.CHI:
AchievementManager.Achieve("chaos");
break;
case Team.RSC:
case Team.CDP:
__instance.EscapeStartTime = (int)Time.realtimeSinceStartup;
break;
}
__instance.GetComponent <Inventory>();
try
{
__instance.GetComponent <FootstepSync>().SetLoudness(role.team, role.roleId.Is939());
}
catch
{
}
if (NetworkServer.active)
{
Handcuffs component = __instance.GetComponent <Handcuffs>();
component.ClearTarget();
component.NetworkCufferId = -1;
}
if (role.team != Team.RIP)
{
if (NetworkServer.active && !lite)
{
Vector3 constantRespawnPoint = NonFacilityCompatibility.currentSceneSettings.constantRespawnPoint;
if (constantRespawnPoint != Vector3.zero)
{
__instance._pms.OnPlayerClassChange(constantRespawnPoint, 0f);
}
else
{
GameObject randomPosition = CharacterClassManager._spawnpointManager.GetRandomPosition(__instance.CurClass);
Vector3 spawnPoint;
float rotY;
if (randomPosition != null)
{
spawnPoint = randomPosition.transform.position;
rotY = randomPosition.transform.rotation.eulerAngles.y;
AmmoBox component1 = __instance.GetComponent <AmmoBox>();
if (escape && __instance.KeepItemsAfterEscaping)
{
Inventory component2 = PlayerManager.localPlayer.GetComponent <Inventory>();
for (ushort index = 0; index < 3; ++index)
{
if (component1[index] >= 15U)
{
component2.SetPickup(component1.types[index].inventoryID, component1[index], randomPosition.transform.position, randomPosition.transform.rotation, 0, 0, 0);
}
}
}
component1.ResetAmmo();
}
else
{
spawnPoint = __instance.DeathPosition;
rotY = 0f;
}
var ev = new SpawningEventArgs(API.Features.Player.Get(__instance.gameObject), __instance.CurClass, spawnPoint, rotY);
Player.OnSpawning(ev);
__instance._pms.OnPlayerClassChange(ev.Position, ev.RotationY);
}
if (!__instance.SpawnProtected && __instance.EnableSP && __instance.SProtectedTeam.Contains((int)role.team))
{
__instance.GodMode = true;
__instance.SpawnProtected = true;
__instance.ProtectedTime = Time.time;
}
}
if (!__instance.isLocalPlayer)
{
__instance.GetComponent <PlayerStats>().maxHP = role.maxHP;
}
}
__instance.Scp0492.iAm049_2 = __instance.CurClass == RoleType.Scp0492;
__instance.Scp106.iAm106 = __instance.CurClass == RoleType.Scp106;
__instance.Scp173.iAm173 = __instance.CurClass == RoleType.Scp173;
__instance.Scp939.iAm939 = __instance.CurClass.Is939();
__instance.RefreshPlyModel();
return(false);
}
void Awake()
{
ammoBox = GetComponent <AmmoBox>();
healthBox = GetComponent <HealthBox>();
traitComponent = GetComponent <Collectible>();
}
public override void Update(float deltaTime)
{
base.Update(deltaTime);
parallax.Update(deltaTime);
deltaTimes = deltaTime;
time += deltaTime;
// Make it shoot the bullets from the ai at the player
if (time >= 1.5)
{
if (tank2.tankObject != null && tank2.ammo > 0)
{
Bullet bullet = new Bullet();
bullet.SetUpAI(tank2, tank);
bullets2.AddObject(bullet);
tank2.ammo -= 1;
}
time = 0;
}
// End Of Test
if (tank2.tankObject != null)
{
bullets2.Update(deltaTime);
tank2.MoveAI(deltaTime, tank, ammoBox);
bullets2.Update(deltaTime);
bullets2.Des(ref tank);
if (ammoBox.IsOnAmmo(tank2.collider))
{
tank2.ammo += ammoBox.ammo;
ammoBox = new AmmoBox(1, 30);
ammoBox.Inits();
}
}
else
{
if (!explodedTank2 && !tankAni.isActive)
{
// Loads win level
if (aniTime >= 1)
{
ChangeLevel("02");
}
else
{
aniTime += deltaTime;
}
}
if (tankAni.isActive)
{
explodedTank2 = true;
}
}
if (tank.tankObject != null)
{
tank.Move(deltaTime);
bullets.Des(ref tank2);
bullets.Update(deltaTime);
if (ammoBox.IsOnAmmo(tank.collider))
{
tank.ammo += ammoBox.ammo;
ammoBox = new AmmoBox(1, 30);
ammoBox.Inits();
}
}
else
{
if (!explodedTank && !tankAni.isActive)
{
// Loads win level
if (aniTime >= 1)
{
ChangeLevel("lose");
}
else
{
aniTime += deltaTime;
}
}
if (tankAni.isActive)
{
explodedTank = true;
}
}
if (IsMouseButtonPressed(MouseButton.MOUSE_LEFT_BUTTON) && !tank.stopTank)
{
if (tank.tankObject != null && tank.ammo > 0)
{
Bullet bullet = new Bullet();
bullet.SetUp(tank);
bullets.AddObject(bullet);
tank.ammo -= 1;
}
}
}
public static void Reload(this IBoxAmmo firearm, AmmoBox ammo)
{
}
public virtual void AddAmmoToWeapon(AmmoBox a)
{
//do nothing, only on server
}
public void TriggerScript()
{
Ray posit = cam.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(posit, out hit, 5f))
{
// get object that player is currenlty aiming at
if (hit.collider.GetComponent <Rigidbody>() != null)
{
// and apply its script
Rigidbody col = hit.collider.GetComponent <Rigidbody>();
if (col.GetComponent <PickUp>() != null && !pickedUpItem)
{
puItem = col.GetComponent <PickUp>();
puItem.PickUpItem();
pickedUpItem = true;
}
else if (col.GetComponent <AmmoBox>() != null && reloadReady)
{
AmmoBox oc = col.GetComponent <AmmoBox>();
oc.Reload();
reloadReady = false;
}
else if (col.GetComponent <Bell>() != null && !rangBell)
{
Bell bell = col.GetComponent <Bell>();
bell.RingBell();
rangBell = true;
}
else if (col.GetComponent <BridgeCranck>() != null && !bridgeUp)
{
BridgeCranck bc = col.GetComponent <BridgeCranck>();
bc.CranckIt();
bridgeUp = true;
}
else if (col.GetComponent <BazookaMechanics>() != null)
//else if (hand.transform.childCount == 0 && col.GetComponent<BazookaMechanics>() != null)
{
BazookaMechanics bm = col.GetComponent <BazookaMechanics>();
DynamiteMechanics dm = player.GetComponent <DynamiteMechanics>();
dm.DisableRestrictions();
player.GetComponent <DynamiteMechanics>().enabled = false;
bm.PickUp();
}
else if (col.name.Contains("Dynamite"))
{
if (hand.transform.childCount > 0)
{
hand.transform.DetachChildren();
}
//restrict gravity and position object into players hands
col.transform.GetComponent <CapsuleCollider>().enabled = false;
col.transform.SetParent(GameObject.Find("RightHand").transform);
col.GetComponent <Rigidbody>().constraints = RigidbodyConstraints.FreezeAll;
col.transform.GetComponent <Rigidbody>().useGravity = false;
col.transform.position = hand.transform.position;
col.transform.localEulerAngles = new Vector3(-90, 0, 0);
player.GetComponent <DynamiteMechanics>().enabled = true;
Destroy(GameObject.Find("DynamiteObject"));
}
else if (col.GetComponent <GrenadeLauncher>() != null)
{
GrenadeLauncher gl = col.GetComponent <GrenadeLauncher>();
DynamiteMechanics dm = player.GetComponent <DynamiteMechanics>();
dm.DisableRestrictions();
player.GetComponent <DynamiteMechanics>().enabled = false;
gl.PickUp();
}
}
}
}
private void BlastCorpsViewer_MouseUp(object sender, MouseEventArgs e)
{
if (level != null && e.Button == System.Windows.Forms.MouseButtons.Left)
{
switch (Mode)
{
case MouseMode.Move:
if (dragItem != null)
{
selectedItem = dragItem;
OnSelectionChangedEvent(new SelectionChangedEventArgs(selectedItem, false, false));
dragItem = null;
Invalidate();
}
break;
case MouseMode.Add:
Int16 x = (Int16)levelX(e.X);
Int16 z = (Int16)levelZ(e.Y);
if (AddType == typeof(AmmoBox))
{
AmmoBox box = new AmmoBox(x, level.carrier.y, z, 0);
selectedItem = box;
level.ammoBoxes.Add(box);
}
else if (AddType == typeof(CommPoint))
{
CommPoint comm = new CommPoint(x, level.carrier.y, z, 0);
selectedItem = comm;
level.commPoints.Add(comm);
}
else if (AddType == typeof(RDU))
{
RDU rdu = new RDU(x, level.carrier.y, z);
selectedItem = rdu;
level.rdus.Add(rdu);
}
else if (AddType == typeof(TNTCrate))
{
TNTCrate tnt = new TNTCrate(x, level.carrier.y, z, 0, 0, 0, 0);
selectedItem = tnt;
level.tntCrates.Add(tnt);
}
else if (AddType == typeof(SquareBlock))
{
SquareBlock block = new SquareBlock(x, level.carrier.y, z, SquareBlock.Type.Block, SquareBlock.Shape.Square);
selectedItem = block;
level.squareBlocks.Add(block);
}
else if (AddType == typeof(Vehicle))
{
Vehicle vehicle = new Vehicle(0, x, level.carrier.y, z, 0);
selectedItem = vehicle;
level.vehicles.Add(vehicle);
}
else if (AddType == typeof(Building))
{
Building building = new Building(x, level.carrier.y, z, 0, 0, 0, 0, 0);
selectedItem = building;
level.buildings.Add(building);
}
OnSelectionChangedEvent(new SelectionChangedEventArgs(selectedItem, true, false));
Invalidate();
break;
}
}
}
public static bool Prefix(CharacterClassManager __instance, bool lite = false, bool escape = false)
{
if (EventPlugin.PlayerSpawnEventPatchDisable)
{
return(true);
}
try
{
Role role = __instance.Classes.SafeGet(__instance.CurClass);
if (!__instance._wasAnytimeAlive && __instance.CurClass != RoleType.Spectator && __instance.CurClass != RoleType.None)
{
__instance._wasAnytimeAlive = true;
}
__instance.InitSCPs();
__instance.AliveTime = 0f;
switch (role.team)
{
case Team.MTF:
AchievementManager.Achieve("arescue");
break;
case Team.CHI:
AchievementManager.Achieve("chaos");
break;
case Team.RSC:
case Team.CDP:
__instance.EscapeStartTime = (int)Time.realtimeSinceStartup;
break;
}
__instance.GetComponent <Inventory>();
try
{
__instance.GetComponent <FootstepSync>().SetLoudness(role.team, role.roleId.Is939());
}
catch
{
}
if (NetworkServer.active)
{
Handcuffs component = __instance.GetComponent <Handcuffs>();
component.ClearTarget();
component.NetworkCufferId = -1;
}
if (role.team != Team.RIP)
{
if (NetworkServer.active && !lite)
{
Vector3 constantRespawnPoint = NonFacilityCompatibility.currentSceneSettings.constantRespawnPoint;
if (constantRespawnPoint != Vector3.zero)
{
__instance._pms.OnPlayerClassChange(constantRespawnPoint, 0f);
}
else
{
GameObject randomPosition = CharacterClassManager.SpawnpointManager.GetRandomPosition(__instance.CurClass);
Vector3 spawnPoint = new Vector3(0f, 0f, 0f);
float rotY = 0f;
if (randomPosition != null)
{
spawnPoint = randomPosition.transform.position;
rotY = randomPosition.transform.rotation.eulerAngles.y;
AmmoBox component2 = __instance.GetComponent <AmmoBox>();
if (escape && __instance.KeepItemsAfterEscaping)
{
Inventory component3 = PlayerManager.localPlayer.GetComponent <Inventory>();
for (ushort num = 0; num < 3; num += 1)
{
if (component2.GetAmmo(num) >= 15)
{
component3.SetPickup(component2.types[num].inventoryID, component2.GetAmmo(num), randomPosition.transform.position, randomPosition.transform.rotation, 0, 0, 0);
}
}
}
component2.SetAmmoAmount();
}
else
{
spawnPoint = __instance.DeathPosition;
rotY = 0f;
}
Events.InvokePlayerSpawn(__instance, __instance.CurClass, ref spawnPoint, ref rotY);
__instance._pms.OnPlayerClassChange(spawnPoint, rotY);
}
if (!__instance.SpawnProtected && __instance.EnableSP && __instance.SProtectedTeam.Contains((int)role.team))
{
__instance.GodMode = true;
__instance.SpawnProtected = true;
__instance.ProtectedTime = Time.time;
}
}
if (!__instance.isLocalPlayer)
{
__instance.GetComponent <PlayerStats>().maxHP = role.maxHP;
}
}
__instance.Scp049.iAm049 = (__instance.CurClass == RoleType.Scp049);
__instance.Scp0492.iAm049_2 = (__instance.CurClass == RoleType.Scp0492);
__instance.Scp096.iAm096 = (__instance.CurClass == RoleType.Scp096);
__instance.Scp106.iAm106 = (__instance.CurClass == RoleType.Scp106);
__instance.Scp173.iAm173 = (__instance.CurClass == RoleType.Scp173);
__instance.Scp939.iAm939 = __instance.CurClass.Is939();
__instance.RefreshPlyModel();
return(false);
}
catch (Exception exception)
{
Log.Error($"PlayerSpawnEvent error: {exception}");
return(true);
}
}
