コード例 #1
0
    public void ChangeDamageType(ContainerDamageTypes type)
    {
        switch (type)
        {
        case ContainerDamageTypes.PhysicalDamage:
            Debug.Log(gameObject.name + " choise the PhysicalDamage!");
            DamageType = new PhysicalDamage();
            break;

        case ContainerDamageTypes.FireDamage:
            Debug.Log(gameObject.name + " choise the FireDamage!");
            DamageType = new FireDamage();
            break;

        case ContainerDamageTypes.IceDamage:
            Debug.Log(gameObject.name + " choise the IceDamage!");
            DamageType = new IceDamage();
            break;

        default:
            Debug.LogError(gameObject.name + " : error in Damage Type!");
            break;

            // Нельзя выбрать данные типы урона в качестве атаки!
            //case ContainerDamageTypes.BleedingDamage:
            //    Debug.Log(gameObject.name + " choise the BleedingDamage!");
            //    DamageType = new BleedingDamage();
            //    break;
            //case ContainerDamageTypes.PoisonDamage:
            //    Debug.Log(gameObject.name + " choise the PoisonDamage!");
            //    DamageType = new PoisonDamage();
            //    break;
        }
    }
コード例 #2
0
 private void AddElementalDamageProperties(ObjectPropertyList list)
 {
     if (DirectDamage != 0)
     {
         list.Add(1079978, DirectDamage.ToString());                   // Direct Damage: ~1_PERCENT~%
     }
     if (PhysicalDamage != 0)
     {
         list.Add(1060403, PhysicalDamage.ToString());                   // physical damage ~1_val~%
     }
     if (FireDamage != 0)
     {
         list.Add(1060405, FireDamage.ToString());                   // fire damage ~1_val~%
     }
     if (ColdDamage != 0)
     {
         list.Add(1060404, ColdDamage.ToString());                   // cold damage ~1_val~%
     }
     if (PoisonDamage != 0)
     {
         list.Add(1060406, PoisonDamage.ToString());                   // poison damage ~1_val~%
     }
     if (EnergyDamage != 0)
     {
         list.Add(1060407, EnergyDamage.ToString());                   // energy damage ~1_val~%
     }
     if (ChaosDamage != 0)
     {
         list.Add(1072846, ChaosDamage.ToString());                   // chaos damage ~1_val~%
     }
 }
コード例 #3
0
        /*
         * public override Item Dupe(Item item, int amount)
         * {
         *  BaseSiegeProjectile s = item as BaseSiegeProjectile;
         *  // dupe the siege projectile props
         *  if (s != null)
         *  {
         *      s.FiringSpeed = FiringSpeed;
         *      s.AccuracyBonus = AccuracyBonus;
         *      s.Area = Area;
         *      s.Range = Range;
         *      s.FireDamage = FireDamage;
         *      s.PhysicalDamage = PhysicalDamage;
         *  }
         *  // dupe the regular item props
         *  return base.Dupe(item, amount);
         * }
         */
        public override void GetProperties(ObjectPropertyList list)
        {
            base.GetProperties(list);

            list.Add(1061169, Range.ToString());                                  // range ~1_val~
            list.Add(1060658, "Speed\t{0}", FiringSpeed.ToString());              // ~1_val~: ~2_val~
            list.Add(1060659, "Accuracy bonus\t{0}", AccuracyBonus.ToString());   // ~1_val~: ~2_val~
            list.Add(1060660, "Area\t{0}", Area.ToString());                      // ~1_val~: ~2_val~
            list.Add(1060661, "Physical damage\t{0}", PhysicalDamage.ToString()); // ~1_val~: ~2_val~
            list.Add(1060662, "Fire damage\t{0}", FireDamage.ToString());         // ~1_val~: ~2_val~
        }
