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); } }