コード例 #1
0
 public CharacterOriginAnimation(int charIndex, int animIndex, RenderTime animTime, int loops)
 {
     AnimationIndex = animIndex;
     FrameLength = animTime;
     TotalLoops = loops;
     CharIndex = charIndex;
 }
コード例 #2
0
 public NormalMoveAnimation(Loc2D tileLoc, int animIndex, RenderTime animTime, int loops)
 {
     AnimationIndex = animIndex;
     FrameLength = animTime;
     TotalLoops = loops;
     StartLoc = new Loc2D(tileLoc.X, tileLoc.Y);
 }
コード例 #3
0
 public OverlayMoveAnimation(int animIndex, RenderTime animTime, int loops, byte transparency)
 {
     AnimationIndex = animIndex;
     FrameLength = animTime;
     TotalLoops = loops;
     Alpha = (byte)(255 - transparency);
 }
コード例 #4
0
 public BeamMoveAnimation(Loc2D startLoc, int animIndex, RenderTime animTime, Maps.Direction8 dir, int distance, RenderTime lastingTime)
 {
     StartLoc = startLoc;
     AnimationIndex = animIndex;
     FrameLength = animTime;
     Direction = dir;
     TotalDistance = distance;
     LastingTime = lastingTime;
 }
コード例 #5
0
ファイル: TileAnim.cs プロジェクト: blastboy/PMD-Toolkit
 public TileAnim(TileAnim oldTileAnim)
 {
     Frames = new List<TileTexture>();
     for (int i = 0; i < oldTileAnim.Frames.Count; i++)
     {
         Frames.Add(oldTileAnim.Frames[i]);
     }
     FrameLength = oldTileAnim.FrameLength;
 }
コード例 #6
0
 public ArrowMoveAnimation(Loc2D startLoc, int animIndex, RenderTime animTime, Maps.Direction8 dir, int distance, int speed)
 {
     StartLoc = startLoc;
     AnimationIndex = animIndex;
     FrameLength = animTime;
     Direction = dir;
     TotalWaves = distance;
     TotalDistance = distance*TextureManager.TILE_SIZE;
     TravelSpeed = speed;
 }
コード例 #7
0
 public ItemThrowMoveAnimation(Loc2D startLoc, Loc2D endLoc, int animIndex, RenderTime animTime, int speed, bool dropDown)
 {
     StartLoc = startLoc;
     EndLoc = endLoc;
     AnimationIndex = animIndex;
     FrameLength = animTime;
     Loc2D diffLoc = startLoc-endLoc;
     TotalDistance = (int)(TextureManager.TILE_SIZE*Math.Sqrt(Math.Pow(diffLoc.X,2) + Math.Pow(diffLoc.Y,2)));
     TravelSpeed = speed;
     DropDown = dropDown;
 }
コード例 #8
0
 public FountainEmitter(Loc2D startLoc, int animIndex, int grainsPerBurst, RenderTime burstTime, int bursts, RenderTime animTime, int startDistance, int speed, RenderTime totalTime)
 {
     StartLoc = startLoc;
     AnimationIndex = animIndex;
     FrameLength = animTime;
     TotalTime = totalTime;
     GrainsPerBurst = grainsPerBurst;
     BurstTime = burstTime;
     TotalBursts = bursts;
     StartDistance = startDistance;
     Speed = speed;
 }
コード例 #9
0
 //float scale;
 //float scaleSpeed;
 //float rotation;
 //float rotationSpeed;
 public ParticleAnimation(int animationIndex, RenderTime frameLength, Loc2D newPosition, Loc2D newSpeed, Loc2D newAcceleration, Color4 newAlpha, Color4 newAlphaSpeed, RenderTime newMaxTime)
 {
     AnimationIndex = animationIndex;
     FrameLength = frameLength;
     MapLoc = newPosition;
     StartLoc = MapLoc;
     Speed = newSpeed;
     StartSpeed = Speed;
     Acceleration = newAcceleration;
     Color = newAlpha;
     ColorChange = newAlphaSpeed;
     TotalTime = newMaxTime;
 }