コード例 #4
0
ファイル: FireDamage.cs プロジェクト: ahvonenj/TheForest
 private void Spread()
 {
     if (BoltNetwork.isClient)
     {
         return;
     }
     for (int i = 0; i < this.FirePoints.Length; i++)
     {
         FireDamagePoint fireDamagePoint = this.FirePoints[i];
         if (fireDamagePoint.isBurning)
         {
             FireDamagePoint fireDamagePoint2 = this.FindClosestFirePoint(fireDamagePoint.Position);
             if (fireDamagePoint2 != null)
             {
                 this.BurnPoint(fireDamagePoint2);
             }
         }
     }
     if (this.burnGeneration + 1 < 10 && this.SpreadLayers != 0)
     {
         for (int j = 0; j < this.FirePoints.Length; j++)
         {
             FireDamagePoint fireDamagePoint3 = this.FirePoints[j];
             if (fireDamagePoint3.isBurning)
             {
                 Vector3    vector = base.transform.TransformPoint(fireDamagePoint3.Position);
                 Collider[] array  = Physics.OverlapSphere(vector, fireDamagePoint3.Radius, this.SpreadLayers);
                 for (int k = 0; k < array.Length; k++)
                 {
                     Collider collider = array[k];
                     if (!collider.transform.IsChildOf(base.transform))
                     {
                         FireDamage componentInChildren = collider.GetComponentInChildren <FireDamage>();
                         if (componentInChildren)
                         {
                             componentInChildren.Ignite(vector, this.burnGeneration + 1);
                         }
                         else
                         {
                             collider.SendMessage("Burn", SendMessageOptions.DontRequireReceiver);
                         }
                     }
                 }
             }
         }
     }
 }
コード例 #5
0
    void apply_effect(GameObject bullet, Gem to_apply)
    {
        switch (to_apply.getElement())
        {
        case 'F':
            FireAspect fire_aspect = bullet.AddComponent <FireAspect> ();
            fire_aspect.damagePerTick = to_apply.getGrade();
            fire_aspect.ticks         = 4 + to_apply.getGrade();
            FireDamage fire_damage = bullet.AddComponent <FireDamage> ();
            fire_damage.damage = to_apply.getGrade();
            break;

        case 'W':
            WaterAspect water_aspect = bullet.AddComponent <WaterAspect> ();
            water_aspect.slowPercentage = 0.90f / (float)to_apply.getGrade();
            WaterDamage water_damage = bullet.AddComponent <WaterDamage> ();
            water_damage.damage = to_apply.getGrade();
            break;

        case 'A':
            AirAspect air_aspect = bullet.AddComponent <AirAspect> ();
            air_aspect.damageMultiplier = 1 + to_apply.getGrade();
            AirDamage air_damage = bullet.AddComponent <AirDamage> ();
            air_damage.damage = to_apply.getGrade();
            break;

        case 'E':
            EarthAspect earth_aspect = bullet.AddComponent <EarthAspect> ();
            earth_aspect.mass = 500 * to_apply.getGrade();
            EarthDamage earth_damage = bullet.AddComponent <EarthDamage> ();
            earth_damage.damage = to_apply.getGrade();
            break;

        default:
            break;
        }
    }
コード例 #6
0
 public Fire_Dagger()
 {
     damage     = 40;
     damageType = new FireDamage();
 }
