Panther

Initiate
Hi All,

I am currently trying to convert and old RunUO Evo Dragon script to work on ServUO

I am getting this error

Code:
Errors:
+ Custom/Evo Dragon/EvolutionDragon.cs:
    CS0508: Line 164: 'EvolutionDragon.Damage(int, Mobile)': return type must be 'int' to match overridden member 'BaseCreature.Damage(int, Mobile)'
Scripts: One or more scripts failed to compile or no script files were found.

Specific Line having issues with, whole script below

C#:
        public override void Damage( int amount, Mobile Defender )
        {

Script that I am working on
EvolutionDragon.cs:
//////////////////////////////////////////////////$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
////==========================================////$                                 $
////        Upgraded By: Triple               ////$   Will like to thank for all    $
////==========================================////$   who help me with this upgrade!$
//////////////////////////////////////////////////$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$

using System;
using System.Collections;
using Server.Mobiles;
using Server.Items;
using Server.Network;
using Server.Targeting;
using Server.Gumps;

namespace Server.Mobiles
{
    [CorpseName( "a dragon hatchling corpse" )]
    public class EvolutionDragon : BaseCreature
    {
        private Timer m_BreatheTimer;
        private DateTime m_EndBreathe;
        private Timer m_MatingTimer;
        private DateTime m_EndMating;

        private Timer m_PetLoyaltyTimer;
        private DateTime m_EndPetLoyalty;

        public DateTime EndMating{ get{ return m_EndMating; } set{ m_EndMating = value; } }

        public DateTime EndPetLoyalty{ get{ return m_EndPetLoyalty; } set{ m_EndPetLoyalty = value; } }

        public int m_Stage;
        public int m_KP;
        public bool m_AllowMating;
        public bool m_HasEgg;
        public bool m_Pregnant;

        public bool m_S1;
        public bool m_S2;
        public bool m_S3;
        public bool m_S4;
        public bool m_S5;
        public bool m_S6;

        public bool S1
        {
            get{ return m_S1; }
            set{ m_S1 = value; }
        }
        public bool S2
        {
            get{ return m_S2; }
            set{ m_S2 = value; }
        }
        public bool S3
        {
            get{ return m_S3; }
            set{ m_S3 = value; }
        }
        public bool S4
        {
            get{ return m_S4; }
            set{ m_S4 = value; }
        }
        public bool S5
        {
            get{ return m_S5; }
            set{ m_S5 = value; }
        }
        public bool S6
        {
            get{ return m_S6; }
            set{ m_S6 = value; }
        }

        [CommandProperty( AccessLevel.GameMaster )]
        public bool AllowMating
        {
            get{ return m_AllowMating; }
            set{ m_AllowMating = value; }
        }

        [CommandProperty( AccessLevel.GameMaster )]
        public bool HasEgg
        {
            get{ return m_HasEgg; }
            set{ m_HasEgg = value; }
        }
        [CommandProperty( AccessLevel.GameMaster )]
        public bool Pregnant
        {
            get{ return m_Pregnant; }
            set{ m_Pregnant = value; }
        }

        [CommandProperty( AccessLevel.GameMaster )]
        public int KP
        {
            get{ return m_KP; }
            set{ m_KP = value; }
        }

        [CommandProperty( AccessLevel.GameMaster )]
        public int Stage
        {
            get{ return m_Stage; }
            set{ m_Stage = value; }
        }

        [Constructable]
        public EvolutionDragon() : base( AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4 )
        {
            Female = Utility.RandomBool();
            Name = "a dragon hatchling";
            Body = 52;
            Hue = Utility.RandomList( 1157, 1175, 1172, 1171, 1170, 1169, 1168, 1167, 1166, 1165 );
            BaseSoundID = 0xDB;
            Stage = 1;

            S1 = true;
            S2 = true;
            S3 = true;
            S4 = true;
            S5 = true;
            S6 = true;

            SetStr( 296, 325 );
            SetDex( 56, 75 );
            SetInt( 76, 96 );

            SetHits( 200, 250 );

            SetDamage( 11, 17 );

            SetDamageType( ResistanceType.Physical, 100 );

            SetResistance( ResistanceType.Physical, 15 );

            SetSkill( SkillName.Magery, 50.1, 70.0 );
            SetSkill( SkillName.Meditation, 50.1, 70.0 );
            SetSkill( SkillName.EvalInt, 50.1, 70.0 );
            SetSkill( SkillName.MagicResist, 15.1, 20.0 );
            SetSkill( SkillName.Tactics, 19.3, 34.0 );
            SetSkill( SkillName.Wrestling, 19.3, 34.0 );
            SetSkill( SkillName.Anatomy, 19.3, 34.0 );

            Fame = 300;
            Karma = -300;

            VirtualArmor = 30;

            ControlSlots = 2;


            m_PetLoyaltyTimer = new PetLoyaltyTimer( this, TimeSpan.FromSeconds( 5.0 ) );
            m_PetLoyaltyTimer.Start();
            m_EndPetLoyalty = DateTime.Now + TimeSpan.FromSeconds( 5.0 );
        }

        public EvolutionDragon(Serial serial) : base(serial)
        {
        }

        public override void Damage( int amount, Mobile Defender )
        {
            int kpgainmin, kpgainmax;

            if ( this.Stage == 1 )
            {
                if ( defender is BaseCreature )
                {
                    BaseCreature bc = (BaseCreature)defender;

                    if ( bc.Controlled != true )
                    {
                        kpgainmin = 5 + ( bc.HitsMax ) / 10;
                        kpgainmax = 5 + ( bc.HitsMax ) / 5;

                        this.KP += Utility.RandomList( kpgainmin, kpgainmax );
                    }
                }

                if ( this.KP >= 25000 )
                {
                    if ( this.S1 == true )
                    {
                        this.S1 = false;
                        int hits, va, mindamage, maxdamage;

                        hits = ( this.HitsMax + 500 );

                        va = ( this.VirtualArmor + 10 );

                        mindamage = this.DamageMin + ( 1 );
                        maxdamage = this.DamageMax + ( 1 );

                        this.Warmode = false;
                        this.Say( "*"+ this.Name +" evolves*");
                        this.SetDamage( mindamage, maxdamage );
                        this.SetHits( hits );
                        this.BodyValue = 89;
                        this.BaseSoundID = 219;
                        this.VirtualArmor = va;
                        this.Stage = 2;

                        this.SetDamageType( ResistanceType.Physical, 100 );
                        this.SetDamageType( ResistanceType.Fire, 25 );
                        this.SetDamageType( ResistanceType.Cold, 25 );
                        this.SetDamageType( ResistanceType.Poison, 25 );
                        this.SetDamageType( ResistanceType.Energy, 25 );

                        this.SetResistance( ResistanceType.Physical, 20 );
                        this.SetResistance( ResistanceType.Fire, 20 );
                        this.SetResistance( ResistanceType.Cold, 20 );
                        this.SetResistance( ResistanceType.Poison, 20 );
                        this.SetResistance( ResistanceType.Energy, 20 );

                        this.RawStr += 200;
                        this.RawInt += 30;
                        this.RawDex += 20;
                    }
                }
            }

            else if ( this.Stage == 2 )
            {
                if ( defender is BaseCreature )
                {
                    BaseCreature bc = (BaseCreature)defender;

                    if ( bc.Controlled != true )
                    {
                        kpgainmin = 5 + ( bc.HitsMax ) / 20;
                        kpgainmax = 5 + ( bc.HitsMax ) / 10;

                        this.KP += Utility.RandomList( kpgainmin, kpgainmax );
                    }
                }

                if ( this.KP >= 75000 )
                {
                    if ( this.S2 == true )
                    {
                        this.S2 = false;
                        int hits, va, mindamage, maxdamage;

                        hits = ( this.HitsMax + 100 );

                        va = ( this.VirtualArmor + 10 );

                        mindamage = this.DamageMin + ( 1 );
                        maxdamage = this.DamageMax + ( 1 );

                        this.Warmode = false;
                        this.Say( "*"+ this.Name +" evolves*");
                        this.SetDamage( mindamage, maxdamage );
                        this.SetHits( hits );
                        this.BodyValue = 0xCE;
                        this.BaseSoundID = 0x5A;
                        this.VirtualArmor = va;
                        this.Stage = 3;

                        this.SetDamageType( ResistanceType.Physical, 100 );
                        this.SetDamageType( ResistanceType.Fire, 25 );
                        this.SetDamageType( ResistanceType.Cold, 25 );
                        this.SetDamageType( ResistanceType.Poison, 25 );
                        this.SetDamageType( ResistanceType.Energy, 25 );

                        this.SetResistance( ResistanceType.Physical, 40 );
                        this.SetResistance( ResistanceType.Fire, 40 );
                        this.SetResistance( ResistanceType.Cold, 40 );
                        this.SetResistance( ResistanceType.Poison, 40 );
                        this.SetResistance( ResistanceType.Energy, 40 );

                        this.RawStr += 100;
                        this.RawInt += 20;
                        this.RawDex += 10;
                    }
                }
            }

            else if ( this.Stage == 3 )
            {
                if ( defender is BaseCreature )
                {
                    BaseCreature bc = (BaseCreature)defender;

                    if ( bc.Controlled != true )
                    {
                        kpgainmin = 5 + ( bc.HitsMax ) / 30;
                        kpgainmax = 5 + ( bc.HitsMax ) / 20;

                        this.KP += Utility.RandomList( kpgainmin, kpgainmax );
                    }
                }

                if ( this.KP >= 175000 )
                {
                    if ( this.S3 == true )
                    {
                        this.S3 = false;
                        int hits, va, mindamage, maxdamage;

                        hits = ( this.HitsMax + 100 );

                        va = ( this.VirtualArmor + 10 );

                        mindamage = this.DamageMin + ( 1 );
                        maxdamage = this.DamageMax + ( 1 );

                        this.Warmode = false;
                        this.Say( "*"+ this.Name +" evolves*");
                        this.SetDamage( mindamage, maxdamage );
                        this.SetHits( hits );
                        this.BodyValue = Utility.RandomList( 60, 61 );
                        this.BaseSoundID = 362;
                        this.VirtualArmor = va;
                        this.Stage = 4;

                        this.SetResistance( ResistanceType.Physical, 60 );
                        this.SetResistance( ResistanceType.Fire, 60 );
                        this.SetResistance( ResistanceType.Cold, 60 );
                        this.SetResistance( ResistanceType.Poison, 60 );
                        this.SetResistance( ResistanceType.Energy, 60 );

                        this.RawStr += 100;
                        this.RawInt += 120;
                        this.RawDex += 10;
                    }
                }
            }

            else if ( this.Stage == 4 )
            {
                if ( defender is BaseCreature )
                {
                    BaseCreature bc = (BaseCreature)defender;

                    if ( bc.Controlled != true )
                    {
                        kpgainmin = 5 + ( bc.HitsMax ) / 50;
                        kpgainmax = 5 + ( bc.HitsMax ) / 40;

                        this.KP += Utility.RandomList( kpgainmin, kpgainmax );
                    }
                }

                if ( this.KP >= 375000 )
                {
                    if ( this.S4 == true )
                    {
                        this.S4 = false;
                        int hits, va, mindamage, maxdamage;

                        hits = ( this.HitsMax + 100 );

                        va = ( this.VirtualArmor + 10 );

                        mindamage = this.DamageMin + ( 5 );
                        maxdamage = this.DamageMax + ( 5 );

                        this.Warmode = false;
                        this.Say( "*"+ this.Name +" evolves*");
                        this.SetDamage( mindamage, maxdamage );
                        this.SetHits( hits );
                        this.BodyValue = 59;
                        this.VirtualArmor = va;
                        this.Stage = 5;

                        this.SetDamageType( ResistanceType.Physical, 100 );
                        this.SetDamageType( ResistanceType.Fire, 50 );
                        this.SetDamageType( ResistanceType.Cold, 50 );
                        this.SetDamageType( ResistanceType.Poison, 50 );
                        this.SetDamageType( ResistanceType.Energy, 50 );

                        this.SetResistance( ResistanceType.Physical, 80 );
                        this.SetResistance( ResistanceType.Fire, 80 );
                        this.SetResistance( ResistanceType.Cold, 80 );
                        this.SetResistance( ResistanceType.Poison, 80 );
                        this.SetResistance( ResistanceType.Energy, 80 );

                        this.RawStr += 100;
                        this.RawInt += 120;
                        this.RawDex += 20;
                    }
                }
            }

            else if ( this.Stage == 5 )
            {
                if ( defender is BaseCreature )
                {
                    BaseCreature bc = (BaseCreature)defender;

                    if ( bc.Controlled != true )
                    {
                        kpgainmin = 5 + ( bc.HitsMax ) / 160;
                        kpgainmax = 5 + ( bc.HitsMax ) / 100;

                        this.KP += Utility.RandomList( kpgainmin, kpgainmax );
                    }
                }

                if ( this.KP >= 775000 )
                {
                    if ( this.S5 == true )
                    {
                        this.S5 = false;
                        int hits, va, mindamage, maxdamage;

                        hits = ( this.HitsMax + 100 );

                        va = ( this.VirtualArmor + 100 );

                        mindamage = this.DamageMin + ( 5 );
                        maxdamage = this.DamageMax + ( 5 );

                        this.AllowMating = true;
                        this.Warmode = false;
                        this.Say( "*"+ this.Name +" evolves*");
                        this.SetDamage( mindamage, maxdamage );
                        this.SetHits( hits );
                        this.BodyValue = 46;
                        this.VirtualArmor = va;
                        this.Stage = 6;

                        this.SetResistance( ResistanceType.Physical, 98 );
                        this.SetResistance( ResistanceType.Fire, 98 );
                        this.SetResistance( ResistanceType.Cold, 98 );
                        this.SetResistance( ResistanceType.Poison, 98 );
                        this.SetResistance( ResistanceType.Energy, 98 );

                        this.RawStr += 100;
                        this.RawInt += 120;
                        this.RawDex += 20;
                    }
                }
            }

            else if ( this.Stage == 6 )
            {
                if ( defender is BaseCreature )
                {
                    BaseCreature bc = (BaseCreature)defender;

                    if ( bc.Controlled != true )
                    {
                        kpgainmin = 5 + ( bc.HitsMax ) / 540;
                        kpgainmax = 5 + ( bc.HitsMax ) / 480;

                        this.KP += Utility.RandomList( kpgainmin, kpgainmax );
                    }
                }

                if ( this.KP >= 1500000 )
                {
                    if ( this.S6 == true )
                    {
                        this.S6 = false;
                        int hits, va, mindamage, maxdamage;

                        hits = ( this.HitsMax + 350 );

                        va = ( this.VirtualArmor + 100 );

                        mindamage = this.DamageMin + ( 15 );
                        maxdamage = this.DamageMax + ( 15 );

                        this.Warmode = false;
                        this.Say( "*"+ this.Name +" is now an ancient dragon*");
                        this.Title = "the Ancient Dragon";
                        this.SetDamage( mindamage, maxdamage );
                        this.SetHits( hits );
                        this.BodyValue = 172;
                        this.VirtualArmor = va;
                        this.Stage = 7;

                        this.SetDamageType( ResistanceType.Physical, 100 );
                        this.SetDamageType( ResistanceType.Fire, 75 );
                        this.SetDamageType( ResistanceType.Cold, 75 );
                        this.SetDamageType( ResistanceType.Poison, 75 );
                        this.SetDamageType( ResistanceType.Energy, 75 );

                        this.RawStr += 125;
                        this.RawInt += 125;
                        this.RawDex += 35;
                    }
                }
            }

            else if ( this.Stage == 7 )
            {
                if ( defender is BaseCreature )
                {
                    BaseCreature bc = (BaseCreature)defender;

                    if ( bc.Controlled != true )
                    {
                        kpgainmin = 5 + ( bc.Hits ) / 740;
                        kpgainmax = 5 + ( bc.Hits ) / 660;

                        this.KP += Utility.RandomList( kpgainmin, kpgainmax );
                    }
                }
            }

            base.Damage( amount, defender );
        }

        public override bool OnDragDrop( Mobile from, Item dropped )
        {
            PlayerMobile player = from as PlayerMobile;

            if ( player != null )
            {
                if ( dropped is DragonDust )
                {
                    DragonDust dust = ( DragonDust )dropped;

                    int amount = ( dust.Amount * 5 );

                    this.PlaySound( 665 );
                    this.KP += amount;
                    dust.Delete();
                    this.Say( "*"+ this.Name +" absorbs the dragon dust*" );

                    return false;
                }
                else
                {
                }
            }
            return base.OnDragDrop( from, dropped );
        }


                private void MatingTarget_Callback( Mobile from, object obj )
                {
                               if ( obj is EvolutionDragon && obj is BaseCreature )
                               {
                    BaseCreature bc = (BaseCreature)obj;
                    EvolutionDragon ed = (EvolutionDragon)obj;

                    if ( ed.Controlled == true && ed.ControlMaster == from )
                    {
                        if ( ed.Female == false )
                        {
                            if ( ed.AllowMating == true )
                            {
                                this.Blessed = true;
                                this.Pregnant = true;

                                m_MatingTimer = new MatingTimer( this, TimeSpan.FromDays( 3.0 ) );
                                m_MatingTimer.Start();

                                m_EndMating = DateTime.Now + TimeSpan.FromDays( 3.0 );
                            }
                            else
                            {
                                from.SendMessage( "This male dragon is not old enough to mate!" );
                            }
                        }
                        else
                        {
                            from.SendMessage( "This dragon is not male!" );
                        }
                    }
                    else if ( ed.Controlled == true )
                    {
                        if ( ed.Female == false )
                        {
                            if ( ed.AllowMating == true )
                            {
                                if ( ed.ControlMaster != null )
                                {
                                    ed.ControlMaster.SendGump( new MatingGump( from, ed.ControlMaster, this, ed ) );
                                    from.SendMessage( "You ask the owner of the dragon if they will let your female mate with their male." );
                                }
                                               else
                                               {
                                                      from.SendMessage( "This dragon is wild." );
                                   }
                            }
                            else
                            {
                                from.SendMessage( "This male dragon is not old enough to mate!" );
                            }
                        }
                        else
                        {
                            from.SendMessage( "This dragon is not male!" );
                        }
                    }
                                   else
                                   {
                                          from.SendMessage( "This dragon is wild." );
                       }
                               }
                               else
                               {
                                      from.SendMessage( "That is not a dragon!" );
                   }
        }

        public override void OnDoubleClick( Mobile from )
        {
            if ( this.Controlled == true && this.ControlMaster == from )
            {
                if ( this.Female == true )
                {
                    if ( this.AllowMating == true )
                    {
                        if ( this.Pregnant == true )
                        {
                            if ( this.HasEgg == true )
                            {
                                this.HasEgg = false;
                                this.Pregnant = false;
                                this.Blessed = false;
                                from.AddToBackpack( new DragonEgg() );
                                from.SendMessage( "A dragon's egg has been placed in your backpack" );
                            }
                            else
                            {
                                from.SendMessage( "The dragon has not yet produced an egg." );
                            }
                        }
                        else
                        {
                            from.SendMessage( "Target a male dragon to mate with this female." );
                                            from.BeginTarget( -1, false, TargetFlags.Harmful, new TargetCallback( MatingTarget_Callback ) );
                        }
                    }
                    else
                    {
                        from.SendMessage( "This female dragon is not old enough to mate!" );
                    }  
                }
            }
        }

        private DateTime m_NextBreathe;

        public override void OnActionCombat()
        {
            Mobile combatant = Combatant;

            if ( combatant == null || combatant.Deleted || combatant.Map != Map || !InRange( combatant, 12 ) || !CanBeHarmful( combatant ) || !InLOS( combatant ) )
                return;

            if ( DateTime.Now >= m_NextBreathe )
            {
                Breathe( combatant );

                m_NextBreathe = DateTime.Now + TimeSpan.FromSeconds( 12.0 + (3.0 * Utility.RandomDouble()) ); // 12-15 seconds
            }
        }

        public void Breathe( Mobile m )
        {
            DoHarmful( m );

            m_BreatheTimer = new BreatheTimer( m, this, this, TimeSpan.FromSeconds( 1.0 ) );
            m_BreatheTimer.Start();
            m_EndBreathe = DateTime.Now + TimeSpan.FromSeconds( 1.0 );

            this.Frozen = true;

            if ( this.Stage == 1 )
            {
                this.MovingParticles( m, 0x1FA8, 1, 0, false, true, ( this.Hue - 1 ), 0, 9502, 6014, 0x11D, EffectLayer.Waist, 0 );
            }
            else if ( this.Stage == 2 )
            {
                this.MovingParticles( m, 0x1FA9, 1, 0, false, true, ( this.Hue - 1 ), 0, 9502, 6014, 0x11D, EffectLayer.Waist, 0 );
            }
            else if ( this.Stage == 3 )
            {
                this.MovingParticles( m, 0x1FAB, 1, 0, false, true, ( this.Hue - 1 ), 0, 9502, 6014, 0x11D, EffectLayer.Waist, 0 );
            }
            else if ( this.Stage == 4 )
            {
                this.MovingParticles( m, 0x1FBC, 1, 0, false, true, ( this.Hue - 1 ), 0, 9502, 6014, 0x11D, EffectLayer.Waist, 0 );
            }
            else if ( this.Stage == 5 )
            {
                this.MovingParticles( m, 0x1FBD, 1, 0, false, true, ( this.Hue - 1 ), 0, 9502, 6014, 0x11D, EffectLayer.Waist, 0 );
            }
            else if ( this.Stage == 6 )
            {
                this.MovingParticles( m, 0x1FBF, 1, 0, false, true, ( this.Hue - 1 ), 0, 9502, 6014, 0x11D, EffectLayer.Waist, 0 );
            }
            else if ( this.Stage == 7 )
            {
                this.MovingParticles( m, 0x1FBE, 1, 0, false, true, ( this.Hue - 1 ), 0, 9502, 6014, 0x11D, EffectLayer.Waist, 0 );
            }
            else
            {
               
                this.PublicOverheadMessage( MessageType.Regular, this.SpeechHue, true, "Please call a GM if you are getting this message, they will fix the breathe, thank you :)", false );
            }
        }

        private class BreatheTimer : Timer
        {
            private EvolutionDragon ed;
            private Mobile m_Mobile, m_From;

            public BreatheTimer( Mobile m, EvolutionDragon owner, Mobile from, TimeSpan duration ) : base( duration )
            {
                ed = owner;
                m_Mobile = m;
                m_From = from;
                Priority = TimerPriority.TwoFiftyMS;
            }

            protected override void OnTick()
            {
                int damagemin = ed.Hits / 20;
                int damagemax = ed.Hits / 25;
                ed.Frozen = false;

                m_Mobile.PlaySound( 0x11D );
                AOS.Damage( m_Mobile, m_From, Utility.RandomMinMax( damagemin, damagemax ), 0, 100, 0, 0, 0 );
                Stop();
            }
        }

        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);

            writer.Write((int) 1);
                        writer.Write( m_AllowMating );
                        writer.Write( m_HasEgg );
                        writer.Write( m_Pregnant );
                        writer.Write( m_S1 );
                        writer.Write( m_S2 );
                        writer.Write( m_S3 );
                        writer.Write( m_S4 );
                        writer.Write( m_S5 );
                        writer.Write( m_S6 );
            writer.Write( (int) m_KP );
            writer.Write( (int) m_Stage );
            writer.WriteDeltaTime( m_EndMating );
            writer.WriteDeltaTime( m_EndBreathe );
            writer.WriteDeltaTime( m_EndPetLoyalty );
        }

        public override void Deserialize(GenericReader reader)
        {
            base.Deserialize(reader);

            int version = reader.ReadInt();

            switch ( version )
            {
                case 1:
                {
                                m_AllowMating = reader.ReadBool();
                                m_HasEgg = reader.ReadBool();
                                m_Pregnant = reader.ReadBool();
                                m_S1 = reader.ReadBool();
                                m_S2 = reader.ReadBool();
                                m_S3 = reader.ReadBool();
                                m_S4 = reader.ReadBool();
                                m_S5 = reader.ReadBool();
                                m_S6 = reader.ReadBool();
                    m_KP = reader.ReadInt();
                    m_Stage = reader.ReadInt();

                    m_EndMating = reader.ReadDeltaTime();
                    m_MatingTimer = new MatingTimer( this, m_EndMating - DateTime.Now );
                    m_MatingTimer.Start();

                    m_EndBreathe = reader.ReadDeltaTime();
                    m_BreatheTimer = new BreatheTimer( this, this, this, m_EndBreathe - DateTime.Now );
                    m_BreatheTimer.Start();

                    m_EndPetLoyalty = reader.ReadDeltaTime();
                    m_PetLoyaltyTimer = new PetLoyaltyTimer( this, m_EndPetLoyalty - DateTime.Now );
                    m_PetLoyaltyTimer.Start();

                    break;
                }
                case 0:
                {
                    TimeSpan durationbreathe = TimeSpan.FromSeconds( 1.0 );
                    TimeSpan durationmating = TimeSpan.FromDays( 3.0 );
                    TimeSpan durationloyalty = TimeSpan.FromSeconds( 5.0 );

                    m_BreatheTimer = new BreatheTimer( this, this, this, durationbreathe );
                    m_BreatheTimer.Start();
                    m_EndBreathe = DateTime.Now + durationbreathe;

                    m_MatingTimer = new MatingTimer( this, durationmating );
                    m_MatingTimer.Start();
                    m_EndMating = DateTime.Now + durationmating;

                    m_PetLoyaltyTimer = new PetLoyaltyTimer( this, durationloyalty );
                    m_PetLoyaltyTimer.Start();
                    m_EndPetLoyalty = DateTime.Now + durationloyalty;

                    break;
                }
            }
        }
    }

    public class MatingTimer : Timer
    {
        private EvolutionDragon ed;

        public MatingTimer( EvolutionDragon owner, TimeSpan duration ) : base( duration )
        {
            Priority = TimerPriority.OneSecond;
            ed = owner;
        }

        protected override void OnTick()
        {
            ed.Blessed = false;
            ed.HasEgg = true;
            ed.Pregnant = false;
            Stop();
        }
    }
    public class PetLoyaltyTimer : Timer
    {
        private EvolutionDragon ed;

        public PetLoyaltyTimer( EvolutionDragon owner, TimeSpan duration ) : base( duration )
        {
            Priority = TimerPriority.OneSecond;
            ed = owner;
        }

        protected override void OnTick()
        {
            ed.Loyalty = 100;

            PetLoyaltyTimer lt = new PetLoyaltyTimer( ed, TimeSpan.FromSeconds( 5.0 ) );
            lt.Start();
            ed.EndPetLoyalty = DateTime.Now + TimeSpan.FromSeconds( 5.0 );

            Stop();
        }
    }
    public class MatingGump : Gump
    {
        private Mobile m_From;
        private Mobile m_Mobile;
        private EvolutionDragon m_ED1;
        private EvolutionDragon m_ED2;

        public MatingGump( Mobile from, Mobile mobile, EvolutionDragon ed1, EvolutionDragon ed2 ) : base( 25, 50 )
        {
            Closable = false;
            Dragable = false;

            m_From = from;
            m_Mobile = mobile;
            m_ED1 = ed1;
            m_ED2 = ed2;

            AddPage( 0 );

            AddBackground( 25, 10, 420, 200, 5054 );

            AddImageTiled( 33, 20, 401, 181, 2624 );
            AddAlphaRegion( 33, 20, 401, 181 );

            AddLabel( 125, 148, 1152, m_From.Name +" would like to mate "+ m_ED1.Name +" with" );
            AddLabel( 125, 158, 1152, m_ED2.Name +"." );

            AddButton( 100, 50, 4005, 4007, 1, GumpButtonType.Reply, 0 );
            AddLabel( 130, 50, 1152, "Allow them to mate." );
            AddButton( 100, 75, 4005, 4007, 0, GumpButtonType.Reply, 0 );
            AddLabel( 130, 75, 1152, "Do not allow them to mate." );
        }

        public override void OnResponse( NetState state, RelayInfo info )
        {
            Mobile from = state.Mobile;

            if ( from == null )
                return;

            if ( info.ButtonID == 0 )
            {
                m_From.SendMessage( m_Mobile.Name +" declines your request to mate the two dragons." );
                m_Mobile.SendMessage( "You decline "+ m_From.Name +"'s request to mate the two dragons." );
            }
            if ( info.ButtonID == 1 )
            {
                m_ED1.Blessed = true;
                m_ED1.Pregnant = true;

                MatingTimer mt = new MatingTimer( m_ED1, TimeSpan.FromDays( 3.0 ) );
                mt.Start();
                m_ED1.EndMating = DateTime.Now + TimeSpan.FromDays( 3.0 );

                m_From.SendMessage( m_Mobile.Name +" accepts your request to mate the two dragons." );
                m_Mobile.SendMessage( "You accept "+ m_From.Name +"'s request to mate the two dragons." );
            }
        }
    }
}
 
I mean it tells you that Damage needs a return value. So in that case you need to switch out void with int, thats 50% done.

The other 50% is to actually return something. In thise case this means at the bottom of your Damage method, you simply add the return keyword infront of the base.Damage( amount, defender)
 

Active Shards

Donations

Total amount
$0.00
Goal
$500.00
Back