Inheritance: MonoBehaviour
    public static WeaponEffect Create(WeaponEffect instance, Transform target)
    {
        WeaponEffect effect = GameObject.Instantiate<WeaponEffect>(instance);
        effect.target = target;

        return effect;
    }
 public Boss(string name, int level, GameItem itemDrop, WeaponEffect effect, int maxHealth,
     int health, int attackDamage, int magic, int defense, int resist, int expDropped,
     int goldDropped, int baseHealth, int baseAttack, int baseMagic, int baseDefense, 
     int baseResist, int expDropBase, int goldDropBase, float healthModifier, 
     float attackModifier, float magicModifier, float defenseModifier, float resistModifier,
     float expModifier, float goldModifier)
     : base(0, 0)
 {
     this.name = name;
     this.level = level;
     this.itemDrop = itemDrop;
     this.effect = effect;
     this.maxHealth = maxHealth;
     this.health = health;
     this.attackDamage = attackDamage;
     this.magic = magic;
     this.defense = defense;
     this.resist = resist;
     this.expDropped = expDropped;
     this.goldDropped = goldDropped;
     this.baseHealth = baseHealth;
     this.baseAttack = baseAttack;
     this.baseMagic = baseMagic;
     this.baseDefense = baseDefense;
     this.baseResist = baseResist;
     this.expDropBase = expDropBase;
     this.goldDropBase = goldDropBase;
     this.healthModifier = healthModifier;
     this.attackModifier = attackModifier;
     this.magicModifier = magicModifier;
     this.defenseModifier = defenseModifier;
     this.resistModifier = resistModifier;
     this.expDropBase = expDropBase;
     this.goldDropBase = goldDropBase;
 }
Example #3
0
 public void RegisterWeaponEffect(WeaponEffect weaponEffect)
 {
     if (weaponEffect != null && !WeaponEffects.Contains(weaponEffect) && !WeaponEffectsToAdd.Contains(weaponEffect))
     {
         WeaponEffectsToAdd.Add(weaponEffect);
     }
 }
 public Weapon(string name, int damage, int cost, int x, int y, WeaponEffect effect = WeaponEffect.none)
     : base(name, cost, x, y)
 {
     this.damage = damage;
     info = "A weapon that deals " + damage + " damage.";
     this.effect = effect;
 }
Example #5
0
 private void OnCastEffect()
 {
     // If we have an effect start it now
     if (this.Effect != null)
     {
         this.activeEffect = WeaponEffect.Create(this.Effect, this.EffectPoint);
     }
 }
Example #6
0
    public virtual void Stop()
    {
        // Get rid of the object
        GameObject.Destroy(this.gameObject);

        // Remove any color effect we performed
        WeaponEffect.ResetBackgroundColor();
    }
Example #7
0
    public static WeaponEffect Create(WeaponEffect instance, Transform target)
    {
        WeaponEffect effect = GameObject.Instantiate <WeaponEffect>(instance);

        effect.target = target;

        return(effect);
    }
 public void EquipItem(ItemBehavior item)
 {
     if (item.weaponSOAsset.weaponScriptName != null && item.weaponSOAsset.weaponScriptName != "")
     {
         WeaponEffect weaponEffect = System.Activator.CreateInstance(System.Type.GetType(item.weaponSOAsset.weaponScriptName), new System.Object[] { this, item }) as WeaponEffect;
         weaponEffect.RegisterEventEffect();
     }
 }
Example #9
0
        static bool Prefix(WeaponEffect __instance)
        {
            var multiplier  = SizeMultiplier.Get(__instance.weapon.weaponDef);
            var ogTransform = Traverse.Create(__instance).Field("projectileTransform").GetValue <Transform>();

            ogTransform.localScale = multiplier;
            Traverse.Create(__instance).Field("projectileTransform").SetValue(ogTransform);
            return(true);
        }
 public MagicWeapon(int magicDamage, string name, int cost, int x, int y, WeaponEffect effect)
     : base(name, cost, x, y)
 {
     this.magicDamage = magicDamage;
     this.name = name;
     this.x = x;
     this.y = y;
     this.cost = cost;
     this.effect = effect;
 }