コード例 #10
0
ファイル: Program.cs プロジェクト: blastboy/PMD-Toolkit
        /// <summary>
        /// Called when it is time to setup the next frame. Add you game logic here.
        /// </summary>
        /// <param name="e">Contains timing information for framerate independent logic.</param>
        protected override void OnUpdateFrame(FrameEventArgs e)
        {
            base.OnUpdateFrame(e);

            if (Editors.MainPanel.GameNeedWait)
            {
                Editors.MainPanel.GameWaiting = true;

                while (Editors.MainPanel.GameNeedWait)
                    Thread.Sleep(100);

                Editors.MainPanel.GameWaiting = false;
            }

            if (GameLoaded == GameLoadState.Closing)
                Close();
            else if (GameLoaded == GameLoadState.PostLoading)
                GameLoaded = GameLoadState.Finalizing;
            else if (GameLoaded == GameLoadState.Finalizing)
            {
                Graphics.TextureManager.PostInit();

                Logic.Gameplay.MenuManager.Init();
                Logic.Gameplay.Processor.Init();
                Logic.Display.Screen.Init();
                Logic.Gameplay.Processor.Restart();
                Logic.Display.Screen.ProcessTaskQueue(true);

                GameLoaded = GameLoadState.Loaded;
                while (!Editors.MainPanel.EditorLoaded)
                {
                    Thread.Sleep(100);
                }
            }
            else if (GameLoaded == GameLoadState.Loaded)
            {
                try
                {
                    Graphics.TextureManager.Update();

                    RenderTime elapsedTime = new RenderTime((int)(e.Time * Graphics.TextureManager.FPS_CAP * 1000));

                    //set this frame's input
                    Logic.Gameplay.Input input = new Logic.Gameplay.Input(Keyboard, Mouse);
                    Logic.Gameplay.Processor.SetFrameInput(input, elapsedTime, (int)Math.Round(UpdateFrequency));

                    Logic.Display.Screen.Process(elapsedTime);
                    errorCount--;
                }
                catch (Exception ex)
                {
                    Logs.Logger.LogError(ex);
                    errorCount += 2;
                }
            }
        }
コード例 #11
0
ファイル: ItemAnim.cs プロジェクト: blastboy/PMD-Toolkit
        public void Process(RenderTime elapsedTime)
        {
            ActionTime += elapsedTime;

            RenderTime totalTime = ITEM_ACTION_TIME[(int)Action];

            if (ActionTime >= totalTime && Action != ItemAnimType.None)
            {
                ActionDone = true;
            } else {
                switch (Action) {
                    case ItemAnimType.None:
                        {
                            MapHeight = 0;
                            MapLoc = StartLoc;
                            break;
                        }
                    case ItemAnimType.Drop: {
                        MapHeight = DrawHelper.GetArc(TextureManager.TILE_SIZE / 4, totalTime.Ticks, ActionTime.Ticks);
                            MapHeight += TextureManager.TILE_SIZE * (totalTime - ActionTime).Ticks / 2 / totalTime.Ticks;
                            Loc2D mapDiff = (EndLoc - StartLoc) * TextureManager.TILE_SIZE;
                            mapDiff = new Loc2D(mapDiff.X * ActionTime.Ticks / totalTime.Ticks, mapDiff.Y * ActionTime.Ticks / totalTime.Ticks);
                            MapLoc = mapDiff + StartLoc * TextureManager.TILE_SIZE;
                        }
                        break;
                    case ItemAnimType.Bounce: {
                        MapHeight = DrawHelper.GetArc(TextureManager.TILE_SIZE / 2, totalTime.Ticks, ActionTime.Ticks);
                            Loc2D mapDiff = (EndLoc - StartLoc) * TextureManager.TILE_SIZE;
                            mapDiff = new Loc2D(mapDiff.X * ActionTime.Ticks / totalTime.Ticks, mapDiff.Y * ActionTime.Ticks / totalTime.Ticks);
                            MapLoc = mapDiff + StartLoc * TextureManager.TILE_SIZE;
                        }
                        break;
                    case ItemAnimType.Deflect: {
                        MapHeight = DrawHelper.GetArc(TextureManager.TILE_SIZE / 2, totalTime.Ticks, ActionTime.Ticks);
                        MapHeight += TextureManager.TILE_SIZE * (totalTime.Ticks - ActionTime.Ticks) / 2 / totalTime.Ticks;
                            Loc2D mapDiff = (EndLoc - StartLoc) * TextureManager.TILE_SIZE;
                            mapDiff = new Loc2D(mapDiff.X * ActionTime.Ticks / totalTime.Ticks, mapDiff.Y * ActionTime.Ticks / totalTime.Ticks);
                            MapLoc = mapDiff + StartLoc * TextureManager.TILE_SIZE;
                        }
                        break;
                }
            }
        }
コード例 #12
0
        public virtual void Process(RenderTime elapsedTime)
        {
            ActionTime += elapsedTime;
            FrameTime += elapsedTime;
            if (FrameTime >= FrameLength) {
                FrameTime = FrameTime - FrameLength;
                Frame++;
            }

            if (Frame >= TextureManager.GetSpellSheet(TextureManager.SpellAnimType.Spell, AnimationIndex).TotalFrames) {
                Loops++;
                Frame = 0;
            }

            if (Loops >= TotalLoops) {
                ActionDone = true;
            }
        }
