void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo info)
{
float newHealth = entity.Health() - info.damageTypes.Total();
// Empty recycler inventory if it's about to be killed to avoid dropping hidden items.
if (newHealth <= 0)
{
var recycler = entity as Recycler;
if (!(entity is Recycler))
{
return;
}
var crafter = CrafterManager.GetCrafter(recycler);
if (crafter == null)
{
return;
}
recycler.inventory.Clear();
recycler.inventory.itemList.Clear();
}
}
private object OnStructureRepair(BaseCombatEntity entity, BasePlayer player)
{
if (!entity.repair.enabled)
{
return(false);
}
if (entity.SecondsSinceAttacked <= 30)
{
return(null);
}
var healthMissing = entity.MaxHealth() - entity.Health();
var healthMissingFraction = 1 - entity.healthFraction;
if (healthMissingFraction <= 0)
{
return(null);
}
if (entity.BuildCost() == null)
{
return(null);
}
var repairAmount = Math.Max(entity.MaxHealth() * RepairFraction, MinRepairAmount);
repairAmount = Math.Min(repairAmount, healthMissing);
entity.health += repairAmount;
entity.SendNetworkUpdate();
if (entity.Health() >= entity.MaxHealth())
{
entity.OnRepairFinished();
}
else
{
entity.OnRepair();
}
return(false);
}
void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo info)
{
if (info == null || info.Initiator == null || info.WeaponPrefab == null || info.InitiatorPlayer == null)
{
return;
}
BasePlayer player = info.InitiatorPlayer;
ulong hitEntityOwnerID = entity.OwnerID != 0 ? entity.OwnerID : info.HitEntity.OwnerID;
if (hitEntityOwnerID == 0)
{
return;
}
string MessageText = lang.GetMessage("BaseAttackedMessageTemplate", this, player.UserIDString)
.Replace("{Attacker}", player.displayName)
.Replace("{Owner}", GetDisplayNameByID(hitEntityOwnerID))
.Replace("{Weapon}", info.WeaponPrefab.ShortPrefabName.Replace(".entity", ""))
.Replace("{Structure}", entity.ShortPrefabName.Replace(".entity", ""))
.Replace("{Damage}", Math.Round(info.damageTypes.Total(), 2).ToString());
//get structure's percentage health remaining for check against threshold
int PercentHealthRemaining = (int)((entity.Health() / entity.MaxHealth()) * 100);
if (IsPlayerActive(hitEntityOwnerID) && IsPlayerNotificationCooledDown(hitEntityOwnerID, NotificationType.ServerNotification, Settings.ServerConfig.NotificationCooldownInSeconds))
{
if (PercentHealthRemaining <= Settings.ServerConfig.ThresholdPercentageHealthRemaining)
{
BasePlayer p = BasePlayer.activePlayerList.Find(x => x.userID == hitEntityOwnerID);
PrintToChat(p, MessageText);
}
}
//Slack
if (Settings.SlackConfig.DoNotifyWhenBaseAttacked && IsPlayerNotificationCooledDown(hitEntityOwnerID, NotificationType.SlackNotification, Settings.SlackConfig.NotificationCooldownInSeconds))
{
if (PercentHealthRemaining <= Settings.SlackConfig.ThresholdPercentageHealthRemaining)
{
SendSlackNotification(player, MessageText);
}
}
//Discord
if (Settings.DiscordConfig.DoNotifyWhenBaseAttacked && IsPlayerNotificationCooledDown(hitEntityOwnerID, NotificationType.DiscordNotification, Settings.DiscordConfig.NotificationCooldownInSeconds))
{
if (PercentHealthRemaining <= Settings.DiscordConfig.ThresholdPercentageHealthRemaining)
{
SendDiscordNotification(player, MessageText);
}
}
}
private object CanPickupEntity(BasePlayer player, BaseCombatEntity entity)
{
if (entity.name != autoTurretPrefab)
{
return(true);
}
var item = ItemManager.Create(entity.pickup.itemTarget, entity.pickup.itemCount);
if (item.hasCondition)
{
item.conditionNormalized = entity.Health() / entity.MaxHealth() / 2;
}
player.GiveItem(item, BaseEntity.GiveItemReason.PickedUp);
entity.OnPickedUp(item, player);
entity.Kill();
return(false);
}
//////////////////////////////////////////////////////////////////////////////////////
private void FixedUpdate()
{
player = GetComponent <BasePlayer>();
if (player.IsDead() || !player.IsFlying)
{
heliAI._currentState = PatrolHelicopterAI.aiState.DEATH;
}
if (heliAI._currentState == PatrolHelicopterAI.aiState.DEATH)
{
heliAI.enabled = true;
DestroyCui(player);
GameObject.Destroy(this);
return;
}
if (rocketMax <= 0)
{
hasRockets = false;
}
if (napalmMax <= 0)
{
hasNapalm = false;
}
Vector3 PlayerPOS = player.transform.position - player.eyes.BodyForward() * 5 + Vector3.down * 0.45f;
CurrentPOS = helicopterBase.transform.position;
Vector3 direction = Quaternion.Euler(input.current.aimAngles) * Vector3.fwd;
heli.spotlightTarget = FindTarget(target);
helicopterBase.transform.localPosition = PlayerPOS;
helicopterBase.transform.rotation = Quaternion.Lerp(helicopterBase.transform.rotation, player.eyes.rotation, 2f * Time.deltaTime);
helicopterBase.transform.eulerAngles = new Vector3(0, helicopterBase.transform.eulerAngles.y, 0);
BaseCombatEntity helientity = helicopterBase.GetComponent <BaseCombatEntity>();
float health = helientity.Health();
HealthIndicator(player, health);
if (health <= 3000f && ShowCockpitOverlay)
{
if (!DamagedHeli.ContainsKey(player.userID))
{
if (ShowCockpitOverlay)
{
DamageOverlay(player);
DamagedHeli.Add(player.userID, new HeliDamage
{
player = player
});
}
}
}
if (isReloading)
{
reloadtimer += Time.deltaTime;
if (reloadtimer >= rocketNapalmReploadTime)
{
isReloading = false;
rocketMax = RocketMax;
hasRockets = true;
napalmMax = NapalmMax;
hasNapalm = true;
reloadtimer = 0.0;
}
}
if (rocketcycle)
{
rocketcycletimer += Time.deltaTime;
if (rocketcycletimer >= rocketDelay)
{
rocketcycle = false;
rocketcycletimer = 0.0;
}
}
if (health > 3000f && ShowCockpitOverlay)
{
if (DamagedHeli.ContainsKey(player.userID))
{
CuiHelper.DestroyUi(player, "DamageGuiOverlay");
DamagedHeli.Remove(player.userID);
}
}
if (input.IsDown(BUTTON.RELOAD))
{
isReloading = true;
}
if (input.IsDown(BUTTON.DUCK))
{
Vector3 downPos = player.transform.position + Vector3.down * (UnityEngine.Time.deltaTime * 3f);
player.ClientRPCPlayer(null, player, "ForcePositionTo", downPos);
player.SendNetworkUpdate();
}
if (input.IsDown(BUTTON.FIRE_PRIMARY))
{
target = FindTarget(target);
FireGuns(target);
}
if (input.IsDown(BUTTON.FIRE_SECONDARY))
{
if (!hasRockets || isReloading)
{
return;
}
if (!rocketcycle)
{
leftTubeFiredLast = !leftTubeFiredLast; FireRocket(leftTubeFiredLast, direction, PlayerPOS, true);
}
rocketcycle = true;
}
if (input.IsDown(BUTTON.FIRE_THIRD))
{
if (!hasNapalm || isReloading)
{
return;
}
if (!rocketcycle)
{
leftTubeFiredLast = !leftTubeFiredLast; FireRocket(leftTubeFiredLast, direction, PlayerPOS, false);
}
rocketcycle = true;
}
}
// BaseCombatEntity
public bool DoRepair(BaseCombatEntity entity, BasePlayer player)
{
if (!entity.repair.enabled)
{
return(false);
}
if (Interface.CallHook("OnStructureRepair", new object[]
{
entity,
player
}) != null)
{
return(false);
}
if (entity.SecondsSinceAttacked <= lastAttackLimit)
{
entity.OnRepairFailed();
return(false);
}
float num = entity.MaxHealth() - entity.Health();
float num2 = num / entity.MaxHealth();
if (num <= 0f || num2 <= 0f)
{
entity.OnRepairFailed();
return(false);
}
var list = entity.RepairCost(num2);
if (list == null || list.Count == 0)
{
return(false);
}
foreach (var ia in list)
{
ia.amount *= repairMulti;
}
float num3 = list.Sum(x => x.amount);
if (num3 > 0f)
{
float num4 = list.Min(x => Mathf.Clamp01((float)player.inventory.GetAmount(x.itemid) / x.amount));
num4 = Mathf.Min(num4, 50f / num);
if (num4 <= 0f)
{
entity.OnRepairFailed();
return(false);
}
int num5 = 0;
foreach (var current in list)
{
int amount = Mathf.CeilToInt(num4 * current.amount);
num5 += player.inventory.Take(null, current.itemid, amount);
}
float num7 = (float)num5 / num3;
entity.health += num * num7;
entity.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
else
{
entity.health += num;
entity.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
if (entity.health >= entity.MaxHealth())
{
entity.OnRepairFinished();
}
else
{
entity.OnRepair();
}
return(true);
}
private void OnEntityTakeDamage(BaseCombatEntity victim, HitInfo hitInfo)
{
if (victim == null || hitInfo == null)
{
return;
}
DamageType type = hitInfo.damageTypes.GetMajorityDamageType();
if (type == null)
{
return;
}
if (hitInfo?.Initiator != null && hitInfo?.Initiator?.ToPlayer() != null && users.Contains(hitInfo.Initiator.ToPlayer().userID))
{
// Need to actually retrieve detailed information on next server tick, because HitInfo will not have been scaled according to hitboxes, protection, etc until then:
NextTick(() =>
{
SendReply(
hitInfo?.Initiator?.ToPlayer(),
string.Format(GetMessage("showhitinfo_displaydamage", hitInfo?.Initiator?.ToPlayer().UserIDString), hitInfo.damageTypes.Total(), victim.Health())
);
});
}
}