public virtual int CalculateDamage(DamagePacket dmg)
{
float finalDamage = dmg.HitPoints;
switch (dmg.Type)
{
case DamagePacket.DamageType.GENERIC:
{
finalDamage = finalDamage * (1.0f - Mathf.Clamp01(Resistances.GenericResistance.Value));
break;
}
case DamagePacket.DamageType.PROJECTILE:
{
finalDamage = finalDamage * (1.0f - Mathf.Clamp01(Resistances.ProjectileResistance.Value));
break;
}
case DamagePacket.DamageType.STRUCTURAL:
{
finalDamage = finalDamage * (1.0f - Mathf.Clamp01(Resistances.StructuralResistance.Value));
break;
}
}
return(Mathf.Max(0, (int)finalDamage));
}
protected virtual DamagePacket ScaleDamageByCharge(DamagePacket dmg)
{
dmg.HitPoints = Mathf.FloorToInt(dmg.HitPoints * (0.2f + _attackCharge * _attackCharge * 0.8f));
dmg.Knockback = dmg.Knockback * _attackCharge;
return(dmg);
}
public static void DealDamageToTarget(GameObject target, DamagePacket dmg, Pawn source, RaycastHit?hitInfo = null)
{
DamageReciever targetDR = target.GetComponent <DamageReciever>();
float kbRes = 0.0f;
if (targetDR)
{
int finalDamage = targetDR.CalculateDamage(dmg);
targetDR.TakeDamage(finalDamage, source);
kbRes = Mathf.Clamp01(targetDR.Resistances.KnockbackResistance.Value);
if (targetDR.HitParticles && hitInfo.HasValue && finalDamage > 0)
{
GameObject spawnedParticles = Instantiate(targetDR.HitParticles, hitInfo.Value.point, Quaternion.identity);
spawnedParticles.transform.forward = hitInfo.Value.normal;
}
}
Rigidbody targetRB = target.GetComponent <Rigidbody>();
if (targetRB)
{
float finalKnockback = Mathf.Max(0.0f, dmg.Knockback * (1.0f - kbRes));
Vector3 knockbackVector = (targetRB.transform.position - source.transform.position).normalized * finalKnockback;
knockbackVector.y = finalKnockback * verticalKnockbackScalar;
if (hitInfo.HasValue)
{
targetRB.AddForceAtPosition(knockbackVector, hitInfo.Value.point, ForceMode.Impulse);
}
else
{
targetRB.AddForce(knockbackVector, ForceMode.Impulse);
}
}
}
private void OnTakeDamage(DamagePacket damage)
{
CameraFX.MainCamera.ScreenShake();
healthText.gameObject.transform.localScale = Vector3.one * 3f;
iTween.ScaleTo(healthText.gameObject, iTween.Hash("scale", Vector3.one, "time", 1f, "easetype", iTween.EaseType.easeOutElastic));
damageParticle.Play();
}
public virtual void Initialize(Vector3 initVelocity, DamagePacket dmg, LayerMask hittable, Pawn source, float maxDistance = DefaultMaxTravelDistance)
{
_velocity = initVelocity;
_damage = dmg;
_hittable = hittable;
_source = source;
_maxTravelDistance = maxDistance;
LineRenderer lr = GetComponent <LineRenderer>();
if (lr)
{
List <Vector3> points = new List <Vector3>();
points.Add(transform.position);
float distTrav = 0.0f;
Vector3 startPos = transform.position;
Vector3 vel = initVelocity;
for (float distance = 0.0f; distance < _maxTravelDistance; distance += distTrav)
{
vel += Physics.gravity * 0.001f;
Vector3 endPos = startPos + vel * 0.001f;
distTrav = (endPos - startPos).magnitude;
//Debug.DrawLine(startPos, endPos, Color.red, 7.0f);
points.Add(endPos);
startPos = endPos;
}
lr.positionCount = points.Count;
lr.SetPositions(points.ToArray());
}
}
private void OnTriggerEnter(Collider collider)
{
if (!collider.isTrigger)
{
var rb = collider.attachedRigidbody;
if (rb != null)
{
if (!_previousCollisions.Contains(rb))
{
_previousCollisions.Add(rb);
rb.AddExplosionForce(ExplosionForce, transform.position, ExplosionRadius);
var hc = rb.GetComponent <HealthControler>();
if (hc != null)
{
var distance = Vector3.Distance(rb.position, transform.position);
var damage = distance > 1 ? ExplosionBaseDamage / (distance * distance) : ExplosionBaseDamage;
var packet = new DamagePacket(damage, true);
hc.ApplyDamage(packet);
}
}
}
}
}
public void OnHit(DamagePacket damagePacket, Vector3 hitPosition)
{
Vector3 currentPos = transform.position;
float xDistFromCenter = hitPosition.x - currentPos.x;
float yDistFromCenter = hitPosition.y - currentPos.y;
float zDistFromCenter = hitPosition.z - currentPos.z;
Logging.Log("x Difference: " + xDistFromCenter.ToString("F10") +
". y Difference: " + yDistFromCenter.ToString("F10") +
". Z difference: " + zDistFromCenter.ToString("F10") +
" | " + damagePacket.source.name);
// if (HitList == null)
// {
// HitList = new List<Tuple<Vector3, Character>>();
// }
// var sameAsPreviousShot = true;
// var ownerAlreadyExists = false;
// float tupleDiff = 0;
// foreach ((Vector3 position, Character character) in HitList)
// {
// if (character.GetInstanceID() == controller.GetInstanceID())
// {
// ownerAlreadyExists = true;
// break;
// }
//
// tupleDiff = hitPosition.x - position.x + hitPosition.y - position.y + hitPosition.z - position.z;
// if (Math.Abs(tupleDiff) > 0.000001f)
// {
// sameAsPreviousShot = false;
// }
// }
// if (ownerAlreadyExists)
// {
// Logging.Log("Already shot on this target!");
// return;
// }
// if (HitList.Count < 1)
// {
// HitList.Add(new Tuple<Vector3, Character>(hitPosition, controller));
// }
// if (sameAsPreviousShot)
// {
// Logging.instance.Log("Same as all previous shot on target: " + transform.parent.name);
// }
// else
// {
// Logging.instance.Log("Not same as all previous shot on target: " + transform.parent.name + ". Off by: " +
// tupleDiff);
// }
}
protected override void OnReceiveDataEvent(uint packetID, ushort packetTypeID, Stream stream)
{
//Debug.Log("Applying velocity received to " + gameObject.name);
switch (packetTypeID)
{
case (ushort)UserPacketType.Velocity:
VelocityPacket velocityPacket = new VelocityPacket();
velocityPacket.Deserialize(stream);
//Debug.Log("Applying velocity received to " + gameObject.name);
Vector3 velocityReceived = new Vector3(
velocityPacket.payload.velocity.x,
velocityPacket.payload.velocity.y,
velocityPacket.payload.velocity.z
);
//rb.position += velocityReceived;
transform.Translate(velocityReceived, Space.Self);
if (NetworkManager.Instance.isServer)
{
NetworkMessageManager.Instance.SendPosition(transform.position, (uint)objectID);
}
break;
case (ushort)UserPacketType.Position:
PositionPacket positionPacket = new PositionPacket();
positionPacket.Deserialize(stream);
Vector3 position = new Vector3(
positionPacket.payload.position.x,
positionPacket.payload.position.y,
positionPacket.payload.position.z
);
//rb.position = position;
transform.position = position;
break;
case (ushort)UserPacketType.Shoot:
Shoot();
break;
case (ushort)UserPacketType.Damage:
DamagePacket damagePacket = new DamagePacket();
damagePacket.Deserialize(stream);
TakeDamage((int)damagePacket.payload.damage);
break;
case (ushort)UserPacketType.ShipDestroyed:
Instantiate(explosionEffect, transform.position, Quaternion.identity);
Destroy(gameObject);
break;
}
}
public void handleDamagePacket(DamagePacket packet)
{
float value;
Dictionary<string,float> rTable = pStats.getDRTable();
value = rTable[packet.getDI()];
int damage = ((int)(((packet.getDamage())/value)));
pStats.setHealth(pStats.getHealth()-damage);
}
public void OnDamaged(DamagePacket packet)
{
health -= packet.damage;
if (health <= 0)
{
Explode();
}
}
public void SendDamagePacket(uint damage, uint objectID, bool sendAsReliable = false)
{
DamagePacket damagePacket = new DamagePacket();
damagePacket.payload.damage = damage;
SendPacket(damagePacket, objectID);
}
public void ApplyDamage(GameObject go, float damage)
{
DamagePacket packet = new DamagePacket("Damage");
packet.damageDone = damage;
packet.damaged_items_id = go.GetComponent <ScapeNet_Network_ID>().object_id;
client.SendPacketToServer(packet);
}
public override void Use(Unit Owner, Targetable Target)
{
Projectile NewProjectile = Instantiate(ProjectilePrefab);
DamagePacket NewPacket = new DamagePacket(Damage * Owner.DamageMultiplier, DamageType);
NewProjectile.Init(Owner, NewPacket);
NewProjectile.Launch(Owner.transform.position, Target.transform.position);
bReady = false;
}
/// <summary>
/// Applys damage, ignores resistance and armour
/// </summary>
/// <param name="damage"></param>
public void ApplyDamage(DamagePacket damage)
{
if (damage.IsAOE && DamageDelegate != null)
{
//Debug.Log(transform.name + " Ignoring AOE damage because it has a delegate");
}
else
{
ApplyDamage(damage.Damage);
}
}
private void OnDamage(Client client, Packet packet)
{
if (AntiLagConfig.Default.Damage)
{
DamagePacket dp = (DamagePacket)packet;
if (dp.ObjectId != client.ObjectId)
{
packet.Send = false;
}
}
}
private void ReceiveDamage(IRecvPacket packet)
{
DamagePacket p = (DamagePacket)packet;
Mobile entity = EntityManager.GetObject <Mobile>(p.Serial, false);
if (entity == null)
{
return;
}
World.Interaction.ChatMessage(string.Format("{0} takes {1} damage!", entity.Name, p.Damage));
}
private void OnDamage(SocketIOEvent obj)
{
DamagePacket packet = JsonUtility.FromJson <DamagePacket>(obj.data);
string id = packet.id;
if (!players.ContainsKey(id))
{
return;
}
players[id].SetHealth(packet.damage);
}
protected virtual void OnDRTakeDamage(DamagePacket damage)
{
int spriteIndex = Mathf.Clamp(_trackedDR.Health, 0, spriteIndicators.Length - 1);
if (DestroyAtZeroHealth && spriteIndex == 0)
{
Destroy(gameObject);
}
else
{
_spriteRenderer.sprite = spriteIndicators[spriteIndex];
}
}
public override void Use(Unit Owner, Targetable Target)
{
DamagePacket MeleeDamagePacked = new DamagePacket(Damage * Owner.DamageMultiplier, DamageType);
Target.TakeDamage(MeleeDamagePacked, (bool bKilled) =>
{
if (bKilled)
{
Debug.Log("Killed enemy");
}
});
bReady = false;
}
public void TakeDamage(string id, int dmg)
{
if (string.IsNullOrEmpty(id))
{
return;
}
DamagePacket packet = new DamagePacket();
packet.id = id;
packet.damage = dmg;
socket.Emit("damage", JsonUtility.ToJson(packet));
}
private void BuildDamagePacket()
{
Entity e = gameObject.GetComponentDownThenUp <EntityWrapper>().Entity;
foreach (var fit in e.GetComponent <ShipFittingsComp>().fittingList)
{
if (gameObject == fit.FittedWeapon.WeaponGameObject)
{
Debug.Log($"Found proper fitted weapon, copying dmg packet");
particleDmgPacket = new DamagePacket(fit.FittedWeapon.HullDamage, fit.FittedWeapon.ShieldDamage);
break;
}
}
}
public DamagePacket GetDamagePacket(Vector2 explosionPoint, Vector2 hitPoint, IDamageDealer explosionCauser)
{
DamagePacket packet = new DamagePacket(DamageType.EXPLOSION, explosionCauser);
Vector2 vecToHitPoint = hitPoint - explosionPoint;
float distance = 1.0f - vecToHitPoint.magnitude / EffectiveRadius;
float pointMagnitude = distance * distance;// 0.75f / (Mathf.PI * Mathf.Pow(distance, 3.0f));
packet.DamageAmount = Mathf.RoundToInt(pointMagnitude * BaseDamageAmount);
packet.KnockbackVector = vecToHitPoint.normalized * pointMagnitude * BaseKnockbackStrength;
return(packet);
}
// TemplePlus extension
public static void DispatchSpellDamage(this GameObject obj, DamagePacket damage, GameObject target, SpellPacketBody spellPkt)
{
var dispatcher = obj.GetDispatcher();
if (dispatcher != null)
{
EvtObjDealingSpellDamage dispIo = new EvtObjDealingSpellDamage
{
damage = damage,
spellPkt = spellPkt,
target = target
};
dispatcher.Process(DispatcherType.DealingDamageSpell, 0, dispIo);
}
}
public void OnShot(GameObject projectile, DamagePacket packet)
{
if (_alarmActivated)
{
_durationTimer = 0; return;
}
GetComponent <AudioSource>().Play();
Spawn.SurroundWithPriority(transform.position, 10, zombieTargetPriority);
Senses.TriggerSoundAlert(transform.position, zombieTargetPriority);
_alarmActivated = true;
//LightPulseSpeed *= 2f;
light.range *= lightRangeMultiplier;
}
public void DamagePacketInstantiateTest()
{
byte[] data = new byte[] { 0x0B, 0x01, 0x02, 0x03, 0x04, 0xEF, 0xFE };
ushort length = (ushort)data.Length;
PacketBuffer buffer = new PacketBuffer(data);
PacketReader reader = new PacketReader(ClientVersion.vMAX, buffer, length);
DamagePacket packet;
packet = DamagePacket.Instantiate(reader);
Assert.IsTrue(packet is DamagePacket);
Assert.AreEqual(0x01020304, packet.Serial.Value);
Assert.AreEqual(0xEFFE, packet.Amount);
}
public void TestDamage(int inputAmount)
{
Serial serial = 0x1024;
var expected = new DamagePacket(serial, inputAmount).Compile();
using var ns = PacketTestUtilities.CreateTestNetState();
ns.ProtocolChanges = ProtocolChanges.DamagePacket;
ns.SendDamage(serial, inputAmount);
var result = ns.SendPipe.Reader.TryRead();
AssertThat.Equal(result.Buffer[0].AsSpan(0), expected);
}
public void TestDamage(int inputAmount, ushort expectedAmount)
{
var m = new Mobile(0x1);
m.DefaultMobileInit();
var data = new DamagePacket(m.Serial, inputAmount).Compile();
Span <byte> expectedData = stackalloc byte[7];
var pos = 0;
expectedData.Write(ref pos, (byte)0x0B); // Packet ID
expectedData.Write(ref pos, m.Serial);
expectedData.Write(ref pos, expectedAmount);
AssertThat.Equal(data, expectedData);
}
// Method in charge of making this DamageReceiver have it's health decrement & receive knockback.
// Takes in parameter damage of type DamagePacket.
// DamagePackets are 3 parts: DamageType, DamageAmount, and KnockbackVector.
// DamagePackets MUST define a DamageType, but defining DamageAmount and KnockbackVector are optional (will default to 1 and Vector2.zero, respectively)
public virtual void TakeDamage(DamagePacket damage, Vector2?hitPoint = null)
{
//Already dead don't do anything
if (!IsAlive)
{
return;
}
//If this DamageReciever isn't resistant to the type of damage it's taking, subtract the damage from health.
if (!ResistCollisionDamage && damage.Type == DamageType.COLLISION || !ResistProjectileDamage && damage.Type == DamageType.PROJECTILE || !ResistExplosionDamage && damage.Type == DamageType.EXPLOSION)
{
_health -= damage.DamageAmount;
if (damage.DamageAmount > 0)
{
OnTakeDamage?.Invoke(damage);
Debug.Log(name + " takes " + damage.DamageAmount + " " + damage.Type + " damage from " + damage.DamageDealer);
damage.DamageDealer?.OnDamageDealtTo(this);
}
}
if (damage.DamageAmount > 0 && DamageFlashCoroutine == null && DoDamageFlash)
{
DamageFlashCoroutine = StartCoroutine(DamageFlash());
}
//If there is a rigidbody2D on this GameObject and this DamageReciever doesn't resist knockback, apply knockback from DamagePacket.
Rigidbody2D rb = GetComponent <Rigidbody2D>();
if (rb && !ResistKnockback)
{
if (hitPoint.HasValue)
{
rb.AddForceAtPosition(damage.KnockbackVector, hitPoint.Value, ForceMode2D.Impulse);
}
else
{
rb.AddForce(damage.KnockbackVector, ForceMode2D.Impulse);
}
}
if (!IsAlive && CanDie)
{
Die(damage.DamageDealer);
}
}
public override void ApplyBuff(float amount)
{
if (BuffCaster.Alive)
{
List <DamagePacket> ownerList = BuffCaster.DeltaHitPointsList;
List <DamagePacket> targetList = Controller.BuffTarget.DeltaHitPointsList;
for (int index = 0; index < targetList.Count; index++)
{
DamagePacket packet = targetList[index];
int delta = packet.GetTotalDelta();
if (delta < 0)
{
ownerList.Add(packet);
targetList.RemoveAt(index);
index--;
}
}
}
}
private static void EnsureMinimumDamage1(DamagePacket dmgPkt)
{
var totalDamage = 0;
var firstDie = true;
foreach (var damageDie in dmgPkt.dice)
{
totalDamage += damageDie.rolledDamage;
if (firstDie)
{
totalDamage += dmgPkt.bonuses.OverallBonus;
firstDie = false;
}
}
if (totalDamage <= 0)
{
dmgPkt.bonuses.AddBonus(1 - totalDamage, 0, 330);
}
}
public void TestDamagePacket(int inputAmount, ushort expectedAmount)
{
var m = new Mobile(0x1);
m.DefaultMobileInit();
Span <byte> data = new DamagePacket(m, inputAmount).Compile();
Span <byte> expectedData = stackalloc byte[]
{
0x0B, // Packet
0x00, 0x00, 0x00, 0x00, // Mobile Serial
0x00, 0x00 // Amount
};
m.Serial.CopyTo(expectedData.Slice(1, 4));
expectedAmount.CopyTo(expectedData.Slice(5, 2));
AssertThat.Equal(data, expectedData);
}
}