コード例 #13
0
        public virtual void Process(RenderTime elapsedTime)
        {
            ActionTime += elapsedTime;
            FrameTime += elapsedTime;
            if (FrameTime >= FrameLength) {
                FrameTime = FrameTime - FrameLength;
                Frame++;
            }

            if (Frame >= TextureManager.GetItemSheet(AnimationIndex).TotalFrames) {
                Frame = 0;
            }

            Distance = ActionTime.ToMillisecs() * TravelSpeed;

            if (Distance >= TotalDistance) {
                ActionDone = true;
            } else {
                MapHeight = DrawHelper.GetArc(TotalDistance, TotalDistance, Distance);
                if (DropDown) {
                    MapHeight += TextureManager.TILE_SIZE * (TotalDistance - Distance) / TotalDistance / 2;
                } else {
                    MapHeight += TextureManager.TILE_SIZE / 2;
                }

                Loc2D mapDiff = (EndLoc - StartLoc) * TextureManager.TILE_SIZE;
                mapDiff = new Loc2D(mapDiff.X * Distance / TotalDistance, mapDiff.Y * Distance / TotalDistance);

                MapLoc = mapDiff + StartLoc * TextureManager.TILE_SIZE;
            }
        }
コード例 #14
0
ファイル: Wait.cs プロジェクト: blastboy/PMD-Toolkit
 public Wait(RenderTime time)
 {
     this.time = time;
 }
コード例 #15
0
 public void ProcessDelay(RenderTime time)
 {
     foreach (KeyValuePair<int, ResultBranch> entry in branches)
     {
         entry.Value.Delay -= time;
         if (entry.Value.Delay < RenderTime.Zero)
             entry.Value.Delay = RenderTime.Zero;
     }
 }
コード例 #16
0
        public virtual void Process(RenderTime elapsedTime)
        {
            ActionTime += elapsedTime;
            FrameTime += elapsedTime;
            if (FrameTime >= FrameLength) {
                FrameTime = FrameTime - FrameLength;
                Frame++;
            }

            if (Frame >= TextureManager.GetSpellSheet(TextureManager.SpellAnimType.Spell, AnimationIndex).TotalFrames) {
                Frame = 0;
            }

            MapLoc = StartLoc + Speed * ActionTime.ToMillisecs() / 1000;
            Speed = StartSpeed + Acceleration * ActionTime.ToMillisecs() / 1000;
            if (ActionTime >= TotalTime) {
                ActionDone = true;
            }
        }
コード例 #17
0
ファイル: Screen.cs プロジェクト: blastboy/PMD-Toolkit
        public static void Process(RenderTime elapsedTime)
        {
            if (DebugSpeed == GameSpeed.Pause)
            {
                return;
            }
            else if (DebugSpeed == GameSpeed.Instant)
            {
                ForceReady();
                ProcessActions(elapsedTime);
            }
            else
            {
                int speedFactor = 1000;

                speedFactor = (int)(speedFactor * Math.Pow(2, (int)DebugSpeed));

                RenderTime newElapsed = elapsedTime * speedFactor / 1000;
                ProcessActions(newElapsed);

            }

            //if actions are ready for queue, get a new result
            ProcessTaskQueue(true);

            //update actions at 0 time
            ProcessActions(new RenderTime());
        }
コード例 #18
0
ファイル: Processor.cs プロジェクト: blastboy/PMD-Toolkit
        public static void SetFrameInput(Input input, RenderTime elapsedTime, int ups)
        {
            if (input == CurrentInput)
            {
                InputTime += elapsedTime;
            }
            else
            {
                InputTime = RenderTime.FromMillisecs(0);
            }
            PrevInput = CurrentInput;
            CurrentInput = input;

            Display.Screen.UpdatesPerSecond = ups;
            ProcessMeta();
        }
