Esempio n. 1
0
        public override void Draw(SpriteBatch spriteBatch)
        {
            if (!MenusHidden)
            {
                spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
                PanelNodes.Draw(spriteBatch, -MenuLoc);
                if (Moving && Move_Page == Page)
                {
                    Move_Cursor.draw(spriteBatch, -(MenuLoc + Panels[Move_Index].loc));
                }

                Left_Page_Arrow.draw(spriteBatch, -MenuLoc);
                Right_Page_Arrow.draw(spriteBatch, -MenuLoc);
                Cursor.draw(spriteBatch, -MenuLoc);
                spriteBatch.End();

                if (Suspend_Panel != null)
                {
                    Suspend_Panel.Draw(spriteBatch);
                }

                if (Cursor.visible)
                {
                    spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
                    CancelButton.Draw(spriteBatch);
                    spriteBatch.End();
                }
            }
        }
Esempio n. 2
0
        private void update_input()
        {
            Left_Page_Arrow.UpdateInput(-MenuLoc);
            Right_Page_Arrow.UpdateInput(-MenuLoc);

            if (!Global.Input.pressed(Inputs.Up) && !Global.Input.pressed(Inputs.Down))
            {
                if (Page > 0 && (Global.Input.repeated(Inputs.Left) ||
                                 Global.Input.gesture_triggered(TouchGestures.SwipeRight)))
                {
                    Global.game_system.play_se(System_Sounds.Menu_Move2);
                    Page--;
                    refresh_page();
                }
                if (Page < Max_Page && (Global.Input.repeated(Inputs.Right) ||
                                        Global.Input.gesture_triggered(TouchGestures.SwipeLeft)))
                {
                    Global.game_system.play_se(System_Sounds.Menu_Move2);
                    Page++;
                    refresh_page();
                }
            }
            if (!Global.Input.pressed(Inputs.Up))
            {
                locked_inputs.Remove(Inputs.Up);
            }
            if (!Global.Input.pressed(Inputs.Down))
            {
                locked_inputs.Remove(Inputs.Down);
            }
        }
Esempio n. 3
0
        protected override void UpdateMenu(bool active)
        {
            // Block inputs while waiting for IO
            if (WaitingForIO)
            {
                if (!Global.copying && !Global.move_file && !Global.delete_file)
                {
                    this.waiting_for_io = false;
                    refresh_page();
                }
                else
                {
                    active = false;
                }
            }

            Cursor.update();
            Left_Page_Arrow.update();
            Right_Page_Arrow.update();

            if (active)
            {
                update_input();
            }
            update_ui(active);

            if (Moving)
            {
                update_move_darken();
            }
        }
Esempio n. 4
0
        protected override void draw_window(SpriteBatch sprite_batch)
        {
            Vector2 offset = PageLoc;

            draw_leader_data(sprite_batch, offset);
            draw_file_data(sprite_batch, offset);
            if (page == 0 || ChangingPage)
            {
                draw_team_data(sprite_batch, offset);
            }
            if (page == 1 || ChangingPage)
            {
                draw_gameplay_data(sprite_batch, offset);
                draw_ranking_data(sprite_batch, offset);
            }
            draw_objective_data(sprite_batch, offset);

            sprite_batch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
            // Banner
            BannerBg.draw(sprite_batch);
            Banner.draw(sprite_batch);

            // Page Arrows
            if (page == 0 || ChangingPage)
            {
                Right_Page_Arrow.draw(sprite_batch);
            }
            if (page == 1 || ChangingPage)
            {
                Left_Page_Arrow.draw(sprite_batch);
            }
            sprite_batch.End();
        }
Esempio n. 5
0
        protected override void UpdateMenu(bool active)
        {
            update_map_sprite();
            Cursor.update();
            Counter.update();
            Left_Page_Arrow.update();
            Right_Page_Arrow.update();

            base.UpdateMenu(active);

            if (ChangingPage)
            {
                (PageLoc.X < target_page_loc.X ? Right_Page_Arrow : Left_Page_Arrow).twirling_update();
                float distance = Math.Abs(PageLoc.X - target_page_loc.X) / 2;
                distance  = MathHelper.Clamp(MathHelper.Lerp(0, distance, ChangingPageTime / 12f), 0, distance);
                distance  = Math.Min(distance, 32);
                distance  = Math.Max(distance, 1);
                distance  = (float)Math.Pow(2, Math.Round(Math.Log(distance, 2)));
                PageLoc.X = (float)Additional_Math.double_closer(PageLoc.X, target_page_loc.X, (int)distance);

                ChangingPageTime++;
                if (PageLoc.X == target_page_loc.X)
                {
                    ChangingPage = false;
                }
            }
        }