コード例 #7
0
        public override void GetProperties(ObjectPropertyList list)
        {
            base.GetProperties(list);

            if (m_Exceptional)
            {
                list.Add(1060636);                   // exceptional
            }
            if (m_Crafter != null)
            {
                list.Add(1050043, m_Crafter.Name);                   // crafted by ~1_NAME~
            }
            int ammoamount = (Ammo != null ? Ammo.Amount : 0);

            list.Add((Ammo is Bolt ? 1075266 : 1075265), "{0}\t{1}", ammoamount.ToString(), MaxAmmo.ToString());                 // Ammo: ~1_QUANTITY~/~2_CAPACITY~ arrows/bolts

            if (DamageModifier != 0)
            {
                list.Add(1074762, DamageModifier.ToString()); // Damage Modifier: ~1_PERCENT~%
            }
            list.Add(1075085);                                // Requirement: Mondain's Legacy

            int prop;

            if ((prop = Attributes.WeaponDamage) != 0)
            {
                list.Add(1060401, prop.ToString());                   // damage increase ~1_val~%
            }
            if ((prop = Attributes.DefendChance) != 0)
            {
                list.Add(1060408, prop.ToString());                   // defense chance increase ~1_val~%
            }
            if ((prop = Attributes.BonusDex) != 0)
            {
                list.Add(1060409, prop.ToString());                   // dexterity bonus ~1_val~
            }
            if ((prop = Attributes.EnhancePotions) != 0)
            {
                list.Add(1060411, prop.ToString());                   // enhance potions ~1_val~%
            }
            if ((prop = Attributes.CastRecovery) != 0)
            {
                list.Add(1060412, prop.ToString());                   // faster cast recovery ~1_val~
            }
            if ((prop = Attributes.CastSpeed) != 0)
            {
                list.Add(1060413, prop.ToString());                   // faster casting ~1_val~
            }
            if ((prop = Attributes.AttackChance) != 0)
            {
                list.Add(1060415, prop.ToString());                   // hit chance increase ~1_val~%
            }
            if ((prop = Attributes.BonusHits) != 0)
            {
                list.Add(1060431, prop.ToString());                   // hit point increase ~1_val~
            }
            if ((prop = Attributes.BonusInt) != 0)
            {
                list.Add(1060432, prop.ToString());                   // intelligence bonus ~1_val~
            }
            if ((prop = Attributes.LowerManaCost) != 0)
            {
                list.Add(1060433, prop.ToString());                   // lower mana cost ~1_val~%
            }
            if ((prop = Attributes.LowerRegCost) != 0)
            {
                list.Add(1060434, prop.ToString());                   // lower reagent cost ~1_val~%
            }
            if ((prop = Attributes.LowerAmmoCost) != 0)
            {
                list.Add(1075208, prop.ToString());                   // Lower Ammo Cost ~1_Percentage~%
            }
            if ((prop = Attributes.Luck) != 0)
            {
                list.Add(1060436, prop.ToString());                   // luck ~1_val~
            }
            if ((prop = Attributes.BonusMana) != 0)
            {
                list.Add(1060439, prop.ToString());                   // mana increase ~1_val~
            }
            if ((prop = Attributes.RegenMana) != 0)
            {
                list.Add(1060440, prop.ToString());                   // mana regeneration ~1_val~
            }
            if ((prop = Attributes.NightSight) != 0)
            {
                list.Add(1060441);                   // night sight
            }
            if ((prop = Attributes.ReflectPhysical) != 0)
            {
                list.Add(1060442, prop.ToString());                   // reflect physical damage ~1_val~%
            }
            if ((prop = Attributes.RegenStam) != 0)
            {
                list.Add(1060443, prop.ToString());                   // stamina regeneration ~1_val~
            }
            if ((prop = Attributes.RegenHits) != 0)
            {
                list.Add(1060444, prop.ToString());                   // hit point regeneration ~1_val~
            }
            if ((prop = Attributes.SpellChanneling) != 0)
            {
                list.Add(1060482);                   // spell channeling
            }
            if ((prop = Attributes.SpellDamage) != 0)
            {
                list.Add(1060483, prop.ToString());                   // spell damage increase ~1_val~%
            }
            if ((prop = Attributes.BonusStam) != 0)
            {
                list.Add(1060484, prop.ToString());                   // stamina increase ~1_val~
            }
            if ((prop = Attributes.BonusStr) != 0)
            {
                list.Add(1060485, prop.ToString());                   // strength bonus ~1_val~
            }
            if ((prop = Attributes.WeaponSpeed) != 0)
            {
                list.Add(1060486, prop.ToString());                   // swing speed increase ~1_val~%
            }
            if (DirectDamage != 0)
            {
                list.Add(1079978, DirectDamage.ToString());                   // Direct Damage: ~1_PERCENT~%
            }
            if (PhysicalDamage != 0)
            {
                list.Add(1060403, PhysicalDamage.ToString());                   // physical damage ~1_val~%
            }
            if (FireDamage != 0)
            {
                list.Add(1060405, FireDamage.ToString());                   // fire damage ~1_val~%
            }
            if (ColdDamage != 0)
            {
                list.Add(1060404, ColdDamage.ToString());                   // cold damage ~1_val~%
            }
            if (PoisonDamage != 0)
            {
                list.Add(1060406, PoisonDamage.ToString());                   // poison damage ~1_val~%
            }
            if (EnergyDamage != 0)
            {
                list.Add(1060407, EnergyDamage.ToString());                   // energy damage ~1_val~%
            }
            if (ChaosDamage != 0)
            {
                list.Add(1072846, ChaosDamage.ToString());                   // chaos damage ~1_val~%
            }
            GetSetArmorPropertiesFirst(list);

            this.AddContentProperty(list);

            if (WeightReduction != 0)
            {
                list.Add(1072210, WeightReduction.ToString());                   // Weight reduction: ~1_PERCENTAGE~%
            }
            GetSetArmorPropertiesSecond(list);
        }