Example #11
0
        public override void OnCollision(GameObject other, Vec2 position)
        {
            if (other is Projectile)
            {
                var proj = other as Projectile;
                if (!proj.PendingDispose)
                {
                    GameWorld.AddGameObject(AnimationFactory.Create(position, "LaserExplosion"));
                    Hp -= proj.Definition.Damage;
                    if (Hp <= 0)
                    {
                        Hp = 0;

                        LivesRemaining--;
                        if (LivesRemaining < 0)
                        {
                            LivesRemaining = 0;
                        }

                        if (Active)
                        {
                            DeathEffect.Play();
                            AnimationFactory.Create(RigidBody.GetPosition(), "AlienExplosion");
                        }

                        Active = false;
                    }
                }
            }
            else if (other is Health)
            {
                var health = other as Health;
                Hp += health.Hp;
                if (Hp >= MaxHp)
                {
                    Hp = MaxHp;
                }

                HealthEffect.Play();
            }
            else if (other is Laser)
            {
                WeaponEffect.Play();

                var laser = other as Laser;
                WeaponInventory.AddToInventory(laser);
            }
        }
        // This method is used by the IL generators in IntermediateLanguageFuckery
        public static float VariantDamage(WeaponEffect weaponEffect, DesignMaskDef designMask)
        {
            var weapon = weaponEffect.weapon;
            var key    = ShotMemoKey(weaponEffect);

            if (DamageWasAlreadyCalculated(key, out var variantDamage))
            {
                return(variantDamage);
            }
            if (IsNonVariantWeapon(key, weapon, out var damageVariance, out var normalDamage))
            {
                return(normalDamage);
            }

            // the following damage calcs should match with Weapon.DamagePerShotAdjusted(DesignMaskDef), with
            // the addition of the variance computations
            var damagePerShot = weapon.DamagePerShotAdjusted();

            Logger.Debug(
                $"some damage numbers:\n" +
                $"weapon damage: {weapon.DamagePerShot}\n" +
                $"weapon damage adjusted: {weapon.DamagePerShotAdjusted()}\n" +
                $"stats based: {weapon.StatCollection.GetValue<float>("DamagePerShot")}"
                );

            var bounds = new VarianceBounds(
                min: damagePerShot - damageVariance,
                max: damagePerShot + damageVariance,
                standardDeviation: ModSettings.StandardDeviationVarianceMultiplier * damageVariance
                );
            var damage        = Utility.NormalDistibutionRandom(bounds);
            var combat        = Traverse.Create(weapon).Field("combat").GetValue <CombatGameState>();
            var damageWDesign = damage * weapon.GetMaskDamageMultiplier(weapon.parent.occupiedDesignMask);
            var result        = damageWDesign * weapon.GetMaskDamageMultiplier(combat.MapMetaData.biomeDesignMask);

            Logger.Debug(
                $"effect id: {key.weaponEffectId}\n" +
                $"hit index: {key.hitIndex}\n" +
                $"damage and variance: {damagePerShot}+-{damageVariance}\n" +
                $"damage range: {bounds.min}-{bounds.max} (std. dev. {bounds.standardDeviation}\n" +
                $"computed damage: {damage}\n" +
                $"damage w/ design mask: {damageWDesign}\n" +
                $"damage w/ env: {result}"
                );
            WeaponDamageMemo[key] = result;
            return(WeaponDamageMemo[key]);
        }
        private static ShotMemoKey ShotMemoKey(WeaponEffect weaponEffect)
        {
            var hitIndex       = Traverse.Create(weaponEffect).Field("hitIndex").GetValue <int>();
            var weaponEffectId = weaponEffect.GetInstanceID();

            Logger.Debug($"shotmemokey weaponeffectid: {weaponEffectId}");
            if (weaponEffect is BulletEffect bulletEffect)
            {
                weaponEffectId = Traverse.Create(bulletEffect).Field("parentLauncher").GetValue <BallisticEffect>()
                                 .GetInstanceID();
                Logger.Debug($"shotmemokey bullet weaponeffectid: {weaponEffectId}");
            }

            var key = new ShotMemoKey(weaponEffectId, hitIndex);

            return(key);
        }
Example #14
0
    protected override void Start()
    {
        base.Start();

        // Get the line renderer that draws the lightning
        this.strikeLine = GetComponent <LineRenderer>();

        // We need to hide it until we have set the control points,
        // otherwise it will be drawn in the wrong place
        this.strikeLine.enabled = false;

        // Set the new background color if that was chosen
        if (this.ChangeBackgroundColor)
        {
            WeaponEffect.SetBackgroundColor(this.BackgroundColor);
        }
    }
Example #15
0
        public static bool Prefix(WeaponEffect __instance, string ___activeProjectileName)
        {
            try
            {
                if (__instance.weapon.weaponDef.Description.Id == Fields.StreakTargetingLaserId)
                {
                    Logger.Debug($"[WeaponEffect_OnComplete_PREFIX] ({__instance.weapon.parent.DisplayName}) Supressing message for Weapon: {__instance.weapon.weaponDef.Description.Id} (WeaponEffect: {__instance.name})");

                    if (__instance.currentState == WeaponEffect.WeaponEffectState.Complete)
                    {
                        return(false);
                    }
                    __instance.currentState = WeaponEffect.WeaponEffectState.Complete;

                    /* This is to be prevented...
                     * if (!__instance.subEffect)
                     * {
                     *  AttackSequenceResolveDamageMessage message = new AttackSequenceResolveDamageMessage(__instance.hitInfo);
                     *  __instance.Combat.MessageCenter.PublishMessage(message);
                     * }
                     * __instance.PublishNextWeaponMessage();
                     * __instance.PublishWeaponCompleteMessage();
                     */

                    if (__instance.projectilePrefab != null)
                    {
                        AutoPoolObject autoPoolObject = __instance.projectile.GetComponent <AutoPoolObject>();
                        if (autoPoolObject == null)
                        {
                            autoPoolObject = __instance.projectile.AddComponent <AutoPoolObject>();
                        }
                        autoPoolObject.Init(__instance.weapon.parent.Combat.DataManager, ___activeProjectileName, 4f);
                        __instance.projectile = null;
                    }

                    return(false);
                }
                return(true);
            }
            catch (Exception e)
            {
                Logger.Error(e);
                return(true);
            }
        }
Example #16
0
        public static bool Prefix(WeaponEffect __instance, ref float hitDamage)
        {
            try
            {
                if (__instance.weapon.weaponDef.Description.Id == Fields.StreakTargetingLaserId)
                {
                    Logger.Debug($"[WeaponEffect_OnImpact_PREFIX] ({__instance.weapon.parent.DisplayName}) Supressing message for Weapon: {__instance.weapon.weaponDef.Description.Id} (WeaponEffect: {__instance.name})");

                    return(false);
                }
                return(true);
            }
            catch (Exception e)
            {
                Logger.Error(e);
                return(true);
            }
        }