コード例 #19
0
ファイル: CharSprite.cs プロジェクト: blastboy/PMD-Toolkit
        public void Process(RenderTime elapsedTime)
        {
            if (Dead)
                return;

            if (CurrentAction == ActionType.Idle)
            {
                if (MovementSpeed < 0)
                {
                    elapsedTime /= 2;
                }
                else if (MovementSpeed > 0)
                {
                    elapsedTime *= 2;
                }
            }
            ActionTime += elapsedTime;

            RenderTime totalActionTime = GetActionTime(CharData, CharDir, CurrentAction);
            RenderTime totalPassTime = GetPassTime(CharData, CharDir, CurrentAction);

            if (ActionTime >= totalPassTime)
                ActionDone = true;

            if (ActionTime >= totalActionTime)
            {
                if (ActionLoop)
                {
                    ActionTime = ActionTime % totalActionTime;
                }
                else
                {
                    switch (CurrentAction)
                    {
                        case ActionType.None:
                            {
                                ActionTime = RenderTime.Zero;
                                CurrentAction = ActionType.Idle;
                            }
                            break;
                        case ActionType.Idle:
                            {
                                if (totalActionTime > RenderTime.Zero)
                                    ActionTime = ActionTime % totalActionTime;
                                else
                                    ActionTime = RenderTime.Zero;
                            }
                            break;
                        default:
                            {
                                ActionTime = RenderTime.Zero;
                                CurrentAction = ActionType.None;
                            }
                            break;
                    }
                }
            }

            CharFrameType = FrameType.Idle;
            CharFrame = 0;
            TileOffset = new Loc2D();
            drawOffset = new Loc2D();
            opacity = 255;
            MapHeight = 0;
            if (CurrentAction == ActionType.Idle)
            {
                CharFrameType = FrameType.Idle;
                int totalFrames = TextureManager.GetSpriteSheet(CharData.Species, CharData.Form, CharData.Shiny, CharData.Gender).FrameData.GetFrameCount(CharFrameType, CharDir);
                if (totalFrames > 0)
                    CharFrame = (ActionTime.Ticks / IDLE_FRAME_LENGTH.Ticks) % totalFrames;

                TileOffset = new Loc2D();
                MapHeight = 0;
            }
            else if (CurrentAction == ActionType.Walk)
            {
                CharFrameType = FrameType.Walk;
                int totalFrames = TextureManager.GetSpriteSheet(CharData.Species, CharData.Form, CharData.Shiny, CharData.Gender).FrameData.GetFrameCount(CharFrameType, CharDir);

                if (totalFrames > 0)
                    CharFrame = ((ActionTime + PrevActionTime).Ticks / WALK_FRAME_LENGTH.Ticks) % totalFrames;

                if (!MoveInPlace)
                {
                    if (ActionTime.Ticks <= totalPassTime.Ticks)
                        Operations.MoveInDirection8(ref TileOffset, CharDir, ActionTime.Ticks * Graphics.TextureManager.TILE_SIZE / totalPassTime.Ticks);
                }
            }
            else if (CurrentAction == ActionType.Attack)
            {
                CharFrameType = FrameType.Attack;
                int totalFrames = TextureManager.GetSpriteSheet(CharData.Species, CharData.Form, CharData.Shiny, CharData.Gender).FrameData.GetFrameCount(CharFrameType, CharDir);
                if (totalFrames > 0)
                    CharFrame = (ActionTime.Ticks * totalFrames / totalActionTime.Ticks);

                if (!MoveInPlace)
                {
                    int pullback_distance = Graphics.TextureManager.TILE_SIZE / 8;
                    int farthest_distance = Graphics.TextureManager.TILE_SIZE * 3 / 4;
                    int hold_point = totalActionTime.Ticks / 8;
                    int rush_point = totalActionTime.Ticks * 2 / 8;
                    int hit_point = totalActionTime.Ticks * 4 / 8;
                    int return_point = totalActionTime.Ticks * 6 / 8;
                    if (ActionTime.Ticks <= hold_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, -ActionTime.Ticks * pullback_distance / rush_point);
                    else if (ActionTime.Ticks <= rush_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, -pullback_distance);
                    else if (ActionTime.Ticks <= hit_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, (ActionTime.Ticks - rush_point) * (farthest_distance + pullback_distance) / (hit_point - rush_point) - pullback_distance);
                    else if (ActionTime.Ticks <= return_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, farthest_distance);
                    else
                        Operations.MoveInDirection8(ref drawOffset, CharDir, ((totalActionTime.Ticks - hit_point) - (ActionTime.Ticks - hit_point)) * farthest_distance / (totalActionTime.Ticks - hit_point));
                }
            }
            else if (CurrentAction == ActionType.AttackArm)
            {
                CharFrameType = FrameType.AttackArm;
                int totalFrames = TextureManager.GetSpriteSheet(CharData.Species, CharData.Form, CharData.Shiny, CharData.Gender).FrameData.GetFrameCount(CharFrameType, CharDir);
                if (totalFrames > 0)
                    CharFrame = (ActionTime.Ticks * totalFrames / totalActionTime.Ticks);

                if (!MoveInPlace)
                {
                    int pullback_distance = Graphics.TextureManager.TILE_SIZE / 8;
                    int farthest_distance = Graphics.TextureManager.TILE_SIZE * 3 / 4;
                    int hold_point = totalActionTime.Ticks / 8;
                    int rush_point = totalActionTime.Ticks * 2 / 8;
                    int hit_point = totalActionTime.Ticks * 4 / 8;
                    int return_point = totalActionTime.Ticks * 6 / 8;
                    if (ActionTime.Ticks <= hold_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, -ActionTime.Ticks * pullback_distance / rush_point);
                    else if (ActionTime.Ticks <= rush_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, -pullback_distance);
                    else if (ActionTime.Ticks <= hit_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, (ActionTime.Ticks - rush_point) * (farthest_distance + pullback_distance) / (hit_point - rush_point) - pullback_distance);
                    else if (ActionTime.Ticks <= return_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, farthest_distance);
                    else
                        Operations.MoveInDirection8(ref drawOffset, CharDir, ((totalActionTime.Ticks - hit_point) - (ActionTime.Ticks - hit_point)) * farthest_distance / (totalActionTime.Ticks - hit_point));
                }
            }
            else if (CurrentAction == ActionType.AltAttack)
            {
                CharFrameType = FrameType.AltAttack;
                int totalFrames = TextureManager.GetSpriteSheet(CharData.Species, CharData.Form, CharData.Shiny, CharData.Gender).FrameData.GetFrameCount(CharFrameType, CharDir);
                CharFrame = (ActionTime.Ticks * totalFrames / totalActionTime.Ticks);

                if (!MoveInPlace)
                {
                    int pullback_distance = Graphics.TextureManager.TILE_SIZE / 8;
                    int farthest_distance = Graphics.TextureManager.TILE_SIZE * 3 / 4;
                    int hold_point = totalActionTime.Ticks / 8;
                    int rush_point = totalActionTime.Ticks * 2 / 8;
                    int hit_point = totalActionTime.Ticks * 4 / 8;
                    int return_point = totalActionTime.Ticks * 6 / 8;
                    if (ActionTime.Ticks <= hold_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, -ActionTime.Ticks * pullback_distance / rush_point);
                    else if (ActionTime.Ticks <= rush_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, -pullback_distance);
                    else if (ActionTime.Ticks <= hit_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, (ActionTime.Ticks - rush_point) * (farthest_distance + pullback_distance) / (hit_point - rush_point) - pullback_distance);
                    else if (ActionTime.Ticks <= return_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, farthest_distance);
                    else
                        Operations.MoveInDirection8(ref drawOffset, CharDir, ((totalActionTime.Ticks - hit_point) - (ActionTime.Ticks - hit_point)) * farthest_distance / (totalActionTime.Ticks - hit_point));
                }
            }
            else if (CurrentAction == ActionType.SpAttack)
            {
                CharFrameType = FrameType.SpAttack;
                int totalFrames = TextureManager.GetSpriteSheet(CharData.Species, CharData.Form, CharData.Shiny, CharData.Gender).FrameData.GetFrameCount(CharFrameType, CharDir);
                CharFrame = (ActionTime.Ticks * totalFrames / totalActionTime.Ticks);
            }
            else if (CurrentAction == ActionType.SpAttackShoot)
            {
                CharFrameType = FrameType.SpAttackShoot;
                int totalFrames = TextureManager.GetSpriteSheet(CharData.Species, CharData.Form, CharData.Shiny, CharData.Gender).FrameData.GetFrameCount(CharFrameType, CharDir);
                CharFrame = (ActionTime.Ticks * totalFrames / totalActionTime.Ticks);

                if (!MoveInPlace)
                {
                    int pullback_distance = Graphics.TextureManager.TILE_SIZE / 8;
                    int farthest_distance = Graphics.TextureManager.TILE_SIZE / 8;
                    int hold_point = totalActionTime.Ticks / 8;
                    int rush_point = totalActionTime.Ticks * 3 / 8;
                    int hit_point = totalActionTime.Ticks * 4 / 8;
                    int return_point = totalActionTime.Ticks * 7 / 8;
                    if (ActionTime.Ticks <= hold_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, -ActionTime.Ticks * pullback_distance / rush_point);
                    else if (ActionTime.Ticks <= rush_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, -pullback_distance);
                    else if (ActionTime.Ticks <= hit_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, (ActionTime.Ticks - rush_point) * (farthest_distance + pullback_distance) / (hit_point - rush_point) - pullback_distance);
                    else if (ActionTime.Ticks <= return_point)
                        Operations.MoveInDirection8(ref drawOffset, CharDir, farthest_distance);
                    else
                        Operations.MoveInDirection8(ref drawOffset, CharDir, ((totalActionTime.Ticks - hit_point) - (ActionTime.Ticks - hit_point)) * farthest_distance / (totalActionTime.Ticks - hit_point));
                }
            }
            else if (CurrentAction == ActionType.SpAttackCharge)
            {
                CharFrameType = FrameType.SpAttackCharge;
                int totalFrames = TextureManager.GetSpriteSheet(CharData.Species, CharData.Form, CharData.Shiny, CharData.Gender).FrameData.GetFrameCount(CharFrameType, CharDir);
                if (totalFrames > 0)
                    CharFrame = totalFrames - 1;

                if (!MoveInPlace)
                {
                    if (ActionTime.Ticks / 40 % 2 == 0)
                        Operations.MoveInDirection8(ref drawOffset, Operations.AddDir(CharDir, Direction8.Left), 1);
                }
            }
            else if (CurrentAction == ActionType.Sleeping)
            {
                CharFrameType = FrameType.Sleep;
                int frameCount = TextureManager.GetSpriteSheet(CharData.Species, CharData.Form, CharData.Shiny, CharData.Gender).FrameData.GetFrameCount(CharFrameType, Direction8.Down);
                CharFrame = (ActionTime.Ticks * frameCount / totalActionTime.Ticks);
            }
            else if (CurrentAction == ActionType.Hurt)
            {
                CharFrameType = FrameType.Hurt;
                CharFrame = 0;
                if (!MoveInPlace)
                {
                    if ((ActionTime.Ticks * 3 / totalActionTime.Ticks) % 2 == 0)
                        Operations.MoveInDirection8(ref drawOffset, Operations.ReverseDir(CharDir), 1);
                }
            }
            else if (CurrentAction == ActionType.Defeated)
            {
                CharFrameType = FrameType.Hurt;
                CharFrame = 0;
                if ((ActionTime.Ticks * 6 / totalActionTime.Ticks) % 2 == 0)
                    Operations.MoveInDirection8(ref drawOffset, Operations.ReverseDir(CharDir), 1);
                if ((ActionTime.Ticks * 2 / totalActionTime.Ticks) > 0)
                    opacity = 128;
            }
            //else if (CurrentAction == ActionType.Jump)
            //{
            //    CharFrame = (ActionTime * TextureManager.GetSpriteSheet(CharData.Species, CharData.Form, CharData.Shiny, CharData.Gender).FrameData.GetFrameCount(FrameType.AltAttack, CharDir) / FrameLength);
            //    if (ActionData1 > 1 || ActionData1 == 0)
            //    {
            //        Operations.MoveInDirection8(ref tileOffset, CharDir, ActionTime * ActionData1 * Graphics.TextureManager.TILE_SIZE / FrameLength);
            //    }
            //    else
            //    {
            //        int moveDist = ActionTime * 2 * Graphics.TextureManager.TILE_SIZE / FrameLength;
            //        if (moveDist > Graphics.TextureManager.TILE_SIZE) moveDist = Graphics.TextureManager.TILE_SIZE;
            //        Operations.MoveInDirection8(ref tileOffset, CharDir, moveDist);
            //    }
            //}
            //else if (CurrentAction == ActionType.JumpHit)
            //{
            //    int phaseTotal = (FrameLength / 2);
            //    int phaseTime = ActionTime % phaseTotal;
            //    if (ActionTime < FrameLength / 2)
            //    {
            //        CharFrame = (phaseTime * TextureManager.GetSpriteSheet(CharData.Species, CharData.Form, CharData.Shiny, CharData.Gender).FrameData.GetFrameCount(FrameType.AltAttack, CharDir) / phaseTotal);
            //        if (ActionData1 > 1 || ActionData1 == 0)
            //        {
            //            Operations.MoveInDirection8(ref drawOffset, CharDir, phaseTime * ActionData1 * Graphics.TextureManager.TILE_SIZE / phaseTotal);
            //        }
            //        else
            //        {
            //            int moveDist = phaseTime * 2 * Graphics.TextureManager.TILE_SIZE / phaseTotal;
            //            if (moveDist > Graphics.TextureManager.TILE_SIZE) moveDist = Graphics.TextureManager.TILE_SIZE;
            //            Operations.MoveInDirection8(ref drawOffset, CharDir, moveDist);
            //        }
            //        MapHeight = phaseTime * Graphics.TextureManager.TILE_SIZE / phaseTotal;
            //    }
            //    else
            //    {
            //        CharFrame = (phaseTime * TextureManager.GetSpriteSheet(CharData.Species, CharData.Form, CharData.Shiny, CharData.Gender).FrameData.GetFrameCount(FrameType.AltAttack, CharDir) / phaseTotal);
            //        Operations.MoveInDirection8(ref drawOffset, CharDir, ActionData1 * Graphics.TextureManager.TILE_SIZE - phaseTime * ActionData1 * Graphics.TextureManager.TILE_SIZE / phaseTotal);
            //        MapHeight = (phaseTotal - phaseTime) * Graphics.TextureManager.TILE_SIZE / phaseTotal;
            //    }
            //}
            else if (CurrentAction == ActionType.Deflect)
            {
                CharFrameType = FrameType.Hurt;
                CharFrame = 0;
                TileOffset = new Loc2D();
                Operations.MoveInDirection8(ref TileOffset, CharDir, ActionTime.Ticks * Graphics.TextureManager.TILE_SIZE / totalActionTime.Ticks);
                MapHeight = DrawHelper.GetArc(TextureManager.TILE_SIZE / 2, totalActionTime.Ticks, ActionTime.Ticks);
            }
            else if (CurrentAction == ActionType.Knockback)
            {
                CharFrameType = FrameType.Hurt;
                CharFrame = 0;
                TileOffset = new Loc2D();
                Operations.MoveInDirection8(ref TileOffset, Operations.ReverseDir(CharDir), ActionTime.Ticks * Graphics.TextureManager.TILE_SIZE / totalActionTime.Ticks);
                MapHeight = 0;
            }
            else
            {
                CharFrameType = FrameType.Idle;
                CharFrame = 0;
                TileOffset = new Loc2D();
                MapHeight = 0;
            }
        }