コード例 #8
0
    // Will apply damage to any zombies within the Overlap Sphere.
    private void OverlapSphereDamage()
    {
        Collider[] hitColliders = Physics.OverlapSphere(transform.position, blastRadius);

        foreach (Collider collider in hitColliders)
        {
            Transform hitTransform = collider.transform;

            if (hitTransform.root.tag == "Zombie")
            {
                // If we have already iterated through a Zombie containing this collider, then skip to next.
                if (hitZombies.Contains(hitTransform.root))
                {
                    continue;
                }

                // Add the new zombie to the <hitZombies> so that he don't get iterated more than once.
                hitZombies.Add(collider.transform.root);

                ZombieAI targetZombie = collider.transform.root.GetComponent <ZombieAI>();

                if (throwableType == ThrowableType.Molotov)
                {
                    foreach (Transform child in targetZombie.transform)
                    {
                        // If the zombie is already on fire, there is not need to set him on fire.
                        if (child.GetComponent <FireDamage>() != null)
                        {
                            continue;
                        }
                    }

                    // Create a fire particle (does apply damage by itself).
                    GameObject fireClone = Instantiate(fireParticle, collider.transform.position, Quaternion.identity) as GameObject;

                    fireClone.name = "Flame";
                    fireClone.transform.SetParent(targetZombie.transform, true);
                    fireClone.transform.localPosition = Vector3.zero;

                    // Setup the fire particle FireDamage component.
                    FireDamage fireDamage = fireClone.GetComponent <FireDamage>();

                    fireDamage.shooterID    = shooterID;
                    fireDamage.targetZombie = targetZombie;
                }
                else
                {
                    // Set the grenade explosion to this one (for ExplosionForce physics) and apply damage to the zombie.
                    targetZombie.grenadeExplosion = this;
                    targetZombie.TakeDamage(damage, shooterID);
                }
            }
            else if (throwableType == ThrowableType.Grenade)
            {
                Rigidbody targetRigidbody = hitTransform.GetComponent <Rigidbody>();

                if (targetRigidbody != null)
                {
                    targetRigidbody.AddExplosionForce(damage * 10f, transform.position, blastRadius, 2f);
                }
            }
        }

        if (throwableType == ThrowableType.Grenade)
        {
            Destroy(gameObject);
        }
    }
コード例 #9
0
 public Fire_Axe()
 {
     damage     = 20;
     damageType = new FireDamage();
 }
コード例 #10
0
 public Fire_Sword()
 {
     damage     = 10;
     damageType = new FireDamage();
 }
コード例 #11
0
	private void OnDisable()
	{
		this.Parent = null;
	}
