コード例 #1
0
        public override void Run(Combat.Character character)
        {
            Int32?  amount   = EvaluationHelper.AsInt32(character, Amount, null);
            Boolean cankill  = EvaluationHelper.AsBoolean(character, CanKill, true);
            Boolean absolute = EvaluationHelper.AsBoolean(character, Absolute, false);

            if (amount == null)
            {
                return;
            }

            Int32 scaledamount = amount.Value;

            if (absolute == false)
            {
                scaledamount = (Int32)(scaledamount / character.DefensiveInfo.DefenseMultiplier);
            }

            character.Life += scaledamount;

            if (cankill == false && character.Life == 0)
            {
                character.Life = 1;
            }
        }
コード例 #2
0
ファイル: TargetLifeAdd.cs プロジェクト: terrynoya/xnamugen-1
        public override void Run(Combat.Character character)
        {
            var amount   = EvaluationHelper.AsInt32(character, Amount, null);
            var targetId = EvaluationHelper.AsInt32(character, TargetId, int.MinValue);
            var cankill  = EvaluationHelper.AsBoolean(character, CanKill, true);
            var absolute = EvaluationHelper.AsBoolean(character, Absolute, false);

            if (amount == null)
            {
                return;
            }

            foreach (var target in character.GetTargets(targetId))
            {
                var newamount = amount.Value;

                if (absolute == false && newamount < 0)
                {
                    newamount = (int)(newamount * character.OffensiveInfo.AttackMultiplier);
                    newamount = (int)(newamount / target.DefensiveInfo.DefenseMultiplier);
                }

                target.Life += newamount;
                if (target.Life == 0 && cankill == false)
                {
                    target.Life = 1;
                }
            }
        }
コード例 #3
0
        public override void Run(Combat.Character character)
        {
            Int32?  statenumber     = EvaluationHelper.AsInt32(character, StateNumber, null);
            Boolean?playercontrol   = EvaluationHelper.AsBoolean(character, Control, null);
            Int32?  animationnumber = EvaluationHelper.AsInt32(character, AnimationNumber, null);

            if (statenumber == null)
            {
                return;
            }
            character.StateManager.ChangeState(statenumber.Value);

            if (playercontrol != null)
            {
                if (playercontrol == true)
                {
                    character.PlayerControl = PlayerControl.InControl;
                }
                if (playercontrol == false)
                {
                    character.PlayerControl = PlayerControl.NoControl;
                }
            }

            if (animationnumber != null)
            {
                character.SetLocalAnimation(animationnumber.Value, 0);
            }
        }
コード例 #4
0
        public override void Run(Combat.Character character)
        {
            Int32?varindex = EvaluationHelper.AsInt32(character, IntNumber, null);

            if (varindex == null)
            {
                return;
            }

            Int32 min = 0;
            Int32 max = 1;

            if (GetRange(character, out min, out max) == false)
            {
                return;
            }

            if (min > max)
            {
                Misc.Swap(ref min, ref max);
            }

            Int32 randomvalue = StateSystem.GetSubSystem <Random>().NewInt(min, max);

            if (character.Variables.SetInteger(varindex.Value, false, randomvalue) == false)
            {
            }
        }
コード例 #5
0
        public override void Run(Combat.Character character)
        {
            Int32   animationnumber    = EvaluationHelper.AsInt32(character, AnimationNumber, 0);
            Boolean drawunder          = EvaluationHelper.AsBoolean(character, DrawUnder, false);
            Point   offset             = EvaluationHelper.AsPoint(character, DrawPosition, new Point(0, 0));
            Int32   randomdisplacement = EvaluationHelper.AsInt32(character, RandomDisplacement, 0);

            Combat.ExplodData data = new xnaMugen.Combat.ExplodData();
            data.Scale           = Vector2.One;
            data.AnimationNumber = animationnumber;
            data.CommonAnimation = true;
            data.Location        = (Vector2)offset;
            data.PositionType    = PositionType.P1;
            data.RemoveTime      = -2;
            data.DrawOnTop       = false;
            data.OwnPalFx        = true;
            data.SpritePriority  = (drawunder == true) ? -9 : 9;
            data.Random          = new Point(randomdisplacement / 2, randomdisplacement / 2);
            data.Transparency    = new Blending();
            data.Creator         = character;
            data.Offseter        = character;

            Combat.Explod explod = new Combat.Explod(character.Engine, data);
            if (explod.IsValid == true)
            {
                explod.Engine.Entities.Add(explod);
            }
        }