Example #17
0
        public static void Prefix(WeaponEffect __instance, Weapon weapon)
        {
            try
            {
                if (weapon.weaponDef.Description.Id == Fields.StreakTargetingLaserId)
                {
                    float oldPFD = __instance.preFireDuration;
                    // MUST be > 0f or it's gonna be overridden with some fallback
                    __instance.preFireDuration = 0.1f;
                    Logger.Debug($"[WeaponEffect_Init_PREFIX] ({weapon.parent.DisplayName}) Changed preFireDuration for {weapon.Name} from {oldPFD} to {__instance.preFireDuration}");

                    return;
                }
            }
            catch (Exception e)
            {
                Logger.Error(e);
            }
        }
Example #18
0
 public void AddEffects(List <Effect> effects)
 {
     foreach (Effect effect in effects)
     {
         WeaponEffect temp = effect as WeaponEffect;
         if (temp != null)
         {
             int chance = Random.Range(0, 100);
             if (temp.chance > chance)
             {
                 AddModificator(temp.statName, temp.modificator);
             }
         }
         else
         {
             AddModificator(effect.statName, effect.modificator);
         }
     }
 }
Example #19
0
        public static bool Prefix(WeaponEffect __instance)
        {
            try
            {
                if (__instance.weapon.weaponDef.Description.Id == Fields.StreakTargetingLaserId)
                {
                    Logger.Debug($"[WeaponEffect_PublishWeaponCompleteMessage_PREFIX] ({__instance.weapon.parent.DisplayName}) Supressing message for Weapon: {__instance.weapon.weaponDef.Description.Id} (WeaponEffect: {__instance.name})");

                    new Traverse(__instance).Property("FiringComplete").SetValue(true);

                    return(false);
                }
                return(true);
            }
            catch (Exception e)
            {
                Logger.Error(e);
                return(true);
            }
        }
Example #20
0
        public static bool Prefix(WeaponEffect __instance)
        {
            try
            {
                if (__instance.weapon.weaponDef.Description.Id == Fields.StreakTargetingLaserId)
                {
                    Logger.Debug($"[WeaponEffect_PublishNextWeaponMessage_PREFIX] ({__instance.weapon.parent.DisplayName}) Supressing message for Weapon: {__instance.weapon.weaponDef.Description.Id} (WeaponEffect: {__instance.name})");

                    new Traverse(__instance).Field("attackSequenceNextDelayTimer").SetValue(-1f);
                    new Traverse(__instance).Field("hasSentNextWeaponMessage").SetValue(true);

                    return(false);
                }
                return(true);
            }
            catch (Exception e)
            {
                Logger.Error(e);
                return(true);
            }
        }
Example #21
0
    public void SetCard(Card c)
    {
        card        = c;
        cAttack     = card.attack;
        cDurability = card.health;
        GetComponent <SpriteRenderer>().sprite = card.image;
        string effectFile = card.filename + "Effect";

        effectFile = effectFile.Substring(0, 1).ToUpper() + effectFile.Substring(1);
        try
        {
            gameObject.AddComponent(System.Type.GetType(effectFile));
            effect = (WeaponEffect)GetComponent(System.Type.GetType(effectFile));
        }
        catch (Exception e)
        {
            gameObject.AddComponent <WeaponEffect>();
            effect = GetComponent <WeaponEffect>();
        }

        effect.user = player.hero;
    }
        public virtual void TakeDamage(int damage, WeaponEffect effect)
        {
            if (effect == WeaponEffect.burn)
                status = StatusEffect.burned;
            else if (effect == WeaponEffect.curse)
                status = StatusEffect.cursed;

            if (effect != WeaponEffect.penetrate)
                damage -= defense / 2;

            if (damage < 0)
                damage = 0;

            health -= damage;

            if (status == StatusEffect.burned)
                health -= 5;
            else if (status == StatusEffect.cursed)
                health = (int)Math.Ceiling((4f / 5f) * health);

            if (health <= 0)
                alive = false;
        }
Example #23
0
    public override void Fire()
    {
        WeaponEffect.Play();

        //Create a ray from the current position and extending straight forward
        Ray ray = new Ray(transform.position, transform.forward);
        //Create a RaycastHit variable which will store information about the raycast
        RaycastHit hit;

        //If our raycast hits something...
        if (Physics.Raycast(ray, out hit, Range, StrikeableMask))
        {
            //...move the lightning hit game object to the point of the hit...
            //HitEffect.transform.position = hit.point;
            //...and play the effect...
            //HitEffect.Play();
            //...then set the end point of the lightning bolt..
            //_lightningBolt.EndPoint = hit.point;
            //...then try to get a reference to an EnemyHealth script...
            EnemyHealth enemyHealth = hit.collider.GetComponent <EnemyHealth>();
            //...if the script exists...
            if (enemyHealth != null)
            {
                //...tell the enemy to take damage
                enemyHealth.TakeDamage(Damage);
            }
        }
        //Otherwise, if our raycast doesn't hit anything...
        else
        {
            //...place the end of the bolt at maximum range
            //_lightningBolt.EndPoint = ray.GetPoint(_range);
        }
        //Turn the lightning bolt game object on
        //_lightningBolt.gameObject.SetActive(true);
    }
Example #24
0
 public void RemoveEffect(uint id, WeaponEffect effect)
 {
     RemoveEffect(this[id], effect);
 }
        public virtual void TakeMagicDamage(int magicDamage, WeaponEffect effect)
        {
            if (effect == WeaponEffect.burn)
                status = StatusEffect.burned;
            else if (effect == WeaponEffect.curse)
                status = StatusEffect.cursed;

            magicDamage -= resist / 2;

            if (magicDamage < 0)
                magicDamage = 0;

            health -= magicDamage;

            if (status == StatusEffect.burned)
                health -= 5;
            else if (status == StatusEffect.cursed)
                health = (int)Math.Ceiling((4f / 5f) * health);

            if (health <= 0)
                alive = false;
        }