コード例 #12
0
        public override Dictionary <string, string> GetCharacterDisplayCalculationValues()
        {
            CalculationsWarlock cw = new CalculationsWarlock();

            Dictionary <string, string> vals = new Dictionary <string, string>();

            vals.Add("Health", BasicStats.Health.ToString());
            vals.Add("Mana", BasicStats.Mana.ToString());
            vals.Add("Stamina", BasicStats.Stamina.ToString());
            vals.Add("Intellect", BasicStats.Intellect.ToString());
            vals.Add("Total Crit %", CritPercent.ToString("0.00"));
            vals.Add("Hit %", HitPercent.ToString("0.00"));
            vals.Add("Haste %", HastePercent.ToString("0.00"));
            vals.Add("Shadow Damage", ShadowDamage.ToString("0"));
            vals.Add("Fire Damage", FireDamage.ToString("0"));
            vals.Add("ISB Uptime", IsbUptime.ToString("0.00"));
            vals.Add("RDPS from ISB", Math.Round(RaidDpsFromIsb).ToString());
            vals.Add("Total Damage", TotalDamage.ToString());
            vals.Add("DPS", Math.Round(DpsRating).ToString());

            //vals.Add("Casting Speed", (1f / (TotalStats.SpellHasteRating / 1570f + 1f)).ToString());
            //vals.Add("Shadow Damage", (TotalStats.SpellShadowDamageRating + TotalStats.SpellDamageRating).ToString());
            //vals.Add("Fire Damage", (TotalStats.SpellFireDamageRating + TotalStats.SpellDamageRating).ToString());
            //vals.Add("DPS", DPS.ToString());
            //if (Spells.Exists(delegate(Spell s) { return s.Name.ToUpper() == "SHADOWBOLT"; }))
            //{
            //    ShadowBolt sb = new ShadowBolt(character, TotalStats);
            //    vals.Add("SB Min Hit", sb.MinDamage.ToString());
            //    vals.Add("SB Max Hit", sb.MaxDamage.ToString());
            //    vals.Add("SB Min Crit", (sb.MinDamage * sb.CritModifier).ToString());
            //    vals.Add("SB Max Crit", (sb.MaxDamage * sb.CritModifier).ToString());
            //    vals.Add("SB Average Hit", sb.AverageDamage.ToString());
            //    vals.Add("SB Crit Rate", sb.CritPercent.ToString());
            //    vals.Add("ISB Uptime", (sb.ISBuptime * 100f).ToString());
            //    vals.Add("#SB Casts", NumCasts[sb].ToString());

            //}
            //else
            //{
            //    vals.Add("SB Min Hit", "");
            //    vals.Add("SB Max Hit", "");
            //    vals.Add("SB Min Crit", "");
            //    vals.Add("SB Max Crit", "");
            //    vals.Add("SB Average Hit", "");
            //    vals.Add("SB Crit Rate", "");
            //    vals.Add("ISB Uptime", "");
            //    vals.Add("#SB Casts", "0");

            //}
            //if (Spells.Exists(delegate(Spell s) { return s.Name.ToUpper() == "INCINERATE"; }))
            //{
            //    Incinerate sb = new Incinerate(character, TotalStats);
            //    vals.Add("Incinerate Min Hit", sb.MinDamage.ToString());
            //    vals.Add("Incinerate Max Hit", sb.MaxDamage.ToString());
            //    vals.Add("Incinerate Min Crit", (sb.MinDamage * sb.CritModifier).ToString());
            //    vals.Add("Incinerate Max Crit", (sb.MaxDamage * sb.CritModifier).ToString());
            //    vals.Add("Incinerate Average Hit", sb.AverageDamage.ToString());
            //    vals.Add("Incinerate Crit Rate", sb.CritPercent.ToString());
            //    vals.Add("#Incinerate Casts", NumCasts[sb].ToString());
            //}
            //else
            //{
            //    vals.Add("Incinerate Min Hit","");
            //    vals.Add("Incinerate Max Hit","");
            //    vals.Add("Incinerate Min Crit","");
            //    vals.Add("Incinerate Max Crit","");
            //    vals.Add("Incinerate Average Hit", "");
            //    vals.Add("Incinerate Crit Rate","");
            //    vals.Add("#Incinerate Casts","0");
            //}
            //if (Spells.Exists(delegate(Spell s) { return s.Name.ToUpper() == "IMMOLATE"; }))
            //{
            //    Immolate sb = new Immolate(character, TotalStats);
            //    vals.Add("ImmolateMin Hit", sb.MinDamage.ToString());
            //    vals.Add("ImmolateMax Hit", sb.MaxDamage.ToString());
            //    vals.Add("ImmolateMin Crit", (sb.MinDamage * sb.CritModifier).ToString());
            //    vals.Add("ImmolateMax Crit", (sb.MaxDamage * sb.CritModifier).ToString());
            //    vals.Add("ImmolateAverage Hit", sb.AverageDamage.ToString());
            //    vals.Add("ImmolateCrit Rate", sb.CritPercent.ToString());
            //    vals.Add("#Immolate Casts", NumCasts[sb].ToString());
            //}
            //else
            //{
            //    vals.Add("ImmolateMin Hit","");
            //    vals.Add("ImmolateMax Hit","");
            //    vals.Add("ImmolateMin Crit","");
            //    vals.Add("ImmolateMax Crit","");
            //    vals.Add("ImmolateAverage Hit","");
            //    vals.Add("ImmolateCrit Rate","");
            //    vals.Add("#Immolate Casts","0");
            //}
            //if (Spells.Exists(delegate(Spell s) { return s.Name.ToUpper() == "CURSEOFAGONY"; }))
            //{
            //    CurseOfAgony sb = new CurseOfAgony(character, TotalStats);
            //    vals.Add("CoA Tick", (sb.AverageDamage / (sb.PeriodicDuration / sb.PeriodicTickInterval)).ToString());
            //    vals.Add("CoA Total Damage", sb.AverageDamage.ToString());
            //    vals.Add("#CoA Casts", NumCasts[sb].ToString());
            //}
            //else
            //{
            //    vals.Add("CoA Tick","");
            //    vals.Add("CoA Total Damage","");
            //    vals.Add("#CoA Casts","0");
            //}
            //if (Spells.Exists(delegate(Spell s) { return s.Name.ToUpper() == "CURSEOFDOOM"; }))
            //{
            //    CurseOfDoom sb = new CurseOfDoom(character, TotalStats);
            //    vals.Add("CoD Total Damage", sb.AverageDamage.ToString());
            //    vals.Add("#CoD Casts", NumCasts[sb].ToString());
            //}
            //else
            //{
            //    vals.Add("CoD Total Damage","");
            //    vals.Add("#CoD Casts","");
            //}
            //if (Spells.Exists(delegate(Spell s) { return s.Name.ToUpper() == "CORRUPTION"; }))
            //{
            //    Corruption sb = new Corruption(character, TotalStats);
            //    vals.Add("Corr Tick", (sb.AverageDamage / (sb.PeriodicDuration / sb.PeriodicTickInterval)).ToString());
            //    vals.Add("Corr Total Damage", sb.AverageDamage.ToString());
            //    vals.Add("#Corr Casts", NumCasts[sb].ToString());
            //}
            //else
            //{
            //    vals.Add("Corr Tick", "");
            //    vals.Add("Corr Total Damage","");
            //    vals.Add("#Corr Casts","");
            //}
            //if (Spells.Exists(delegate(Spell s) { return s.Name.ToUpper() == "UNSTABLEAFFLICTION"; }))
            //{
            //    UnstableAffliction sb = new UnstableAffliction(character, TotalStats);
            //    vals.Add("UA Tick", (sb.AverageDamage / (sb.PeriodicDuration / sb.PeriodicTickInterval)).ToString());
            //    vals.Add("UA Total Damage", sb.AverageDamage.ToString());
            //    vals.Add("#UA Casts", NumCasts[sb].ToString());
            //}
            //else
            //{
            //    vals.Add("UA Tick", "");
            //    vals.Add("UA Total Damage","");
            //    vals.Add("#UA Casts", "0");
            //}
            //if (Spells.Exists(delegate(Spell s) { return s.Name.ToUpper() == "SIPHONLIFE"; }))
            //{
            //    SiphonLife sb = new SiphonLife(character, TotalStats);
            //    vals.Add("SL Tick", (sb.AverageDamage / (sb.PeriodicDuration / sb.PeriodicTickInterval)).ToString());
            //    vals.Add("SL Total Damage", sb.AverageDamage.ToString());
            //    vals.Add("#SL Casts", NumCasts[sb].ToString());
            //}
            //else
            //{
            //    vals.Add("SL Tick","");
            //    vals.Add("SL Total Damage","");
            //    vals.Add("#SL Casts","0");
            //}
            //vals.Add("#Lifetaps", NumLifetaps.ToString());
            //vals.Add("Mana Per LT", LifetapManaReturn.ToString());

            return(vals);
        }