コード例 #6
0
ファイル: BindToTarget.cs プロジェクト: xubingyue/xnamugen
        public override void Run(Combat.Character character)
        {
            Int32   time      = EvaluationHelper.AsInt32(character, Time, 1);
            Int32   target_id = EvaluationHelper.AsInt32(character, TargetId, Int32.MinValue);
            Vector2 offset    = EvaluationHelper.AsVector2(character, Position, new Vector2(0, 0));

            foreach (Combat.Character target in character.GetTargets(target_id))
            {
                switch (BindPosition)
                {
                case BindToTargetPostion.Mid:
                    offset += target.BasePlayer.Constants.Midposition;
                    break;

                case BindToTargetPostion.Head:
                    offset += target.BasePlayer.Constants.Headposition;
                    break;

                case BindToTargetPostion.None:
                case BindToTargetPostion.Foot:
                default:
                    break;
                }

                character.Bind.Set(target, offset, time, 0, false);
                break;
            }
        }
コード例 #7
0
        public override void Run(Combat.Character character)
        {
            SoundId?soundid             = EvaluationHelper.AsSoundId(character, SoundId, null);
            Int32   volume              = EvaluationHelper.AsInt32(character, Volume, 0);
            Int32   channelindex        = EvaluationHelper.AsInt32(character, ChannelNumber, -1);
            Boolean priority            = EvaluationHelper.AsBoolean(character, ChannelPriority, false);
            Single  frequencymultiplier = EvaluationHelper.AsSingle(character, FrequencyMultiplier, 1.0f);
            Boolean loop   = EvaluationHelper.AsBoolean(character, LoopSound, false);
            Int32?  pan    = EvaluationHelper.AsInt32(character, PanSound, null);
            Int32?  abspan = EvaluationHelper.AsInt32(character, PanSoundAbsolute, null);

            if (soundid == null)
            {
                return;
            }

            Audio.SoundManager soundmanager = SoundId.IsCommon(false) ? character.Engine.CommonSounds : character.SoundManager;

            Audio.Channel channel = soundmanager.Play(channelindex, soundid.Value, priority, volume, frequencymultiplier, loop);
            if (channel != null && pan != null)
            {
                channel.RelativePan(pan.Value);
            }
            if (channel != null && abspan != null)
            {
                channel.AbsolutePan(abspan.Value);
            }
        }
コード例 #8
0
ファイル: EnvColor.cs プロジェクト: terrynoya/xnamugen-1
        public override void Run(Combat.Character character)
        {
            var color     = EvaluationHelper.AsVector3(character, ScreenColor, Vector3.One);
            var time      = EvaluationHelper.AsInt32(character, Time, 1);
            var underflag = EvaluationHelper.AsBoolean(character, Under, false);

            character.Engine.EnvironmentColor.Setup(color, time, underflag);
        }
コード例 #9
0
        public override void Run(Combat.Character character)
        {
            var spritepriority = EvaluationHelper.AsInt32(character, Priority, 0);

            spritepriority = Misc.Clamp(spritepriority, -5, 5);

            character.DrawOrder = spritepriority;
        }
コード例 #10
0
        public override void Run(Combat.Character character)
        {
            var distance = EvaluationHelper.AsInt32(character, GuardDistance, null);

            if (distance != null && character.OffensiveInfo.ActiveHitDef)
            {
                character.OffensiveInfo.HitDef.GuardDistance = distance.Value;
            }
        }