Example #26
0
        public override void Deserialize( GenericReader reader )
        {
            base.Deserialize( reader );

            int version = reader.ReadInt();

            switch ( version )
            {
                case 9:
                    {
                        m_IDList = reader.ReadStrongMobileList();
                        goto case 5;
                    }
                case 8:
                case 7:
                case 6:
                case 5:
                {
                    m_WeaponEffect = (WeaponEffect)reader.ReadEncodedInt();
                    m_Charges = reader.ReadInt();

                    SaveFlag flags = (SaveFlag)reader.ReadInt();

                    if ( GetSaveFlag( flags, SaveFlag.DamageLevel ) )
                    {
                        m_DamageLevel = (WeaponDamageLevel)reader.ReadInt();

                        if ( m_DamageLevel > WeaponDamageLevel.Vanq )
                            m_DamageLevel = WeaponDamageLevel.Ruin;
                    }

                    if ( GetSaveFlag( flags, SaveFlag.AccuracyLevel ) )
                    {
                        m_AccuracyLevel = (WeaponAccuracyLevel)reader.ReadInt();

                        if ( m_AccuracyLevel > WeaponAccuracyLevel.Supremely )
                            m_AccuracyLevel = WeaponAccuracyLevel.Accurate;
                    }

                    if ( GetSaveFlag( flags, SaveFlag.DurabilityLevel ) )
                    {
                        m_DurabilityLevel = (WeaponDurabilityLevel)reader.ReadInt();

                        if ( m_DurabilityLevel > WeaponDurabilityLevel.Indestructible )
                            m_DurabilityLevel = WeaponDurabilityLevel.Durable;
                    }

                    if ( GetSaveFlag( flags, SaveFlag.Quality ) )
                        m_Quality = (WeaponQuality)reader.ReadInt();
                    else
                        m_Quality = WeaponQuality.Regular;

                    if ( GetSaveFlag( flags, SaveFlag.Hits ) )
                        m_Hits = reader.ReadInt();

                    if ( GetSaveFlag( flags, SaveFlag.MaxHits ) )
                        m_MaxHits = reader.ReadInt();

                    if ( GetSaveFlag( flags, SaveFlag.Slayer ) )
                        m_Slayer = (SlayerName)reader.ReadInt();

                    if ( GetSaveFlag( flags, SaveFlag.Poison ) )
                        m_Poison = Poison.Deserialize( reader );

                    if ( GetSaveFlag( flags, SaveFlag.PoisonCharges ) )
                        m_PoisonCharges = reader.ReadInt();

                    if ( GetSaveFlag( flags, SaveFlag.Crafter ) )
                        m_Crafter = reader.ReadMobile();

                    if ( GetSaveFlag( flags, SaveFlag.Identified ) )
                        m_Identified = ( version >= 6 || reader.ReadBool() );

                    if ( GetSaveFlag( flags, SaveFlag.StrReq ) )
                        m_StrReq = reader.ReadInt();
                    else
                        m_StrReq = -1;

                    if ( GetSaveFlag( flags, SaveFlag.DexReq ) )
                        m_DexReq = reader.ReadInt();
                    else
                        m_DexReq = -1;

                    if ( GetSaveFlag( flags, SaveFlag.IntReq ) )
                        m_IntReq = reader.ReadInt();
                    else
                        m_IntReq = -1;

                    if ( GetSaveFlag( flags, SaveFlag.MinDamage ) )
                        m_MinDamage = reader.ReadInt();
                    else
                        m_MinDamage = -1;

                    if ( GetSaveFlag( flags, SaveFlag.MaxDamage ) )
                        m_MaxDamage = reader.ReadInt();
                    else
                        m_MaxDamage = -1;

                    if ( GetSaveFlag( flags, SaveFlag.HitSound ) )
                        m_HitSound = reader.ReadInt();
                    else
                        m_HitSound = -1;

                    if ( GetSaveFlag( flags, SaveFlag.MissSound ) )
                        m_MissSound = reader.ReadInt();
                    else
                        m_MissSound = -1;

                    if ( GetSaveFlag( flags, SaveFlag.Speed ) )
                    {
                        if ( version < 9 )
                            m_Speed = reader.ReadInt();
                        else
                            m_Speed = reader.ReadInt();
                    }
                    else
                        m_Speed = -1;

                    if ( GetSaveFlag( flags, SaveFlag.MaxRange ) )
                        m_MaxRange = reader.ReadInt();
                    else
                        m_MaxRange = -1;

                    if ( GetSaveFlag( flags, SaveFlag.Skill ) )
                        m_Skill = (SkillName)reader.ReadInt();
                    else
                        m_Skill = (SkillName)(-1);

                    if ( GetSaveFlag( flags, SaveFlag.Type ) )
                        m_Type = (WeaponType)reader.ReadInt();
                    else
                        m_Type = (WeaponType)(-1);

                    if ( GetSaveFlag( flags, SaveFlag.Animation ) )
                        m_Animation = (WeaponAnimation)reader.ReadInt();
                    else
                        m_Animation = (WeaponAnimation)(-1);

                    if ( GetSaveFlag( flags, SaveFlag.Resource ) )
                        m_Resource = (CraftResource)reader.ReadInt();
                    else
                        m_Resource = CraftResource.Iron;

                    if ( GetSaveFlag( flags, SaveFlag.xAttributes ) )
                        m_AosAttributes = new AosAttributes( this, reader );
                    else
                        m_AosAttributes = new AosAttributes( this );

                    if ( GetSaveFlag( flags, SaveFlag.xWeaponAttributes ) )
                        m_AosWeaponAttributes = new AosWeaponAttributes( this, reader );
                    else
                        m_AosWeaponAttributes = new AosWeaponAttributes( this );

                    if ( UseSkillMod && m_AccuracyLevel != WeaponAccuracyLevel.Regular && Parent is Mobile )
                    {
                        m_SkillMod = new DefaultSkillMod( AccuracySkill, true, (int)m_AccuracyLevel * 5 );
                        ((Mobile)Parent).AddSkillMod( m_SkillMod );
                    }

                    if ( version < 7 && m_AosWeaponAttributes.MageWeapon != 0 )
                        m_AosWeaponAttributes.MageWeapon = 30 - m_AosWeaponAttributes.MageWeapon;

                    if ( Core.AOS && m_AosWeaponAttributes.MageWeapon != 0 && m_AosWeaponAttributes.MageWeapon != 30 && Parent is Mobile )
                    {
                        m_MageMod = new DefaultSkillMod( SkillName.Magery, true, -30 + m_AosWeaponAttributes.MageWeapon );
                        ((Mobile)Parent).AddSkillMod( m_MageMod );
                    }

                    if ( GetSaveFlag( flags, SaveFlag.PlayerConstructed ) )
                        m_PlayerConstructed = true;

                    if( GetSaveFlag( flags, SaveFlag.SkillBonuses ) )
                        m_AosSkillBonuses = new AosSkillBonuses( this, reader );
                    else
                        m_AosSkillBonuses = new AosSkillBonuses( this );

                    if( GetSaveFlag( flags, SaveFlag.Slayer2 ) )
                        m_Slayer2 = (SlayerName)reader.ReadInt();

                    if( GetSaveFlag( flags, SaveFlag.ElementalDamages ) )
                        m_AosElementDamages = new AosElementAttributes( this, reader );
                    else
                        m_AosElementDamages = new AosElementAttributes( this );

                    if( GetSaveFlag( flags, SaveFlag.EngravedText ) )
                        m_EngravedText = reader.ReadString();

                    break;
                }
                case 4:
                {
                    m_Slayer = (SlayerName)reader.ReadInt();

                    goto case 3;
                }
                case 3:
                {
                    m_StrReq = reader.ReadInt();
                    m_DexReq = reader.ReadInt();
                    m_IntReq = reader.ReadInt();

                    goto case 2;
                }
                case 2:
                {
                    m_Identified = reader.ReadBool();

                    goto case 1;
                }
                case 1:
                {
                    m_MaxRange = reader.ReadInt();

                    goto case 0;
                }
                case 0:
                {
                    if ( version == 0 )
                        m_MaxRange = 1; // default

                    if ( version < 5 )
                    {
                        m_Resource = CraftResource.Iron;
                        m_AosAttributes = new AosAttributes( this );
                        m_AosWeaponAttributes = new AosWeaponAttributes( this );
                        m_AosElementDamages = new AosElementAttributes( this );
                        m_AosSkillBonuses = new AosSkillBonuses( this );
                    }

                    m_MinDamage = reader.ReadInt();
                    m_MaxDamage = reader.ReadInt();

                    m_Speed = reader.ReadInt();

                    m_HitSound = reader.ReadInt();
                    m_MissSound = reader.ReadInt();

                    m_Skill = (SkillName)reader.ReadInt();
                    m_Type = (WeaponType)reader.ReadInt();
                    m_Animation = (WeaponAnimation)reader.ReadInt();
                    m_DamageLevel = (WeaponDamageLevel)reader.ReadInt();
                    m_AccuracyLevel = (WeaponAccuracyLevel)reader.ReadInt();
                    m_DurabilityLevel = (WeaponDurabilityLevel)reader.ReadInt();
                    m_Quality = (WeaponQuality)reader.ReadInt();

                    m_Crafter = reader.ReadMobile();

                    m_Poison = Poison.Deserialize( reader );
                    m_PoisonCharges = reader.ReadInt();

                    if ( m_StrReq == OldStrengthReq )
                        m_StrReq = -1;

                    if ( m_DexReq == OldDexterityReq )
                        m_DexReq = -1;

                    if ( m_IntReq == OldIntelligenceReq )
                        m_IntReq = -1;

                    if ( m_MinDamage == OldMinDamage )
                        m_MinDamage = -1;

                    if ( m_MaxDamage == OldMaxDamage )
                        m_MaxDamage = -1;

                    if ( m_HitSound == OldHitSound )
                        m_HitSound = -1;

                    if ( m_MissSound == OldMissSound )
                        m_MissSound = -1;

                    if ( m_Speed == OldSpeed )
                        m_Speed = -1;

                    if ( m_MaxRange == OldMaxRange )
                        m_MaxRange = -1;

                    if ( m_Skill == OldSkill )
                        m_Skill = (SkillName)(-1);

                    if ( m_Type == OldType )
                        m_Type = (WeaponType)(-1);

                    if ( m_Animation == OldAnimation )
                        m_Animation = (WeaponAnimation)(-1);

                    if ( UseSkillMod && m_AccuracyLevel != WeaponAccuracyLevel.Regular && Parent is Mobile )
                    {
                        m_SkillMod = new DefaultSkillMod( AccuracySkill, true, (int)m_AccuracyLevel * 5);
                        ((Mobile)Parent).AddSkillMod( m_SkillMod );
                    }

                    break;
                }
            }

            if ( Core.AOS && Parent is Mobile )
                m_AosSkillBonuses.AddTo( (Mobile)Parent );

            int strBonus = m_AosAttributes.BonusStr;
            int dexBonus = m_AosAttributes.BonusDex;
            int intBonus = m_AosAttributes.BonusInt;

            if ( this.Parent is Mobile && (strBonus != 0 || dexBonus != 0 || intBonus != 0) )
            {
                Mobile m = (Mobile)this.Parent;

                string modName = this.Serial.ToString();

                if ( strBonus != 0 )
                    m.AddStatMod( new StatMod( StatType.Str, modName + "Str", strBonus, TimeSpan.Zero ) );

                if ( dexBonus != 0 )
                    m.AddStatMod( new StatMod( StatType.Dex, modName + "Dex", dexBonus, TimeSpan.Zero ) );

                if ( intBonus != 0 )
                    m.AddStatMod( new StatMod( StatType.Int, modName + "Int", intBonus, TimeSpan.Zero ) );
            }

            if ( Parent is Mobile )
                ((Mobile)Parent).CheckStatTimers();

            if ( m_Hits <= 0 && m_MaxHits <= 0 )
            {
                m_Hits = m_MaxHits = Utility.RandomMinMax( InitMinHits, InitMaxHits );
            }

            if ( version < 6 )
                m_PlayerConstructed = true; // we don't know, so, assume it's crafted
        }