コード例 #20
0
ファイル: TileAnim.cs プロジェクト: blastboy/PMD-Toolkit
 public TileAnim()
 {
     Frames = new List<TileTexture>();
     FrameLength = RenderTime.FromMillisecs(1);
 }
コード例 #21
0
ファイル: TileAnim.cs プロジェクト: blastboy/PMD-Toolkit
        public void Load(BinaryReader reader)
        {
            FrameLength = RenderTime.FromMillisecs(reader.ReadInt32());
            int frameCount = reader.ReadInt32();
            for (int j = 0; j < frameCount; j++)
            {
                TileTexture layer = new TileTexture();

                layer.Texture.X = reader.ReadInt32();
                layer.Texture.Y = reader.ReadInt32();
                layer.Sheet = reader.ReadInt32();
                Frames.Add(layer);
            }
        }
コード例 #22
0
ファイル: MoveAnimation.cs プロジェクト: blastboy/PMD-Toolkit
 public void Load(XmlReader reader)
 {
     while (reader.Read()) {
         if (reader.IsStartElement()) {
             switch (reader.Name) {
                 case "AnimType": {
                         AnimType = reader.ReadString().ToEnum<Logic.Display.MoveAnimationType>();
                         break;
                     }
                 case "AnimIndex": {
                         AnimIndex = reader.ReadString().ToInt();
                         break;
                     }
                 case "FrameLength": {
                         FrameLength = RenderTime.FromMillisecs(reader.ReadString().ToInt());
                         break;
                     }
                 case "Anim1": {
                         Anim1 = reader.ReadString().ToInt();
                         break;
                     }
                 case "Anim2": {
                         Anim2 = reader.ReadString().ToInt();
                         break;
                     }
                 case "Anim3": {
                         Anim3 = reader.ReadString().ToInt();
                         break;
                     }
             }
         }
     }
 }