コード例 #11
0
ファイル: PowerSet.cs プロジェクト: xubingyue/xnamugen
        public override void Run(Combat.Character character)
        {
            Int32?power = EvaluationHelper.AsInt32(character, Power, null);

            if (power != null)
            {
                character.BasePlayer.Power = power.Value;
            }
        }
コード例 #12
0
        public static int Data_Guard_Sparkno(Character character, ref bool error)
        {
            if (character == null)
            {
                error = true;
                return(0);
            }

            return(EvaluationHelper.AsInt32(character, character.BasePlayer.Constants.DefaultGuardSparkNumber, -1));
        }
コード例 #13
0
        public override void Run(Combat.Character character)
        {
            Int32 explod_id = EvaluationHelper.AsInt32(character, Id, Int32.MinValue);
            Int32 time      = EvaluationHelper.AsInt32(character, Time, 1);

            foreach (Combat.Explod explod in character.GetExplods(explod_id))
            {
                explod.Data.BindTime = time;
            }
        }
コード例 #14
0
        public override void Run(Combat.Character character)
        {
            var explodId = EvaluationHelper.AsInt32(character, Id, int.MinValue);
            var time     = EvaluationHelper.AsInt32(character, Time, 1);

            foreach (var explod in character.GetExplods(explodId))
            {
                explod.Data.BindTime = time;
            }
        }
コード例 #15
0
        public static Int32 Data_Guard_Sparkno(Object state, ref Boolean error)
        {
            Combat.Character character = state as Combat.Character;
            if (character == null)
            {
                error = true;
                return(0);
            }

            return(EvaluationHelper.AsInt32(character, character.BasePlayer.Constants.DefaultGuardSparkNumber, -1));
        }
コード例 #16
0
ファイル: PalFx.cs プロジェクト: xubingyue/xnamugen
        public override void Run(Combat.Character character)
        {
            Int32   time      = EvaluationHelper.AsInt32(character, Time, -2);
            Vector3 paladd    = EvaluationHelper.AsVector3(character, PaletteColorAdd, new Vector3(0, 0, 0));
            Vector3 palmul    = EvaluationHelper.AsVector3(character, PaletteColorMultiply, new Vector3(255, 255, 255));
            Vector4 sinadd    = EvaluationHelper.AsVector4(character, PaletteColorSineAdd, new Vector4(0, 0, 0, 1));
            Boolean invert    = EvaluationHelper.AsBoolean(character, PaletteColorInversion, false);
            Int32   basecolor = EvaluationHelper.AsInt32(character, PaletteColor, 255);

            character.PaletteFx.Set(time, paladd, palmul, sinadd, invert, basecolor / 255.0f);
        }
コード例 #17
0
        public override void Run(Combat.Character character)
        {
            var hits = EvaluationHelper.AsInt32(character, Hits, null);

            if (hits == null || hits <= 0)
            {
                return;
            }

            character.Team.Display.ComboCounter.AddHits(hits.Value);
        }
コード例 #18
0
        public override void Run(Combat.Character character)
        {
            Int32 explod_id = EvaluationHelper.AsInt32(character, ExplodId, Int32.MinValue);

            List <Combat.Explod> removelist = new List <Combat.Explod>(character.GetExplods(explod_id));

            foreach (Combat.Explod explod in removelist)
            {
                explod.Kill();
            }
        }
コード例 #19
0
        public override void Run(Combat.Character character)
        {
            var explodId = EvaluationHelper.AsInt32(character, ExplodId, int.MinValue);

            var removelist = new List <Combat.Explod>(character.GetExplods(explodId));

            foreach (var explod in removelist)
            {
                explod.Kill();
            }
        }
コード例 #20
0
        public override void Run(Combat.Character character)
        {
            var time     = EvaluationHelper.AsInt32(character, Time, 1);
            var targetId = EvaluationHelper.AsInt32(character, TargetId, int.MinValue);
            var position = EvaluationHelper.AsVector2(character, Position, new Vector2(0, 0));

            foreach (var target in character.GetTargets(targetId))
            {
                target.Bind.Set(character, position, time, 0, true);
            }
        }
