Inheritance: EffectDirect
Exemplo n.º 1
0
        public EffectBase DeserializeEffect(byte[] buffer, ref int index)
        {
            if (buffer.Length < index)
            {
                throw new System.Exception("buffer too small to contain an Effect");
            }
            byte       b = buffer[index];
            EffectBase effectBase;

            switch (b)
            {
            case 1:
                effectBase = new EffectBase();
                break;

            case 2:
                effectBase = new EffectCreature();
                break;

            case 3:
                effectBase = new EffectDate();
                break;

            case 4:
                effectBase = new EffectDice();
                break;

            case 5:
                effectBase = new EffectDuration();
                break;

            case 6:
                effectBase = new EffectInteger();
                break;

            case 7:
                effectBase = new EffectLadder();
                break;

            case 8:
                effectBase = new EffectMinMax();
                break;

            case 9:
                effectBase = new EffectMount();
                break;

            case 10:
                effectBase = new EffectString();
                break;

            default:
                throw new System.Exception(string.Format("Incorrect identifier : {0}", b));
            }
            index++;
            effectBase.DeSerialize(buffer, ref index);
            return(effectBase);
        }
Exemplo n.º 2
0
 private void OnFightEnded(Character character, CharacterFighter fighter)
 {
     BasePlayerItem[] items = this.GetItems(CharacterInventoryPositionEnum.INVENTORY_POSITION_BOOST_FOOD);
     for (int i = 0; i < items.Length; i++)
     {
         BasePlayerItem basePlayerItem = items[i];
         EffectMinMax   effectMinMax   = basePlayerItem.Effects.OfType <EffectMinMax>().FirstOrDefault((EffectMinMax x) => x.EffectId == EffectsEnum.Effect_RemainingFights);
         if (!(effectMinMax == null))
         {
             EffectMinMax expr_4C = effectMinMax;
             expr_4C.ValueMax -= 1;
             if (effectMinMax.ValueMax <= 0)
             {
                 this.RemoveItem(basePlayerItem, true);
             }
             else
             {
                 this.RefreshItem(basePlayerItem);
             }
         }
     }
 }
Exemplo n.º 3
0
        public override uint UseItem(int amount = 1, Cell targetCell = null, Character target = null)
        {
            var weapon = Owner.Inventory.TryGetItem(CharacterInventoryPositionEnum.ACCESSORY_POSITION_WEAPON);

            if (weapon == null || weapon.Effects.All(x => x.EffectId != EffectsEnum.Effect_DamageNeutral))
            {
                Owner.SendServerMessage("Vous devez vous équipper d'une arme de dégats neutre pour la forgemager");
                return(0);
            }

            var tuple = m_potions.FirstOrDefault(x => x.Item2.Contains(Template.Id));

            if (tuple == null)
            {
                return(1);
            }

            var boost  = m_potionsBoosts[Array.IndexOf(tuple.Item2, Template.Id)];
            var effect = weapon.Effects.FirstOrDefault(x => x.EffectId == EffectsEnum.Effect_DamageNeutral);

            weapon.Effects.Remove(effect);

            if (effect is EffectDice effectDice)
            {
                var newEffect = new EffectDice(effectDice)
                {
                    EffectId = tuple.Item1
                };
                newEffect.DiceFace = (short)(newEffect.DiceFace * boost);
                newEffect.DiceNum  = (short)Math.Ceiling((newEffect.DiceNum * boost));

                weapon.Effects.Add(newEffect);
            }
            else
            {
                if (effect is EffectInteger effectInteger)
                {
                    var newEffect = new EffectInteger(effectInteger)
                    {
                        EffectId = tuple.Item1
                    };
                    newEffect.Value = (short)(newEffect.Value * boost);

                    weapon.Effects.Add(newEffect);
                }
                else
                {
                    if (effect is EffectMinMax effectMinMax)
                    {
                        var newEffect = new EffectMinMax(effectMinMax)
                        {
                            EffectId = tuple.Item1
                        };
                        newEffect.ValueMin = (short)(newEffect.ValueMin * boost);
                        newEffect.ValueMax = (short)(newEffect.ValueMax * boost);

                        weapon.Effects.Add(newEffect);
                    }
                }
            }

            weapon.Invalidate();
            Owner.Inventory.RefreshItem(weapon);
            weapon.OnObjectModified();

            return(1);
        }
Exemplo n.º 4
0
        public EffectBase ConvertExportedEffect(EffectInstance effect)
        {
            EffectBase result;

            if (effect is EffectInstanceLadder)
            {
                result = new EffectLadder(effect as EffectInstanceLadder);
            }
            else
            {
                if (effect is EffectInstanceCreature)
                {
                    result = new EffectCreature(effect as EffectInstanceCreature);
                }
                else
                {
                    if (effect is EffectInstanceDate)
                    {
                        result = new EffectDate(effect as EffectInstanceDate);
                    }
                    else
                    {
                        if (effect is EffectInstanceDice)
                        {
                            result = new EffectDice(effect as EffectInstanceDice);
                        }
                        else
                        {
                            if (effect is EffectInstanceDuration)
                            {
                                result = new EffectDuration(effect as EffectInstanceDuration);
                            }
                            else
                            {
                                if (effect is EffectInstanceMinMax)
                                {
                                    result = new EffectMinMax(effect as EffectInstanceMinMax);
                                }
                                else
                                {
                                    if (effect is EffectInstanceMount)
                                    {
                                        result = new EffectMount(effect as EffectInstanceMount);
                                    }
                                    else
                                    {
                                        if (effect is EffectInstanceString)
                                        {
                                            result = new EffectString(effect as EffectInstanceString);
                                        }
                                        else
                                        {
                                            if (effect is EffectInstanceInteger)
                                            {
                                                result = new EffectInteger(effect as EffectInstanceInteger);
                                            }
                                            else
                                            {
                                                result = new EffectBase(effect);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return(result);
        }