Esempio n. 6
0
        private void update_input()
        {
            Left_Page_Arrow.UpdateInput(new Vector2(0, Offset.Y));
            Right_Page_Arrow.UpdateInput(new Vector2(0, Offset.Y));
            if (Delay != 0)
            {
                return;
            }

            if (Global.Input.pressed(Inputs.Up) || Global.Input.mouseScroll > 0 ||
                Global.Input.gesture_triggered(TouchGestures.SwipeDown))
            {
                Delay     = 14;
                Direction = 8;
            }
            else if (Global.Input.pressed(Inputs.Down) || Global.Input.mouseScroll < 0 ||
                     Global.Input.gesture_triggered(TouchGestures.SwipeUp))
            {
                Delay     = 14;
                Direction = 2;
            }
            else if (Global.Input.pressed(Inputs.Left) ||
                     Global.Input.gesture_triggered(TouchGestures.SwipeRight))
            {
                Delay     = 22;
                Direction = 4;
            }
            else if (Global.Input.pressed(Inputs.Right) ||
                     Global.Input.gesture_triggered(TouchGestures.SwipeLeft))
            {
                Delay     = 22;
                Direction = 6;
            }
            else if (Global.Input.triggered(Inputs.B) ||
                     Global.Input.mouse_click(MouseButtons.Right) ||
                     CancelButton.consume_trigger(MouseButtons.Left) ||
                     CancelButton.consume_trigger(TouchGestures.Tap))
            {
                Global.game_system.play_se(System_Sounds.Cancel);
                if (!Actors)
                {
                    Game_Unit status_unit = Global.game_map.units[Global.game_temp.status_unit_id];
                    status_unit.highlighted         = false;
                    Global.game_temp.status_unit_id = -1;
                }
                Closing              = true;
                Black_Screen_Timer   = BLACK_SCREEN_TIME;
                Black_Screen.visible = true;
            }
            else if (Global.Input.triggered(Inputs.R))
            {
                open_help();
            }
            else if (Global.Input.triggered(Inputs.A) && (unit.is_rescued || unit.is_rescuing))
            {
                if (Actors)
                {
                    bool same_team = false;
                    if (unit.is_rescued)
                    {
                        if (Global.game_map.units[unit.rescued].same_team(unit))
                        {
                            same_team = true;
                        }
                    }
                    else
                    if (Global.game_map.units[unit.rescuing].same_team(unit))
                    {
                        same_team = true;
                    }
                    if (!same_team)
                    {
                        return;
                    }
                }
                if (unit.is_rescued && !Team.Contains(unit.rescued) &&
                    Global.game_map.units[unit.rescued].same_team(unit))
                {
                    return;
                }
                if (unit.is_rescuing && !Team.Contains(unit.rescuing) &&
                    Global.game_map.units[unit.rescuing].same_team(unit))
                {
                    return;
                }

                Delay        = 14;
                Direction    = unit.is_rescuing ? 2 : 8;
                Goto_Rescued = true;
            }
        }