コード例 #21
0
        public override void Run(Combat.Character character)
        {
            var amount = EvaluationHelper.AsInt32(character, Amount, null);

            if (amount == null)
            {
                return;
            }

            character.Life = amount.Value;
        }
コード例 #22
0
ファイル: DefensiveInfo.cs プロジェクト: xubingyue/xnamugen
        public void OnHit(HitDefinition hitdef, Character attacker, Boolean blocked)
        {
            if (hitdef == null)
            {
                throw new ArgumentNullException("hitdef");
            }
            if (attacker == null)
            {
                throw new ArgumentNullException("attacker");
            }

            Boolean alreadyfalling = IsFalling;

            HitDef.Set(hitdef);
            Attacker = attacker;
            Blocked  = blocked;

            if (alreadyfalling == true)
            {
                HitDef.Fall = true;
            }
            else
            {
                m_character.JugglePoints = m_character.BasePlayer.Constants.AirJuggle;
            }

            HitCount     = (m_character.MoveType == MoveType.BeingHit) ? HitCount + 1 : 1;
            HitStateType = m_character.StateType;

            m_character.DrawOrder     = HitDef.P2SpritePriority;
            m_character.PlayerControl = PlayerControl.NoControl;
            m_character.MoveType      = MoveType.BeingHit;

            if (blocked == true)
            {
                HitShakeTime = HitDef.GuardShakeTime;
                m_character.BasePlayer.Power += HitDef.P2GuardPowerAdjustment;
            }
            else
            {
                HitShakeTime = HitDef.ShakeTime;
                m_character.BasePlayer.Power += HitDef.P2HitPowerAdjustment;

                m_character.PaletteFx.Set(HitDef.PalFxTime, HitDef.PalFxAdd, HitDef.PalFxMul, HitDef.PalFxSinAdd, HitDef.PalFxInvert, HitDef.PalFxBaseColor);

                if (IsFalling == true)
                {
                    Int32 neededjugglepoints = EvaluationHelper.AsInt32(Attacker, Attacker.StateManager.CurrentState.JugglePoints, 0);
                    m_character.JugglePoints -= neededjugglepoints;
                }
            }
        }
コード例 #23
0
        public override void Run(Combat.Character character)
        {
            var time = EvaluationHelper.AsInt32(character, DisplayTime, null);

            if (time != null)
            {
                character.AfterImages.ModifyDisplayTime(time.Value);
            }
            else
            {
                character.AfterImages.IsActive = false;
            }
        }