コード例 #23
0
ファイル: TileAnim.cs プロジェクト: blastboy/PMD-Toolkit
 public TileAnim(Loc2D texture, int sheet)
 {
     Frames = new List<TileTexture>();
     Frames.Add(new TileTexture(texture, sheet));
     FrameLength = RenderTime.FromMillisecs(1);
 }
コード例 #24
0
        public virtual void Process(RenderTime elapsedTime)
        {
            ActionTime += elapsedTime;
            FrameTime += elapsedTime;
            if (FrameTime >= FrameLength) {
                FrameTime = FrameTime - FrameLength;
                Frame++;
            }

            if (Frame >= TextureManager.GetSpellSheet(TextureManager.SpellAnimType.Arrow, AnimationIndex).TotalFrames) {
                Frame = 0;
            }

            Distance = ActionTime.ToMillisecs() * TravelSpeed / 1000;

            if (Distance >= TotalDistance) {
                ActionDone = true;
            } else {
                Loc2D mapLoc = new Loc2D(StartLoc.X * TextureManager.TILE_SIZE, StartLoc.Y * TextureManager.TILE_SIZE);
                Operations.MoveInDirection8(ref mapLoc, Direction, Distance);
                MapLoc = mapLoc;
            }
        }
コード例 #25
0
        public virtual void Process(RenderTime elapsedTime)
        {
            ActionTime += elapsedTime;
            CurrentBurstTime += elapsedTime;
            if (CurrentBurstTime >= BurstTime) {
                CurrentBurstTime -= BurstTime;
                for (int i = 0; i < GrainsPerBurst; i++) {
                    double angle = Logic.Display.Screen.Rand.NextDouble() * MathHelper.TwoPi;
                    Loc2D particleSpeed = new Loc2D((int)(Math.Cos(angle) * Speed), (int)(Math.Sin(angle) * Speed));
                    int dist = Logic.Display.Screen.Rand.Next(StartDistance + 1);
                    Loc2D startDelta = new Loc2D((int)(Math.Cos(angle) * dist), (int)(Math.Sin(angle) * dist));
                    Display.Screen.Effects[Screen.EffectPriority.None].Add(new ParticleAnimation(AnimationIndex, FrameLength, StartLoc + startDelta, particleSpeed, new Loc2D(), Color4.White, Color4.Gray, TotalTime ));
                }
                Bursts++;
            }

            if (Bursts >= TotalBursts) {
                ActionDone = true;
            }
        }