Esempio n. 7
0
        protected override void UpdateMenu(bool active)
        {
            update_map_sprite();
            update_direction();
            // Black Screen
            update_black_screen();
            // Inputs
            bool input = active && Delay == 0 && !Closing && Black_Screen_Timer <= 0;

#if DEBUG
            if (Help_Window != null && input && Global.Input.pressed(Inputs.X))
            {
                DirectionFlags dir = Global.Input.dir_triggered();
                if (dir != DirectionFlags.None)
                {
                    StatusNodes[page].ActiveNode.cheat(this.unit, dir);
                    move_to(Help_Index);
                    Help_Window.add_remaining_text();

                    foreach (var status_page in Pages)
                    {
                        status_page.refresh(this.unit);
                    }
                    foreach (StatusUINode node in TopPanelNodes)
                    {
                        node.refresh(unit);
                    }
                }
                input = false;
            }
#endif

            // Cancel button
            CancelButton.Update(input);

            StatusNodes[page].Update(!input ? ControlSet.None :
                                     (Help_Window != null ?
                                      ControlSet.Movement : (ControlSet.Mouse | ControlSet.Touch)));

            if (input)
            {
                if (Help_Window == null)
                {
                    update_input();

                    var help_index = StatusNodes[page].consume_triggered(
                        MouseButtons.Left, TouchGestures.Tap);
                    if (help_index.IsNothing)
                    {
                        help_index = StatusNodes[page].consume_triggered(
                            TouchGestures.LongPress);
                    }

                    if (help_index.IsSomething)
                    {
                        Help_Index = StatusNodes[page][help_index].HelpLabel;
                        open_help();
                    }
                }
                else
                {
                    if (StatusNodes[page].ActiveNode.HelpLabel != Help_Index)
                    {
                        move_to(StatusNodes[page].ActiveNode.HelpLabel);
                    }

                    var help_index = StatusNodes[page].consume_triggered(
                        MouseButtons.Left, TouchGestures.Tap);
                    var help_cancel_index = StatusNodes[page].consume_triggered(
                        TouchGestures.LongPress);

                    if (Global.Input.triggered(Inputs.B) ||
                        Global.Input.triggered(Inputs.R) ||
                        Global.Input.mouse_click(MouseButtons.Right) ||
                        help_cancel_index.IsSomething ||
                        CancelButton.consume_trigger(MouseButtons.Left) ||
                        CancelButton.consume_trigger(TouchGestures.Tap))
                    {
                        close_help();
                    }

                    /* //Debug
                     * if (Global.Input.repeated(Inputs.Down))
                     * {
                     *  if (move(2))
                     *  {
                     *
                     *  }
                     * }
                     * if (Global.Input.repeated(Inputs.Up))
                     * {
                     *  if (move(8))
                     *  {
                     *
                     *  }
                     * }
                     * if (Global.Input.repeated(Inputs.Right))
                     * {
                     *  if (move(6))
                     *  {
                     *
                     *  }
                     * }
                     * if (Global.Input.repeated(Inputs.Left))
                     * {
                     *  if (move(4))
                     *  {
                     *
                     *  }
                     * }
                     * else if (Global.Input.triggered(Inputs.R) || Global.Input.triggered(Inputs.B))
                     * {
                     *  close_help();
                     * }*/
                }
                StatusCursors[page].update();
            }

            if (Help_Window != null)
            {
                Help_Window.update();
            }
            Background.update();
            // Top Panel
            Top_Panel.update();
            foreach (TextSprite label in Battle_Stat_Labels)
            {
                label.update();
            }
            // Pages
            foreach (Status_Page status_page in Pages)
            {
                status_page.update();
            }
            Left_Page_Arrow.update();
            Right_Page_Arrow.update();
        }
Esempio n. 8
0
        public override void Draw(SpriteBatch sprite_batch)
        {
            Vector2 offset = new Vector2(0, Offset.Y);

            sprite_batch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);

            Background.draw(sprite_batch);
            // Draw Windows //
            // Page //
            Pages[page].draw(sprite_batch, Offset);
            if (Delay > 0 && changing_page)
            {
                if (Direction == 6 ^ Delay < 12)
                {
                    Pages[(page + 1 + Pages.Count) % Pages.Count].draw(sprite_batch, Offset - new Vector2(PAGE_SPACING + 320, 0));
                }
                else
                {
                    Pages[(page - 1 + Pages.Count) % Pages.Count].draw(sprite_batch, Offset + new Vector2(PAGE_SPACING + 320, 0));
                }
            }
            //if (changing_page)
            //    Background.draw(sprite_batch, new Color(Bg_Alpha, Bg_Alpha, Bg_Alpha, Bg_Alpha));
            // Top Panel //
            // Page Arrows
            Left_Page_Arrow.draw(sprite_batch, offset);
            Right_Page_Arrow.draw(sprite_batch, offset);
            Face_Bg.draw(sprite_batch, offset);

            if (Input.ControlScheme == ControlSchemes.Touch)
            {
                CancelButton.Draw(sprite_batch);
            }
            sprite_batch.End();

            Face.draw(sprite_batch, offset);

            sprite_batch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
            Top_Panel.draw(sprite_batch, offset);
            Platform.draw(sprite_batch, offset);
            //LvLabel.draw(sprite_batch, offset);
            //HpLabel.draw(sprite_batch, offset);
            //Lv_Hp_Labels_Other.draw(sprite_batch, offset);
            //foreach (RightAdjustedText stat in Lv_Hp_Values)
            //    stat.draw(sprite_batch, offset);
            foreach (TextSprite label in Battle_Stat_Labels)
            {
                label.draw(sprite_batch, offset);
            }

            Map_Sprite.draw(sprite_batch, offset);

            foreach (var node in TopPanelNodes)
            {
                node.Draw(sprite_batch, offset);
            }

            if (Global.game_map.icons_visible)
            {
                Rescue_Icon.draw(sprite_batch, offset);
            }
            if (changing_unit)
            {
                Color bg_tint = Background.tint;
                Background.tint = new Color(Bg_Alpha, Bg_Alpha, Bg_Alpha, Bg_Alpha);
                Background.draw(sprite_batch);
                Background.tint = bg_tint;
            }
            Black_Screen.draw(sprite_batch);
            sprite_batch.End();

            sprite_batch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
            if (Help_Window != null) //Debug
            {
                StatusCursors[page].draw(sprite_batch, offset);
            }
            sprite_batch.End();
            if (Help_Window != null)
            {
                Help_Window.draw(sprite_batch);
            }
        }