コード例 #24
0
        public override void Run(Combat.Character character)
        {
            var helperName        = Name ?? character.BasePlayer.Profile.DisplayName + "'s Helper";
            var helperId          = EvaluationHelper.AsInt32(character, Id, 0);
            var positionOffset    = (Vector2)EvaluationHelper.AsPoint(character, Position, new Point(0, 0));
            var facingflag        = EvaluationHelper.AsInt32(character, Facing, 1);
            var statenumber       = EvaluationHelper.AsInt32(character, StateNumber, 0);
            var keycontrol        = EvaluationHelper.AsBoolean(character, KeyControl, false);
            var ownpalette        = EvaluationHelper.AsBoolean(character, OwnPalette, false);
            var supermovetime     = EvaluationHelper.AsInt32(character, SuperMoveTime, 0);
            var pausemovetime     = EvaluationHelper.AsInt32(character, PauseMoveTime, 0);
            var scalex            = EvaluationHelper.AsSingle(character, XScale, character.BasePlayer.Constants.Scale.X);
            var scaley            = EvaluationHelper.AsSingle(character, YScale, character.BasePlayer.Constants.Scale.Y);
            var groundfront       = EvaluationHelper.AsInt32(character, GroundFrontSize, character.BasePlayer.Constants.GroundFront);
            var groundback        = EvaluationHelper.AsInt32(character, GroundBackSize, character.BasePlayer.Constants.GroundBack);
            var airfront          = EvaluationHelper.AsInt32(character, AirFrontSize, character.BasePlayer.Constants.Airfront);
            var airback           = EvaluationHelper.AsInt32(character, AirBackSize, character.BasePlayer.Constants.Airback);
            var height            = EvaluationHelper.AsInt32(character, Height, character.BasePlayer.Constants.Height);
            var projectilescaling = EvaluationHelper.AsBoolean(character, ProjectileScaling, character.BasePlayer.Constants.ProjectileScaling);
            var headposition      = (Vector2)EvaluationHelper.AsPoint(character, HeadPosition, (Point)character.BasePlayer.Constants.Headposition);
            var midposition       = (Vector2)EvaluationHelper.AsPoint(character, MiddlePosition, (Point)character.BasePlayer.Constants.Midposition);
            var shadowoffset      = EvaluationHelper.AsInt32(character, ShadowOffset, character.BasePlayer.Constants.Shadowoffset);

            var data = new Combat.HelperData();

            data.Name               = helperName;
            data.HelperId           = helperId;
            data.Type               = HelperType;
            data.FacingFlag         = facingflag;
            data.PositionType       = PositionType;
            data.CreationOffset     = positionOffset;
            data.KeyControl         = keycontrol;
            data.OwnPaletteFx       = ownpalette;
            data.InitialStateNumber = statenumber;
            data.Scale              = new Vector2(scalex, scaley);
            data.GroundFront        = groundfront;
            data.GroundBack         = groundback;
            data.AirFront           = airfront;
            data.AirBack            = airback;
            data.Height             = height;
            data.SuperPauseTime     = supermovetime;
            data.PauseTime          = pausemovetime;
            data.ProjectileScaling  = projectilescaling;
            data.HeadPosition       = headposition;
            data.MidPosition        = midposition;
            data.ShadowOffset       = shadowoffset;

            var helper = new Combat.Helper(character.Engine, character, data);

            helper.Engine.Entities.Add(helper);
        }
コード例 #25
0
ファイル: SuperPause.cs プロジェクト: terrynoya/xnamugen-1
        public override void Run(Combat.Character character)
        {
            int?time       = EvaluationHelper.AsInt32(character, Time, 30);
            var buffertime = EvaluationHelper.AsInt32(character, EndCommandBufferTime, 0);
            var movetime   = EvaluationHelper.AsInt32(character, MoveTime, 0);
            var pausebg    = EvaluationHelper.AsBoolean(character, PauseBackgrounds, true);
            var power      = EvaluationHelper.AsInt32(character, PowerAdd, 0);

#warning Documentation states that default should be 30. Testing looks to be 100.
            var animationnumber = EvaluationHelper.AsInt32(character, AnimationNumber, 100);

            var soundid           = EvaluationHelper.AsSoundId(character, SoundId, null);
            var animationposition = EvaluationHelper.AsPoint(character, AnimationPosition, new Point(0, 0));
            var darkenscreen      = EvaluationHelper.AsBoolean(character, DarkenScreen, true);
            var p2defmul          = EvaluationHelper.AsSingle(character, P2DefenseMultiplier, null);
            var unhittable        = EvaluationHelper.AsBoolean(character, Unhittable, true);

            if (time == null)
            {
                return;
            }

            var pause = character.Engine.SuperPause;
            pause.Set(character, time.Value, buffertime, movetime, false, pausebg);

            character.BasePlayer.Power += power;

            var data = new Combat.ExplodData();
            data.PositionType    = PositionType.P1;
            data.Location        = (Vector2)animationposition;
            data.RemoveTime      = -2;
            data.CommonAnimation = EvaluationHelper.IsCommon(AnimationNumber, true);
            data.AnimationNumber = animationnumber;
            data.Scale           = Vector2.One;
            data.SuperMove       = true;
            data.Creator         = character;
            data.Offseter        = character;
            data.DrawOnTop       = true;

            var explod = new Combat.Explod(character.Engine, data);
            if (explod.IsValid)
            {
                explod.Engine.Entities.Add(explod);
            }

            if (soundid != null)
            {
                Audio.SoundManager soundmanager = SoundId.IsCommon(true) ? character.Engine.CommonSounds : character.SoundManager;
                soundmanager.Play(soundid.Value);
            }
        }
