private void ClientRemote_VehicleExploded(Vector2D position)
{
Logger.Important(this + " exploded at " + position);
ExplosionHelper.ClientExplode(position: position + this.SharedGetObjectCenterWorldOffset(null),
this.DestroyedExplosionPreset,
this.DestroyedExplosionVolume);
}
public void Triggered()
{
switch (payloadType)
{
case "Bomb Payload":
ExplosionHelper.Explode(transform.position, values["Power"], bigExplosionPrefab, 1, values["Falloff"]);
break;
case "Vacuum Bomb Payload":
ExplosionHelper.Explode(transform.position, values["Power"], smallExplosionPrefab, -1, values["Falloff"]);
break;
case "Shrapnel Payload":
GameObject.Instantiate(tinyExplosionPrefab, transform.position, Quaternion.identity);
Time.fixedDeltaTime = .02f;
GameObject temp;
for (int i = 0; i < values["Shrapnel Count"]; i++)
{
GameController.activeObjects++;
temp = GameObject.Instantiate(shrapnelPrefab, transform.position, Quaternion.identity);
temp.GetComponent <Rigidbody>().mass = values["Power"];
}
break;
}
GameController.activeObjects--;
Destroy(gameObject);
}
public void React(IEntity solutionEntity, double intensity)
{
float floatIntensity = (float)intensity;
if (solutionEntity == null)
{
return;
}
if (!solutionEntity.TryGetComponent(out SolutionComponent solution))
{
return;
}
//Handle scaling
if (_scaled)
{
floatIntensity = MathF.Min(floatIntensity, _maxScale);
}
else
{
floatIntensity = 1;
}
//Calculate intensities
int finalDevastationRange = (int)MathF.Round(_devastationRange * floatIntensity);
int finalHeavyImpactRange = (int)MathF.Round(_heavyImpactRange * floatIntensity);
int finalLightImpactRange = (int)MathF.Round(_lightImpactRange * floatIntensity);
int finalFlashRange = (int)MathF.Round(_flashRange * floatIntensity);
ExplosionHelper.SpawnExplosion(solutionEntity.Transform.Coordinates, finalDevastationRange,
finalHeavyImpactRange, finalLightImpactRange, finalFlashRange);
}
protected override void ClientOnObjectDestroyed(Vector2D position)
{
//base.ClientOnObjectDestroyed(tilePosition);
Logger.Important(this + " exploded at " + position);
ExplosionHelper.ClientExplode(position: position + this.Layout.Center,
this.ExplosionPreset,
this.VolumeExplosion);
}
public static ExplosionHelper.Surface[] OverlapExplosionSorted(Vector3 point, float explosionRadius, int findLayerMask = -1, int occludingLayerMask = -1, IDMain ignore = null)
{
ExplosionHelper.Surface[] surfaceArray = ExplosionHelper.OverlapExplosion(point, explosionRadius, findLayerMask, occludingLayerMask, ignore);
if ((int)surfaceArray.Length > 1)
{
Array.Sort <ExplosionHelper.Surface>(surfaceArray);
}
return(surfaceArray);
}
protected override void ClientOnObjectDestroyed(Vector2Ushort tilePosition)
{
//base.ClientOnObjectDestroyed(tilePosition);
Logger.Important(this + " exploded at " + tilePosition);
var epicenterPosition = tilePosition.ToVector2D() + this.Layout.Center;
ExplosionHelper.ClientExplode(epicenterPosition,
this.ExplosionPreset,
this.VolumeExplosion);
}
protected override void HandleDeath()
{
enemyUnits.Remove(gameObject);
gameObject.layer = LayerMask.NameToLayer("Active Object");
ExplosionHelper.Explode(transform.position, 2, explosionPrefab, 1, 2);
StopAllCoroutines();
enemyActive = false;
Destroy(resourceBar);
Destroy(gameObject);
}
protected override void HandleDeath()
{
playerUnits.Remove(gameObject);
gameObject.layer = LayerMask.NameToLayer("Active Object");
ExplosionHelper.Explode(transform.position, 2, explosionPrefab, 1, 2);
if (GameController.selectedUnit == gameObject)
{
GameController.selectedUnit = null;
}
Destroy(resourceBar);
Destroy(gameObject);
}
// Use this for initialization
void Start()
{
ExplosionHelper.Add(this);
numberOfHumans++;
humanId = humanInstanceCount++;
DataCollector.Add("Total # of people", 1f);
GenericHumanSounds.HumanCountChange();
initHumanProfile();
StartCoroutine(reportStats());
}
private void ServerExplode(IStaticWorldObject worldObject, ICharacter character)
{
try
{
Logger.Important(worldObject + " exploded");
this.ServerSendObjectDestroyedEvent(worldObject);
ExplosionHelper.ServerExplode(
character: character,
protoExplosive: this,
protoWeapon: null,
explosionPreset: this.ExplosionPreset,
epicenterPosition: worldObject.TilePosition.ToVector2D() + this.Layout.Center,
damageDescriptionCharacters: this.damageDescriptionCharacters,
physicsSpace: worldObject.PhysicsBody.PhysicsSpace,
executeExplosionCallback: this.ServerExecuteExplosion);
if (this.IsActivatesRaidModeForLandClaim)
{
var explosionRadius = (int)Math.Ceiling(this.DamageRadius);
var bounds = new RectangleInt(x: worldObject.TilePosition.X - explosionRadius,
y: worldObject.TilePosition.Y - explosionRadius,
width: 2 * explosionRadius,
height: 2 * explosionRadius);
if (RaidingProtectionSystem.SharedCanRaid(bounds,
showClientNotification: false))
{
// try activate the raidblock
LandClaimSystem.ServerOnRaid(bounds, character);
}
else
{
// Raiding is not possible now due to raiding window
// Find if there is any land claim and in that case notify nearby players
// that the damage to objects there were not applied.
if (LandClaimSystem.SharedIsLandClaimedByAnyone(bounds))
{
using var tempPlayers = Api.Shared.GetTempList <ICharacter>();
Server.World.GetScopedByPlayers(worldObject, tempPlayers);
RaidingProtectionSystem.ServerNotifyShowNotificationRaidingNotAvailableNow(
tempPlayers.AsList());
}
}
}
}
finally
{
Server.World.DestroyObject(worldObject);
}
}
void Start()
{
ExplosionHelper.Add(this);
if (!slave)
{
PubSub.subscribe("gameIsReady", this);
delayTime = Misc.randomRange(0.3f, 0.8f);
foreach (BuildingRoof slaveRoof in slaves)
{
slaveRoof.delayTime = delayTime;
}
}
}
public bool Explosion()
{
//Prevent adjacent explosives from infinitely blowing each other up.
if (_beingExploded)
{
return(true);
}
_beingExploded = true;
ExplosionHelper.SpawnExplosion(Owner.Transform.GridPosition, DevastationRange, HeavyImpactRange, LightImpactRange, FlashRange);
Owner.Delete();
return(true);
}
private void ClientExplodeAt(
IProtoItemWeapon protoWeapon,
Vector2D shotSourcePosition,
Vector2D explosionWorldPosition)
{
var timeToHit = WeaponSystemClientDisplay.SharedCalculateTimeToHit(protoWeapon.FireTracePreset
?? this.FireTracePreset,
shotSourcePosition,
explosionWorldPosition);
ClientTimersSystem.AddAction(timeToHit,
() => ExplosionHelper.ClientExplode(explosionWorldPosition,
this.ExplosionPreset,
this.ExplosionVolume));
}
public static ExplosionHelper.Surface[] OverlapExplosionUnique(Vector3 point, float explosionRadius, int findLayerMask = -1, int occludingLayerMask = -1, IDMain ignore = null)
{
ExplosionHelper.Surface[] surfaceArray = ExplosionHelper.OverlapExplosion(point, explosionRadius, findLayerMask, occludingLayerMask, ignore);
int length = (int)surfaceArray.Length;
if (length > 1)
{
Array.Sort <ExplosionHelper.Surface>(surfaceArray);
if (ExplosionHelper.Unique.Filter(surfaceArray, ref length))
{
Array.Resize <ExplosionHelper.Surface>(ref surfaceArray, length);
}
}
return(surfaceArray);
}
public void Update(float frameTime)
{
_chasing ??= RandomNearbyPlayer();
if (_chasing == null)
{
Owner.Delete();
return;
}
_turningDelay -= frameTime;
if (_turningDelay > 0)
{
var difference = _chasing.Transform.WorldPosition - Owner.Transform.WorldPosition;
var angle = difference.ToAngle();
var adjusted = angle.Degrees + 90;
var newAngle = Angle.FromDegrees(adjusted);
Owner.Transform.LocalRotation = newAngle;
UpdateAppearance();
return;
}
_chasingDelay -= frameTime;
Owner.Transform.WorldRotation += Angle.FromDegrees(20);
UpdateAppearance();
var toChased = _chasing.Transform.WorldPosition - Owner.Transform.WorldPosition;
Owner.Transform.WorldPosition += toChased * frameTime * _chasingSpeed;
_chasingTime -= frameTime;
if (_chasingTime > 0)
{
return;
}
ExplosionHelper.SpawnExplosion(Owner.Transform.Coordinates, 0, 2, 1, 1);
EntitySystem.Get <AudioSystem>().PlayFromEntity("/Audio/Effects/explosion.ogg", Owner);
Owner.Delete();
}
private void ServerExplode(IStaticWorldObject worldObject, ICharacter character)
{
Logger.Important(worldObject + " exploded");
this.ServerSendObjectDestroyedEvent(worldObject);
ExplosionHelper.ServerExplode(
character: character,
protoObjectExplosive: this,
explosionPreset: this.ExplosionPreset,
epicenterPosition: worldObject.TilePosition.ToVector2D() + this.Layout.Center,
damageDescriptionCharacters: this.damageDescriptionCharacters,
physicsSpace: worldObject.PhysicsBody.PhysicsSpace,
executeExplosionCallback: this.ServerExecuteExplosion);
Server.World.DestroyObject(worldObject);
LandClaimSystem.ServerOnRaid(worldObject.TilePosition, this.DamageRadius, character);
}
public void Execute(IConsoleShell shell, IPlayerSession?player, string[] args)
{
if (player?.AttachedEntity == null)
{
shell.SendText(player, "You must have an attached entity.");
return;
}
var x = float.Parse(args[0]);
var y = float.Parse(args[1]);
var dev = int.Parse(args[2]);
var hvy = int.Parse(args[3]);
var lgh = int.Parse(args[4]);
var fla = int.Parse(args[5]);
var mapTransform = player.AttachedEntity.Transform.GetMapTransform();
var coords = new EntityCoordinates(mapTransform.Owner.Uid, x, y);
ExplosionHelper.SpawnExplosion(coords, dev, hvy, lgh, fla);
}
protected override void ClientOnObjectDestroyed(Vector2D position)
{
//base.ClientOnObjectDestroyed(position);
Logger.Important(this + " exploded at " + position);
var explosionPresetNode = ExplosionPresets.PragmiumResonanceBomb_NodeClientOnly;
var positionEpicenter = position + this.Layout.Center;
ProcessExplosionDirection(-1, 0); // left
ProcessExplosionDirection(0, 1); // top
ProcessExplosionDirection(1, 0); // right
ProcessExplosionDirection(0, -1); // bottom
ExplosionHelper.ClientExplode(position: position + this.Layout.Center,
this.ExplosionPreset,
this.VolumeExplosion);
void ProcessExplosionDirection(int xOffset, int yOffset)
{
foreach (var(_, offsetIndex) in
WeaponExplosionSystem.SharedEnumerateExplosionBombermanDirectionTilesWithTargets(
positionEpicenter: positionEpicenter,
damageDistanceFullDamage: DamageRadiusFullDamage,
damageDistanceMax: DamageRadiusMax,
Api.Client.World,
xOffset,
yOffset))
{
ClientTimersSystem.AddAction(
delaySeconds: 0.1 * offsetIndex, // please note the offsetIndex is starting with 1
() => ExplosionHelper.ClientExplode(
position: positionEpicenter + (offsetIndex * xOffset, offsetIndex * yOffset),
explosionPresetNode,
volume: 0));
}
}
}
protected override void ServerOnDynamicObjectZeroStructurePoints(
WeaponFinalCache weaponCache,
ICharacter byCharacter,
IWorldObject targetObject)
{
var vehicle = (IDynamicWorldObject)targetObject;
// explode
using var scopedBy = Api.Shared.GetTempList <ICharacter>();
Server.World.GetCharactersInRadius(vehicle.TilePosition,
scopedBy,
radius: this.DestroyedExplosionRadius,
onlyPlayers: true);
this.CallClient(scopedBy.AsList(),
_ => _.ClientRemote_VehicleExploded(vehicle.Position));
ExplosionHelper.ServerExplode(
character:
null, // yes, no damaging character here otherwise it will not receive the damage if staying close
protoExplosive: null,
protoWeapon: null,
explosionPreset: this.DestroyedExplosionPreset,
epicenterPosition: vehicle.Position
+ this.SharedGetObjectCenterWorldOffset(targetObject),
damageDescriptionCharacters: this.DestroyedVehicleDamageDescriptionCharacters,
physicsSpace: targetObject.PhysicsBody.PhysicsSpace,
executeExplosionCallback: this.ServerExecuteVehicleExplosion);
// destroy the vehicle completely after short explosion delay
ServerTimersSystem.AddAction(
this.DestroyedExplosionPreset.ServerDamageApplyDelay,
() => base.ServerOnDynamicObjectZeroStructurePoints(weaponCache,
byCharacter,
targetObject));
}
public void ExplodeCores()
{
if (_cores.Count < 1 || MasterController == null)
{
return;
}
var intensity = 0;
/*
* todo: add an exact to the shielding and make this find the core closest to the controller
* so they chain explode, after helpers have been added to make it not cancer
*/
var epicenter = _cores.First();
foreach (AMEShieldComponent core in _cores)
{
intensity += MasterController.InjectionAmount;
}
intensity = Math.Min(intensity, 8);
ExplosionHelper.SpawnExplosion(epicenter.Owner.Transform.GridPosition, intensity / 2, intensity, intensity * 2, intensity * 3);
}
void OnDestroy()
{
ExplosionHelper.Remove(this);
PubSub.unsubscribeAllForSubscriber(this);
}
void Start()
{
ExplosionHelper.Add(this);
}
private void ServerExplodeAt(WeaponFinalCache weaponCache, Vector2D endPosition, bool isHit)
{
var character = weaponCache.Character;
var protoWeapon = (IProtoItemWeaponRanged)weaponCache.ProtoWeapon;
var shotSourcePosition = WeaponSystemClientDisplay.SharedCalculateWeaponShotWorldPositon(
character,
protoWeapon,
character.ProtoCharacter,
character.Position,
hasTrace: true);
if (isHit)
{
// offset end position a bit towards the source position
// this way the explosion will definitely happen outside the hit object
endPosition -= 0.1 * (endPosition - shotSourcePosition).Normalized;
}
var timeToHit = WeaponSystemClientDisplay.SharedCalculateTimeToHit(
protoWeapon.FireTracePreset
?? this.FireTracePreset,
shotSourcePosition,
endPosition);
// We're using a check here similar to the one in WeaponSystem.
// Ensure that player can hit objects only on the same height level
// and can fire through over the pits (the cliffs of the lower heights).
var anyCliffIsAnObstacle = character.Tile.Height
!= Server.World.GetTile(endPosition.ToVector2Ushort()).Height;
if (!WeaponSystem.SharedHasTileObstacle(
character.Position,
character.Tile.Height,
endPosition,
character.PhysicsBody.PhysicsSpace,
anyCliffIsAnObstacle: anyCliffIsAnObstacle))
{
ServerTimersSystem.AddAction(
timeToHit,
() =>
{
ExplosionHelper.ServerExplode(
character: character,
protoExplosive: this,
protoWeapon: protoWeapon,
explosionPreset: this.ExplosionPreset,
epicenterPosition: endPosition,
damageDescriptionCharacters: this.DamageDescription,
physicsSpace: Server.World.GetPhysicsSpace(),
executeExplosionCallback: this.ServerExecuteExplosion);
});
}
// notify other characters about the explosion
using var charactersObserving = Api.Shared.GetTempList <ICharacter>();
var explosionEventRadius = Math.Max(protoWeapon.SoundPresetWeaponDistance.max,
this.FireRangeMax)
+ this.DamageRadius;
Server.World.GetCharactersInRadius(endPosition.ToVector2Ushort(),
charactersObserving,
radius: (byte)Math.Min(byte.MaxValue, explosionEventRadius),
onlyPlayers: true);
charactersObserving.Remove(character);
this.CallClient(charactersObserving.AsList(),
_ => _.ClientRemote_OnExplosion(protoWeapon,
shotSourcePosition,
endPosition));
}
void OnDestroy()
{
ExplosionHelper.Remove(this);
}
private void AddDebugVerbs(GetOtherVerbsEvent args)
{
if (!args.User.TryGetComponent <ActorComponent>(out var actor))
{
return;
}
var player = actor.PlayerSession;
// Delete verb
if (_groupController.CanCommand(player, "deleteentity"))
{
Verb verb = new();
verb.Text = Loc.GetString("delete-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/delete.svg.192dpi.png";
verb.Act = () => args.Target.Delete();
args.Verbs.Add(verb);
}
// Rejuvenate verb
if (_groupController.CanCommand(player, "rejuvenate"))
{
Verb verb = new();
verb.Text = Loc.GetString("rejuvenate-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/rejuvenate.svg.192dpi.png";
verb.Act = () => RejuvenateCommand.PerformRejuvenate(args.Target);
args.Verbs.Add(verb);
}
// Control mob verb
if (_groupController.CanCommand(player, "controlmob") &&
args.User != args.Target &&
args.User.HasComponent <MindComponent>() &&
args.Target.TryGetComponent <MindComponent>(out var targetMind))
{
Verb verb = new();
verb.Text = Loc.GetString("control-mob-verb-get-data-text");
verb.Category = VerbCategory.Debug;
// TODO VERB ICON control mob icon
verb.Act = () =>
{
targetMind.Mind?.TransferTo(null);
player.ContentData()?.Mind?.TransferTo(args.Target, ghostCheckOverride: true);
};
args.Verbs.Add(verb);
}
// Make Sentient verb
if (_groupController.CanCommand(player, "makesentient") &&
args.User != args.Target &&
!args.Target.HasComponent <MindComponent>())
{
Verb verb = new();
verb.Text = Loc.GetString("make-sentient-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/sentient.svg.192dpi.png";
verb.Act = () => MakeSentientCommand.MakeSentient(args.Target);
args.Verbs.Add(verb);
}
if (_adminManager.HasAdminFlag(player, AdminFlags.Fun))
{
Verb verb = new();
verb.Text = Loc.GetString("explode-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.Act = () =>
{
var coords = args.Target.Transform.Coordinates;
Timer.Spawn(_gameTiming.TickPeriod, () => ExplosionHelper.SpawnExplosion(coords, 0, 1, 2, 1), CancellationToken.None);
if (args.Target.TryGetComponent(out SharedBodyComponent? body))
{
body.Gib();
}
};
args.Verbs.Add(verb);
}
// Set clothing verb
if (_groupController.CanCommand(player, "setoutfit") &&
args.Target.HasComponent <InventoryComponent>())
{
Verb verb = new();
verb.Text = Loc.GetString("set-outfit-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/outfit.svg.192dpi.png";
verb.Act = () => _euiManager.OpenEui(new SetOutfitEui(args.Target), player);
args.Verbs.Add(verb);
}
// In range unoccluded verb
if (_groupController.CanCommand(player, "inrangeunoccluded"))
{
Verb verb = new();
verb.Text = Loc.GetString("in-range-unoccluded-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/information.svg.192dpi.png";
verb.Act = () =>
{
var message = args.User.InRangeUnOccluded(args.Target)
? Loc.GetString("in-range-unoccluded-verb-on-activate-not-occluded")
: Loc.GetString("in-range-unoccluded-verb-on-activate-occluded");
args.Target.PopupMessage(args.User, message);
};
args.Verbs.Add(verb);
}
// Get Disposal tube direction verb
if (_groupController.CanCommand(player, "tubeconnections") &&
args.Target.TryGetComponent <IDisposalTubeComponent>(out var tube))
{
Verb verb = new();
verb.Text = Loc.GetString("tube-direction-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/information.svg.192dpi.png";
verb.Act = () => tube.PopupDirections(args.User);
args.Verbs.Add(verb);
}
// Make ghost role verb
if (_groupController.CanCommand(player, "makeghostrole") &&
!(args.Target.GetComponentOrNull <MindComponent>()?.HasMind ?? false))
{
Verb verb = new();
verb.Text = Loc.GetString("make-ghost-role-verb-get-data-text");
verb.Category = VerbCategory.Debug;
// TODO VERB ICON add ghost icon
// Where is the national park service icon for haunted forests?
verb.Act = () => _ghostRoleSystem.OpenMakeGhostRoleEui(player, args.Target.Uid);
args.Verbs.Add(verb);
}
// Configuration verb. Is this even used for anything!?
if (_groupController.CanAdminMenu(player) &&
args.Target.TryGetComponent <ConfigurationComponent>(out var config))
{
Verb verb = new();
verb.Text = Loc.GetString("configure-verb-get-data-text");
verb.IconTexture = "/Textures/Interface/VerbIcons/settings.svg.192dpi.png";
verb.Category = VerbCategory.Debug;
verb.Act = () => config.OpenUserInterface(actor);
args.Verbs.Add(verb);
}
// Add reagent verb
if (_adminManager.HasAdminFlag(player, AdminFlags.Fun) &&
args.Target.HasComponent <SolutionContainerManagerComponent>())
{
Verb verb = new();
verb.Text = Loc.GetString("admin-add-reagent-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/spill.svg.192dpi.png";
verb.Act = () => _euiManager.OpenEui(new AdminAddReagentEui(args.Target), player);
// TODO CHEMISTRY
// Add reagent ui broke after solution refactor. Needs fixing
verb.Disabled = true;
verb.Tooltip = "Currently non functional after solution refactor.";
verb.Priority = -2;
args.Verbs.Add(verb);
}
}
}
void OnDestroy()
{
ExplosionHelper.Remove(this);
removeAllVehiclesInVision();
}