コード例 #26
0
ファイル: TextSprite.cs プロジェクト: blastboy/PMD-Toolkit
 public virtual void Process(RenderTime elapsedTime)
 {
     ActionTime += elapsedTime;
     if (ActionTime >= TOTAL_ANIM_TIME) {
         ActionDone = true;
     } else {
         MapHeight = ActionTime.Ticks * TextureManager.TILE_SIZE * 6 / TOTAL_ANIM_TIME.Ticks;
         if (MapHeight > TextureManager.TILE_SIZE) MapHeight = TextureManager.TILE_SIZE;
     }
 }
コード例 #27
0
 public void ProcessDelay(RenderTime time)
 {
     for (int i = 0; i < BranchCount; i++)
     {
         branches[i].Delay -= time;
         if (branches[i].Delay < RenderTime.Zero)
             branches[i].Delay = RenderTime.Zero;
     }
 }
コード例 #28
0
ファイル: Screen.cs プロジェクト: blastboy/PMD-Toolkit
        public static void ProcessActions(RenderTime elapsedTime)
        {
            TotalTick += (ulong)elapsedTime.Ticks;

            outContainer.ProcessDelay(elapsedTime);

            //update music
            if (NextSong != null) {
                MusicFadeTime -= elapsedTime;
                if (MusicFadeTime.Ticks <= 0) {
                    AudioManager.BGM.Stop();
                    if (System.IO.File.Exists(NextSong))
                    {
                        Song = NextSong;
                        AudioManager.BGM.SetBGM(Song);
                        AudioManager.BGM.Play();
                        NextSong = null;
                    }
                    else
                    {
                        Song = "";
                    }
                } else {
                    AudioManager.BGM.SetVolume((float)MusicFadeTime.Ticks / (float)MUSIC_FADE_TOTAL.Ticks);
                }
            }

            //update fade
            if (CurrentFade != FadeType.None) {
                FadeTime -= elapsedTime;
                if (FadeTime.Ticks <= 0) {
                    CurrentFade = FadeType.None;
                }
            }

            //update the player
            foreach (PlayerSprite player in Players)
            {
                player.Process(elapsedTime);
            }

            //update Items
            foreach (ItemAnim item in Items)
            {
                item.Process(elapsedTime);
            }

            //update Npcs
            foreach (NpcSprite npc in Npcs) {
                npc.Process(elapsedTime);
            }

            for (int n = (int)EffectPriority.Ground; n <= (int)EffectPriority.Overlay; n++) {
                for (int i = Effects[(EffectPriority)n].Count - 1; i >= 0; i--) {
                    Effects[(EffectPriority)n][i].Process(elapsedTime);
                    if (Effects[(EffectPriority)n][i].ActionDone) Effects[(EffectPriority)n].RemoveAt(i);
                }
            }

            for (int i = Emitters.Count - 1; i >= 0; i--) {
                Emitters[i].Process(elapsedTime);
                if (Emitters[i].ActionDone) Emitters.RemoveAt(i);
            }

            //update the camera, reliant on the player
            CamOffset = FocusedCharacter.TileOffset;
        }
コード例 #29
0
        public virtual void Process(RenderTime elapsedTime)
        {
            ActionTime += elapsedTime;
            FrameTime += elapsedTime;
            if (Distance >= TotalDistance) {
                TimeSinceArrival += elapsedTime;
            }
            if (FrameTime >= FrameLength) {
                FrameTime = FrameTime - FrameLength;
                Frame++;
            }

            if (Frame >= TextureManager.GetSpellSheet(TextureManager.SpellAnimType.Beam, AnimationIndex).TotalFrames) {
                Frame = 0;
                if (Distance < TotalDistance) {
                    Distance++;
                }
            }

            if (TimeSinceArrival >= LastingTime) {
                ActionDone = true;
            }
        }