Example #27
0
        public static bool Prefix(WeaponEffect __instance)
        {
            CustomAmmoCategoriesLog.Log.LogWrite("WeaponEffect.PlayProjectile");
            try {
                //__instance.t = 0.0f;
                typeof(WeaponEffect).GetField("t", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(__instance, 0.0f);
                __instance.currentState = WeaponEffect.WeaponEffectState.Firing;
                GameObject projectileMeshObject = (GameObject)typeof(WeaponEffect).GetField("projectileMeshObject", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance);
                if ((UnityEngine.Object)projectileMeshObject != (UnityEngine.Object)null)
                {
                    projectileMeshObject.SetActive(true);
                }
                GameObject projectileLightObject = (GameObject)typeof(WeaponEffect).GetField("projectileLightObject", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance);
                if ((UnityEngine.Object)projectileLightObject != (UnityEngine.Object)null)
                {
                    projectileLightObject.SetActive(true);
                }
                ParticleSystem projectileParticles = (ParticleSystem)typeof(WeaponEffect).GetField("projectileParticles", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance);
                if ((UnityEngine.Object)projectileParticles != (UnityEngine.Object)null)
                {
                    projectileParticles.Stop(true);
                    projectileParticles.Clear(true);
                }
                Transform projectileTransform = (Transform)typeof(WeaponEffect).GetField("projectileTransform", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance);
                Transform startingTransform   = (Transform)typeof(WeaponEffect).GetField("startingTransform", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance);
                projectileTransform.position = startingTransform.position;
                Vector3 endPos = (Vector3)typeof(WeaponEffect).GetField("endPos", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance);
                projectileTransform.LookAt(endPos);
                typeof(WeaponEffect).GetField("startPos", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(__instance, startingTransform.position);
                //__instance.startPos = __instance.startingTransform.position;
                if ((UnityEngine.Object)projectileParticles != (UnityEngine.Object)null)
                {
                    BTCustomRenderer.SetVFXMultiplier(projectileParticles);
                    projectileParticles.Play(true);
                    BTLightAnimator componentInChildren = projectileParticles.GetComponentInChildren <BTLightAnimator>(true);
                    if ((UnityEngine.Object)componentInChildren != (UnityEngine.Object)null)
                    {
                        componentInChildren.StopAnimation();
                        componentInChildren.PlayAnimation();
                    }
                }
                if ((UnityEngine.Object)__instance.weapon.parent.GameRep != (UnityEngine.Object)null)
                {
                    int num;
                    switch ((ChassisLocations)__instance.weapon.Location)
                    {
                    case ChassisLocations.LeftArm:
                        num = 1;
                        break;

                    case ChassisLocations.RightArm:
                        num = 2;
                        break;

                    default:
                        num = 0;
                        break;
                    }
                    __instance.weapon.parent.GameRep.PlayFireAnim((AttackSourceLimb)num, CustomAmmoCategories.getWeaponAttackRecoil(__instance.weapon));
                }
                int hitIndex = (int)typeof(WeaponEffect).GetField("hitIndex", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance);
                if (!__instance.AllowMissSkipping || __instance.hitInfo.hitLocations[hitIndex] != 0 && __instance.hitInfo.hitLocations[hitIndex] != 65536)
                {
                    return(false);
                }
                __instance.PublishWeaponCompleteMessage();
            } catch (Exception e) {
                CustomAmmoCategoriesLog.Log.LogWrite("Exception " + e.ToString() + "\nFallback to default\n");
                return(true);
            }
            return(false);
        }
Example #28
0
 public void SetWeaponEffect(WeaponEffect e)
 {
     this.weaponEffect = e;
 }
Example #29
0
        public BaseWeapon( int itemID )
            : base(itemID)
        {
            Layer = (Layer)ItemData.Quality;

            m_Quality = WeaponQuality.Regular;
            m_StrReq = -1;
            m_DexReq = -1;
            m_IntReq = -1;
            m_MinDamage = -1;
            m_MaxDamage = -1;
            m_HitSound = -1;
            m_MissSound = -1;
            m_Speed = -1;
            m_MaxRange = -1;
            m_Skill = (SkillName)(-1);
            m_Type = (WeaponType)(-1);
            m_Animation = (WeaponAnimation)(-1);
            m_Charges = 0;
            m_WeaponEffect = WeaponEffect.None;
            m_IDList = new List<Mobile>();

            m_Hits = m_MaxHits = Utility.RandomMinMax( InitMinHits, InitMaxHits );

            m_Resource = CraftResource.Iron;

            m_AosAttributes = new AosAttributes( this );
            m_AosWeaponAttributes = new AosWeaponAttributes( this );
            m_AosSkillBonuses = new AosSkillBonuses( this );
            m_AosElementDamages = new AosElementAttributes( this );
        }
Example #30
0
 public void UnregisterWeaponEffect(WeaponEffect weaponEffect)
 {
     WeaponEffectsToRemove.Add(weaponEffect);
 }
Example #31
0
 public void AdWeaponEffects(EffectEnum a, WeaponEffect b)
 {
     this.myWeaponStats.Add(a, b);;
 }
Example #32
0
 /// <summary>
 /// REmoves the given effect from the given Weapon.
 /// </summary>
 /// <param name="weapon">Weapon struct</param>
 /// <param name="effect">The WeaponEffecft to remove.</param>
 public void RemoveEffect(Weapon weapon, WeaponEffect effect)
 {
     weapon.Effect &= ~effect;
 }
Example #33
0
        private void ParseStats(Jet stats)
        {
            if (WeaponEffect.Contains(stats.Header))
            {
                return;
            }

            // Checking stats Header (Element)
            switch (stats.Header)
            {
            // Positive basic effects

            case Effect.AddAgilite:
                Agility.Items += stats.MinValue;
                break;

            case Effect.AddChance:
                Chance.Items += stats.MinValue;
                break;

            case Effect.AddForce:
                Strength.Items += stats.MinValue;
                break;

            case Effect.AddIntelligence:
                Intelligence.Items += stats.MinValue;
                break;

            case Effect.AddVitalite:
                Vitality.Items += stats.MinValue;
                break;

            case Effect.AddSagesse:
                Wisdom.Items += stats.MinValue;
                break;

            case Effect.AddLife:
                PdvNow.Items += stats.MinValue;
                break;

            case Effect.AddPa:
                Pa.Items += stats.MinValue;
                break;

            case Effect.AddPm:
                Pm.Items += stats.MinValue;
                break;

            case Effect.AddPo:
                Po.Items += stats.MinValue;
                break;

            case Effect.AddInvocationMax:
                MaxInvoc.Items += stats.MinValue;
                break;

            case Effect.AddInitiative:
                Initiative.Items += stats.MinValue;
                break;

            case Effect.AddProspection:
                Prospection.Items += stats.MinValue;
                break;

            case Effect.AddPods:
                Weight.Items += stats.MinValue;
                break;

            // Negative basic effects

            case Effect.SubAgilite:
                Agility.Items -= stats.MinValue;
                break;

            case Effect.SubChance:
                Chance.Items -= stats.MinValue;
                break;

            case Effect.SubForce:
                Strength.Items -= stats.MinValue;
                break;

            case Effect.SubIntelligence:
                Intelligence.Items -= stats.MinValue;
                break;

            case Effect.SubVitalite:
                Vitality.Items -= stats.MinValue;
                break;

            case Effect.SubSagesse:
                Wisdom.Items -= stats.MinValue;
                break;

            case Effect.SubPa:
                Pa.Items -= stats.MinValue;
                break;

            case Effect.SubPm:
                Pm.Items -= stats.MinValue;
                break;

            case Effect.SubPo:
                Po.Items -= stats.MinValue;
                break;

            case Effect.SubInitiative:
                Initiative.Items -= stats.MinValue;
                break;

            case Effect.SubProspection:
                Prospection.Items -= stats.MinValue;
                break;

            case Effect.SubPods:
                Weight.Items -= stats.MinValue;
                break;

            // Positive Reduc damage effects

            case Effect.AddReduceDamageAir:
                ReducDamageAir.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamageEau:
                ReduceDamageChance.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamageFeu:
                ReduceDamageIntelligence.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamageTerre:
                ReduceDamageStrength.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamageNeutre:
                ReduceDamageNeutral.Items += stats.MinValue;
                break;

            // Positive Reduc damage Pvp effects

            case Effect.AddReduceDamagePvPAir:
                ReducDamagePvpAir.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamagePvPEau:
                ReduceDamagePvpChance.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamagePvPFeu:
                ReduceDamagePvpIntelligence.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamagePvPTerre:
                ReduceDamagePvpStrength.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamagePvPNeutre:
                ReduceDamagePvpNeutral.Items += stats.MinValue;
                break;

            // Positive Reduc percent damage effects

            case Effect.AddReduceDamagePourcentAir:
                ReduceDamagePercentAir.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamagePourcentEau:
                ReduceDamagePercentChance.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamagePourcentFeu:
                ReduceDamagePercentIntelligence.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamagePourcentTerre:
                ReduceDamagePercentStrenght.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamagePourcentNeutre:
                ReduceDamagePercentNeutral.Items += stats.MinValue;
                break;

            // Positive Reduc percent damage Pvp effects

            case Effect.AddReduceDamagePourcentPvPAir:
                ReduceDamagePercentPvPAir.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamagePourcentPvPEau:
                ReduceDamagePercentPvPChance.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamagePourcentPvPFeu:
                ReduceDamagePercentPvPIntelligence.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamagePourcentPvPTerre:
                ReduceDamagePercentPvPStrenght.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamagePourcentPvpNeutre:
                ReduceDamagePercentPvPNeutral.Items += stats.MinValue;
                break;

            // Positive Reduc damages Type

            case Effect.AddReduceDamagePhysic:
                ReducPhysicalDamage.Items += stats.MinValue;
                break;

            case Effect.AddReduceDamageMagic:
                ReducMagicDamage.Items += stats.MinValue;
                break;

            // Positive Dodge Pa Pm

            case Effect.AddEsquivePa:
                DodgePa.Items += stats.MinValue;
                break;

            case Effect.AddEsquivePm:
                DodgePm.Items += stats.MinValue;
                break;

            // Negative Dodge Pa Pm

            case Effect.SubEsquivePa:
                DodgePa.Items -= stats.MinValue;
                break;

            case Effect.SubEsquivePm:
                DodgePm.Items -= stats.MinValue;
                break;

            // Negative Reduc damage effects

            case Effect.SubReduceDamageAir:
                ReducDamageAir.Items -= stats.MinValue;
                break;

            case Effect.SubReduceDamageEau:
                ReduceDamageChance.Items -= stats.MinValue;
                break;

            case Effect.SubReduceDamageFeu:
                ReduceDamageIntelligence.Items -= stats.MinValue;
                break;

            case Effect.SubReduceDamageTerre:
                ReduceDamageStrength.Items -= stats.MinValue;
                break;

            case Effect.SubReduceDamageNeutre:
                ReduceDamageNeutral.Items -= stats.MinValue;
                break;

            // Negative Reduc percent damage effects

            case Effect.SubReduceDamagePourcentAir:
                ReduceDamagePercentAir.Items -= stats.MinValue;
                break;

            case Effect.SubReduceDamagePourcentEau:
                ReduceDamagePercentChance.Items -= stats.MinValue;
                break;

            case Effect.SubReduceDamagePourcentFeu:
                ReduceDamagePercentIntelligence.Items -= stats.MinValue;
                break;

            case Effect.SubReduceDamagePourcentTerre:
                ReduceDamagePercentStrenght.Items -= stats.MinValue;
                break;

            case Effect.SubReduceDamagePourcentNeutre:
                ReduceDamagePercentNeutral.Items -= stats.MinValue;
                break;

            // Negative Reduc percent damage Pvp effects

            case Effect.SubReduceDamagePourcentPvPAir:
                ReduceDamagePercentPvPAir.Items -= stats.MinValue;
                break;

            case Effect.SubReduceDamagePourcentPvPEau:
                ReduceDamagePercentPvPChance.Items -= stats.MinValue;
                break;

            case Effect.SubReduceDamagePourcentPvPFeu:
                ReduceDamagePercentPvPIntelligence.Items += stats.MinValue;
                break;

            case Effect.SubReduceDamagePourcentPvPTerre:
                ReduceDamagePercentPvPStrenght.Items -= stats.MinValue;
                break;

            case Effect.SubReduceDamagePourcentPvpNeutre:
                ReduceDamagePercentPvPNeutral.Items -= stats.MinValue;
                break;

            // Positive different types of damage

            case Effect.AddRenvoiDamage:
                ReturnDamage.Items += stats.MinValue;
                break;

            case Effect.AddDamageCritic:
                CriticalDamage.Items += stats.MinValue;
                break;

            case Effect.AddEchecCritic:
                FailDamage.Items += stats.MinValue;
                break;

            case Effect.AddDamage:
                Damage.Items += stats.MinValue;
                break;

            case Effect.AddDamagePercent:
                PercentDamage.Items += stats.MinValue;
                break;

            case Effect.AddDamagePhysic:
                PhysicalDamage.Items += stats.MinValue;
                break;

            case Effect.AddDamageMagic:
                MagicDamage.Items += stats.MinValue;
                break;

            case Effect.AddDamagePiege:
                TrapDamage.Items += stats.MinValue;
                break;

            case Effect.AddDamagePiegePercent:
                TrapPercentDamage.Items += stats.MinValue;
                break;

            case Effect.AddSoins:
                Heal.Items += stats.MinValue;
                break;

            // Negative different types of damage

            case Effect.SubDamageCritic:
                CriticalDamage.Items -= stats.MinValue;
                break;

            case Effect.SubDamage:
                Damage.Items -= stats.MinValue;
                break;

            case Effect.SubDamagePhysic:
                PhysicalDamage.Items -= stats.MinValue;
                break;

            case Effect.SubDamageMagic:
                MagicDamage.Items -= stats.MinValue;
                break;

            case Effect.SubSoins:
                Heal.Items -= stats.MinValue;
                break;
            }
        }
Example #34
0
 public bool HasEffect(uint id, WeaponEffect effect)
 {
     return(HasEffect(this[id], effect));
 }
Example #35
0
 /// <summary>
 /// Adds the given effect to the given Weapon.
 /// </summary>
 /// <param name="weapon">Weapon struct</param>
 /// <param name="effect">The WeaponEffect to add.</param>
 public void SetEffect(Weapon weapon, WeaponEffect effect)
 {
     weapon.Effect |= effect;
 }
Example #36
0
 public void SetEffect(uint id, WeaponEffect effect)
 {
     SetEffect(this[id], effect);
 }
 private void OnCastEffect()
 {
     // If we have an effect start it now
     if (this.Effect != null)
     {
         this.activeEffect = WeaponEffect.Create(this.Effect, this.EffectPoint);
     }
 }
Example #38
0
 /// <summary>
 /// Returns true if the weapon has the given effect set.
 /// </summary>
 /// <param name="weapon">Weapon struct</param>
 /// <param name="effect">The WeaponEffect to check</param>
 /// <returns>True or false.</returns>
 public bool HasEffect(Weapon weapon, WeaponEffect effect)
 {
     return((weapon.Effect & effect) != WeaponEffect.None);
 }