コード例 #26
0
        public override void Run(Combat.Character character)
        {
            var time       = EvaluationHelper.AsInt32(character, Time, null);
            var buffertime = EvaluationHelper.AsInt32(character, EndCommandBufferTime, 0);
            var movetime   = EvaluationHelper.AsInt32(character, MoveTime, 0);
            var pausebg    = EvaluationHelper.AsBoolean(character, PauseBackgrounds, true);

            if (time == null)
            {
                return;
            }

            character.Engine.Pause.Set(character, time.Value, buffertime, movetime, false, pausebg);
        }
コード例 #27
0
        public override void Run(Combat.Character character)
        {
            var slotnumber  = EvaluationHelper.AsInt32(character, SlotNumber, 0);
            var statenumber = EvaluationHelper.AsInt32(character, StateNumber, int.MinValue);
            var time        = EvaluationHelper.AsInt32(character, Time, 1);
            var forceair    = EvaluationHelper.AsBoolean(character, ForceAir, false);

            if (slotnumber < 0 || slotnumber > 7)
            {
                return;
            }

            character.DefensiveInfo.HitOverrides[slotnumber].Set(Override, statenumber, time, forceair);
        }
コード例 #28
0
        public override void Run(Combat.Character character)
        {
            var time = EvaluationHelper.AsInt32(character, Time, 1);

            if (HitAttribute1 != null)
            {
                character.DefensiveInfo.HitBy1.Set(HitAttribute1, time, true);
            }

            if (HitAttribute2 != null)
            {
                character.DefensiveInfo.HitBy2.Set(HitAttribute2, time, true);
            }
        }
コード例 #29
0
        public override void Run(Combat.Character character)
        {
            Combat.Helper helper = character as Combat.Helper;
            if (helper == null)
            {
                return;
            }

            Int32   time   = EvaluationHelper.AsInt32(character, Time, 1);
            Int32   facing = EvaluationHelper.AsInt32(character, Facing, 0);
            Vector2 offset = EvaluationHelper.AsVector2(character, Position, new Vector2(0, 0));

            helper.Bind.Set(helper.BasePlayer, offset, time, facing, false);
        }
コード例 #30
0
        public override void Run(Combat.Character character)
        {
            var helper = character as Combat.Helper;

            if (helper == null)
            {
                return;
            }

            if (IntNumber != null)
            {
                var index = EvaluationHelper.AsInt32(character, IntNumber, null);
                var value = EvaluationHelper.AsInt32(character, Value, null);

                if (index != null && value != null && helper.Parent.Variables.AddInteger(index.Value, false, value.Value) == false)
                {
                }
            }

            if (FloatNumber != null)
            {
                var index = EvaluationHelper.AsInt32(character, FloatNumber, null);
                var value = EvaluationHelper.AsSingle(character, Value, null);

                if (index != null && value != null && helper.Parent.Variables.AddFloat(index.Value, false, value.Value) == false)
                {
                }
            }

            if (SystemIntNumber != null)
            {
                var index = EvaluationHelper.AsInt32(character, SystemIntNumber, null);
                var value = EvaluationHelper.AsInt32(character, Value, null);

                if (index != null && value != null && helper.Parent.Variables.AddInteger(index.Value, true, value.Value) == false)
                {
                }
            }

            if (SystemFloatNumber != null)
            {
                var index = EvaluationHelper.AsInt32(character, SystemFloatNumber, null);
                var value = EvaluationHelper.AsSingle(character, Value, null);

                if (index != null && value != null && helper.Parent.Variables.AddFloat(index.Value, true, value.Value) == false)
                {
                }
            }
        }