Beispiel #1
0
 protected override void KeyDownHandler(object sender, KeyboardKeyEventArgs args)
 {
     key_down[args.Key] = true;
     if (!Global.KeyPressed)
     {
         ConsoleKey ck = Global.GetConsoleKey(args.Key);
         if (ck != ConsoleKey.NoName)
         {
             bool alt   = KeyIsDown(Key.LAlt) || KeyIsDown(Key.RAlt);
             bool shift = KeyIsDown(Key.LShift) || KeyIsDown(Key.RShift);
             bool ctrl  = KeyIsDown(Key.LControl) || KeyIsDown(Key.RControl);
             if (ck == ConsoleKey.Enter && alt)
             {
                 if (FullScreen)
                 {
                     FullScreen  = false;
                     WindowState = WindowState.Normal;
                 }
                 else
                 {
                     FullScreen  = true;
                     WindowState = WindowState.Fullscreen;
                 }
             }
             else
             {
                 Global.KeyPressed = true;
                 Global.LastKey    = new ConsoleKeyInfo(Global.GetChar(ck, shift), ck, shift, alt, ctrl);
             }
         }
         MouseUI.RemoveHighlight();
         MouseUI.RemoveMouseover();
     }
 }
Beispiel #2
0
        void MouseWheelHandler(object sender, MouseWheelEventArgs args)
        {
            if (!Global.KeyPressed)
            {
                if (args.Delta > 0)
                {
                    switch (MouseUI.Mode)
                    {
                    case MouseMode.ScrollableMenu:
                        Global.KeyPressed = true;
                        Global.LastKey    = new ConsoleKeyInfo('8', ConsoleKey.UpArrow, false, false, false);
                        break;

                    case MouseMode.Targeting:
                        Global.KeyPressed = true;
                        Global.LastKey    = new ConsoleKeyInfo((char)9, ConsoleKey.Tab, true, false, false);
                        break;

                    case MouseMode.Map:
                        Global.KeyPressed = true;
                        Global.LastKey    = new ConsoleKeyInfo((char)9, ConsoleKey.Tab, false, false, false);
                        break;
                    }
                }
                if (args.Delta < 0)
                {
                    switch (MouseUI.Mode)
                    {
                    case MouseMode.ScrollableMenu:
                        Global.KeyPressed = true;
                        Global.LastKey    = new ConsoleKeyInfo('2', ConsoleKey.DownArrow, false, false, false);
                        break;

                    case MouseMode.Targeting:
                        Global.KeyPressed = true;
                        Global.LastKey    = new ConsoleKeyInfo((char)9, ConsoleKey.Tab, false, false, false);
                        break;

                    case MouseMode.Map:
                        Global.KeyPressed = true;
                        Global.LastKey    = new ConsoleKeyInfo((char)9, ConsoleKey.Tab, false, false, false);
                        break;
                    }
                }
            }
            MouseUI.RemoveHighlight();
            MouseUI.RemoveMouseover();
        }
Beispiel #3
0
        void HandleMiddleClick()
        {
            if (!Global.KeyPressed)
            {
                Global.KeyPressed = true;
                switch (MouseUI.Mode)
                {
                case MouseMode.Map:
                    Global.LastKey = new ConsoleKeyInfo('v', ConsoleKey.V, false, false, false);
                    break;

                default:
                    Global.LastKey = new ConsoleKeyInfo((char)27, ConsoleKey.Escape, false, false, false);
                    break;
                }
            }
            MouseUI.RemoveHighlight();
            MouseUI.RemoveMouseover();
        }
Beispiel #4
0
 void MouseLeaveHandler(object sender, EventArgs args)
 {
     MouseUI.RemoveHighlight();
 }
Beispiel #5
0
        void MouseClickHandler(object sender, MouseButtonEventArgs args)
        {
            if (MouseUI.IgnoreMouseClicks)
            {
                return;
            }
            if (args.Button == MouseButton.Middle)
            {
                HandleMiddleClick();
                return;
            }
            if (args.Button == MouseButton.Right)
            {
                HandleRightClick();
                return;
            }
            int row;
            int col;

            if (FullScreen)
            {
                row = (int)(args.Y - ClientRectangle.Height * ((1.0f - screen_multiplier_h) * 0.5f)) / cell_h;
                col = (int)(args.X - ClientRectangle.Width * ((1.0f - screen_multiplier_w) * 0.5f)) / cell_w;
            }
            else
            {
                row = args.Y / cell_h;
                col = args.X / cell_w;
            }
            Button b = MouseUI.GetButton(row, col);

            if (!Global.KeyPressed)
            {
                Global.KeyPressed = true;
                if (b != null)
                {
                    bool shifted = (b.mods & ConsoleModifiers.Shift) == ConsoleModifiers.Shift;
                    Global.LastKey = new ConsoleKeyInfo(Global.GetChar(b.key, shifted), b.key, shifted, false, false);
                }
                else
                {
                    switch (MouseUI.Mode)
                    {
                    case MouseMode.Map:
                    {
                        int map_row = row - Global.MAP_OFFSET_ROWS;
                        int map_col = col - Global.MAP_OFFSET_COLS;
                        if (map_row >= 0 && map_row < Global.ROWS && map_col >= 0 && map_col < Global.COLS)
                        {
                            if (map_row == Actor.player.row && map_col == Actor.player.col)
                            {
                                Global.LastKey = new ConsoleKeyInfo('.', ConsoleKey.OemPeriod, false, false, false);
                            }
                            else
                            {
                                if (KeyIsDown(Key.LControl) || KeyIsDown(Key.RControl) || (Math.Abs(map_row - Actor.player.row) <= 1 && Math.Abs(map_col - Actor.player.col) <= 1))
                                {
                                    int rowchange = 0;
                                    int colchange = 0;
                                    if (map_row > Actor.player.row)
                                    {
                                        rowchange = 1;
                                    }
                                    else
                                    {
                                        if (map_row < Actor.player.row)
                                        {
                                            rowchange = -1;
                                        }
                                    }
                                    if (map_col > Actor.player.col)
                                    {
                                        colchange = 1;
                                    }
                                    else
                                    {
                                        if (map_col < Actor.player.col)
                                        {
                                            colchange = -1;
                                        }
                                    }
                                    ConsoleKey dir_key = (ConsoleKey)(ConsoleKey.NumPad0 + Actor.player.DirectionOf(Actor.M.tile[Actor.player.row + rowchange, Actor.player.col + colchange]));
                                    Global.LastKey = new ConsoleKeyInfo(Global.GetChar(dir_key, false), dir_key, false, false, false);
                                }
                                else
                                {
                                    Tile nearest = Actor.M.tile[map_row, map_col];
                                    Actor.player.path = Actor.player.GetPath(nearest.row, nearest.col, -1, true, true, Actor.UnknownTilePathingPreference.UnknownTilesAreOpen);
                                    if (Actor.player.path.Count > 0)
                                    {
                                        Actor.player.path.StopAtBlockingTerrain();
                                        if (Actor.player.path.Count > 0)
                                        {
                                            Actor.interrupted_path = new pos(-1, -1);
                                            ConsoleKey path_key = (ConsoleKey)(ConsoleKey.NumPad0 + Actor.player.DirectionOf(Actor.player.path[0]));
                                            Global.LastKey = new ConsoleKeyInfo(Global.GetChar(path_key, false), path_key, false, false, false);
                                            Actor.player.path.RemoveAt(0);
                                        }
                                        else
                                        {
                                            Global.LastKey = new ConsoleKeyInfo(' ', ConsoleKey.Spacebar, false, false, false);
                                        }
                                    }
                                    else
                                    {
                                        //int distance_of_first_passable = -1;
                                        //List<Tile> passable_tiles = new List<Tile>();
                                        foreach (Tile t in Actor.M.TilesByDistance(map_row, map_col, true, true))
                                        {
                                            //if(distance_of_first_passable != -1 && nearest.DistanceFrom(t) > distance_of_first_passable){
                                            //nearest = passable_tiles.Last();
                                            if (t.passable)
                                            {
                                                nearest           = t;
                                                Actor.player.path = Actor.player.GetPath(nearest.row, nearest.col, -1, true, true, Actor.UnknownTilePathingPreference.UnknownTilesAreOpen);
                                                break;
                                            }

                                            /*}
                                             * if(t.passable){
                                             *      distance_of_first_passable = nearest.DistanceFrom(t);
                                             *      passable_tiles.Add(t);
                                             * }*/
                                        }
                                        if (Actor.player.path.Count > 0)
                                        {
                                            Actor.interrupted_path = new pos(-1, -1);
                                            ConsoleKey path_key = (ConsoleKey)(ConsoleKey.NumPad0 + Actor.player.DirectionOf(Actor.player.path[0]));
                                            Global.LastKey = new ConsoleKeyInfo(Global.GetChar(path_key, false), path_key, false, false, false);
                                            Actor.player.path.RemoveAt(0);
                                        }
                                        else
                                        {
                                            Global.LastKey = new ConsoleKeyInfo(' ', ConsoleKey.Spacebar, false, false, false);
                                        }
                                    }
                                }
                            }
                        }
                        else
                        {
                            Global.LastKey = new ConsoleKeyInfo((char)13, ConsoleKey.Enter, false, false, false);
                        }
                        break;
                    }

                    case MouseMode.Directional:
                    {
                        int map_row = row - Global.MAP_OFFSET_ROWS;
                        int map_col = col - Global.MAP_OFFSET_COLS;
                        if (map_row >= 0 && map_row < Global.ROWS && map_col >= 0 && map_col < Global.COLS)
                        {
                            int    dir   = Actor.player.DirectionOf(new pos(map_row, map_col));
                            pos    p     = Actor.player.p.PosInDir(dir);
                            Button dir_b = MouseUI.GetButton(Global.MAP_OFFSET_ROWS + p.row, Global.MAP_OFFSET_COLS + p.col);
                            if (dir_b != null)
                            {
                                bool shifted = (dir_b.mods & ConsoleModifiers.Shift) == ConsoleModifiers.Shift;
                                Global.LastKey = new ConsoleKeyInfo(Global.GetChar(dir_b.key, shifted), dir_b.key, shifted, false, false);
                            }
                        }
                        else
                        {
                            Global.LastKey = new ConsoleKeyInfo((char)27, ConsoleKey.Escape, false, false, false);
                        }
                        break;
                    }

                    case MouseMode.Targeting:
                    {
                        int map_row = row - Global.MAP_OFFSET_ROWS;
                        int map_col = col - Global.MAP_OFFSET_COLS;
                        if (map_row >= 0 && map_row < Global.ROWS && map_col >= 0 && map_col < Global.COLS)
                        {
                            Global.LastKey = new ConsoleKeyInfo((char)13, ConsoleKey.Enter, false, false, false);
                        }
                        else
                        {
                            Global.LastKey = new ConsoleKeyInfo((char)27, ConsoleKey.Escape, false, false, false);
                        }
                        break;
                    }

                    case MouseMode.YesNoPrompt:
                        Global.LastKey = new ConsoleKeyInfo('y', ConsoleKey.Y, false, false, false);
                        break;

                    case MouseMode.Inventory:
                        Global.LastKey = new ConsoleKeyInfo('a', ConsoleKey.A, false, false, false);
                        break;

                    default:
                        Global.LastKey = new ConsoleKeyInfo((char)13, ConsoleKey.Enter, false, false, false);
                        break;
                    }
                }
            }
            MouseUI.RemoveHighlight();
            MouseUI.RemoveMouseover();
        }
Beispiel #6
0
        void MouseMoveHandler(object sender, MouseMoveEventArgs args)
        {
            if (MouseUI.IgnoreMouseMovement)
            {
                return;
            }
            int row;
            int col;

            if (FullScreen)
            {
                row = (int)(args.Y - ClientRectangle.Height * ((1.0f - screen_multiplier_h) * 0.5f)) / cell_h;               //todo: give this its own var?
                col = (int)(args.X - ClientRectangle.Width * ((1.0f - screen_multiplier_w) * 0.5f)) / cell_w;
            }
            else
            {
                row = args.Y / cell_h;
                col = args.X / cell_w;
            }
            switch (MouseUI.Mode)
            {
            case MouseMode.Targeting:
            {
                int    map_row = row - Global.MAP_OFFSET_ROWS;
                int    map_col = col - Global.MAP_OFFSET_COLS;
                Button b       = MouseUI.GetButton(row, col);
                if (MouseUI.Highlighted != null && MouseUI.Highlighted != b)
                {
                    MouseUI.RemoveHighlight();
                }
                if (args.XDelta == 0 && args.YDelta == 0)
                {
                    return;                     //don't re-highlight immediately after a click
                }
                if (b != null)
                {
                    if (b != MouseUI.Highlighted)
                    {
                        MouseUI.Highlighted = b;
                        colorchar[,] array  = new colorchar[b.height, b.width];
                        for (int i = 0; i < b.height; ++i)
                        {
                            for (int j = 0; j < b.width; ++j)
                            {
                                array[i, j]         = Screen.Char(i + b.row, j + b.col);
                                array[i, j].bgcolor = Color.Blue;
                            }
                        }
                        Screen.UpdateGLBuffer(b.row, b.col, array);
                    }
                }
                else
                {
                    if (!Global.KeyPressed && (row != MouseUI.LastRow || col != MouseUI.LastCol) && !KeyIsDown(Key.LControl) && !KeyIsDown(Key.RControl))
                    {
                        MouseUI.LastRow   = row;
                        MouseUI.LastCol   = col;
                        Global.KeyPressed = true;
                        if (map_row >= 0 && map_row < Global.ROWS && map_col >= 0 && map_col < Global.COLS)
                        {
                            ConsoleKey key = ConsoleKey.F1;
                            Global.LastKey = new ConsoleKeyInfo(Global.GetChar(key, false), key, false, false, false);
                        }
                        else
                        {
                            ConsoleKey key = ConsoleKey.F2;
                            Global.LastKey = new ConsoleKeyInfo(Global.GetChar(key, false), key, false, false, false);
                        }
                    }
                }
                break;
            }

            case MouseMode.Directional:
            {
                int map_row = row - Global.MAP_OFFSET_ROWS;
                int map_col = col - Global.MAP_OFFSET_COLS;
                if (map_row >= 0 && map_row < Global.ROWS && map_col >= 0 && map_col < Global.COLS)
                {
                    int    dir   = Actor.player.DirectionOf(new pos(map_row, map_col));
                    pos    p     = Actor.player.p.PosInDir(dir);
                    Button dir_b = MouseUI.GetButton(Global.MAP_OFFSET_ROWS + p.row, Global.MAP_OFFSET_COLS + p.col);
                    if (MouseUI.Highlighted != null && MouseUI.Highlighted != dir_b)
                    {
                        MouseUI.RemoveHighlight();
                    }
                    if (dir_b != null && dir_b != MouseUI.Highlighted)
                    {
                        MouseUI.Highlighted = dir_b;
                        colorchar[,] array  = new colorchar[1, 1];
                        array[0, 0]         = Screen.Char(Global.MAP_OFFSET_ROWS + p.row, Global.MAP_OFFSET_COLS + p.col);
                        array[0, 0].bgcolor = Color.Blue;
                        Screen.UpdateGLBuffer(dir_b.row, dir_b.col, array);
                    }
                }
                else
                {
                    if (MouseUI.Highlighted != null)
                    {
                        MouseUI.RemoveHighlight();
                    }
                }
                break;
            }

            default:
            {
                Button b = MouseUI.GetButton(row, col);
                if (MouseUI.Highlighted != null && MouseUI.Highlighted != b)
                {
                    MouseUI.RemoveHighlight();
                }
                if (args.XDelta == 0 && args.YDelta == 0)
                {
                    return;                     //don't re-highlight immediately after a click
                }
                if (b != null && b != MouseUI.Highlighted)
                {
                    MouseUI.Highlighted = b;
                    colorchar[,] array  = new colorchar[b.height, b.width];
                    for (int i = 0; i < b.height; ++i)
                    {
                        for (int j = 0; j < b.width; ++j)
                        {
                            array[i, j]         = Screen.Char(i + b.row, j + b.col);
                            array[i, j].bgcolor = Color.Blue;
                        }
                    }
                    Screen.UpdateGLBuffer(b.row, b.col, array);

                    /*for(int i=b.row;i<b.row+b.height;++i){
                     *      for(int j=b.col;j<b.col+b.width;++j){
                     *              colorchar cch = Screen.Char(i,j);
                     *              cch.bgcolor = Color.Blue;
                     *              UpdateVertexArray(i,j,cch.c,ConvertColor(cch.color),ConvertColor(cch.bgcolor));
                     *      }
                     * }*/
                }
                else
                {
                    if (MouseUI.Mode == MouseMode.Map)
                    {
                        int            map_row = row - Global.MAP_OFFSET_ROWS;
                        int            map_col = col - Global.MAP_OFFSET_COLS;
                        PhysicalObject o       = null;
                        if (map_row >= 0 && map_row < Global.ROWS && map_col >= 0 && map_col < Global.COLS)
                        {
                            o = MouseUI.mouselook_objects[map_row, map_col];
                            if (MouseUI.VisiblePath && o == null)
                            {
                                o = Actor.M.tile[map_row, map_col];
                            }
                        }
                        if (MouseUI.mouselook_current_target != null && MouseUI.mouselook_current_target != o)
                        {
                            MouseUI.RemoveMouseover();
                        }
                        if (o != null && o != MouseUI.mouselook_current_target)
                        {
                            MouseUI.mouselook_current_target = o;
                            bool description_on_right = false;

                            /*int max_length = 29;
                             * if(map_col - 6 < max_length){
                             *      max_length = map_col - 6;
                             * }
                             * if(max_length < 20){
                             *      description_on_right = true;
                             *      max_length = 29;
                             * }*/
                            int max_length = MouseUI.MaxDescriptionBoxLength;
                            if (map_col <= 32)
                            {
                                description_on_right = true;
                            }
                            List <colorstring> desc_box = null;
                            Actor a = o as Actor;
                            if (a != null)
                            {
                                desc_box = Actor.MonsterDescriptionBox(a, true, max_length);
                            }
                            else
                            {
                                Item i = o as Item;
                                if (i != null)
                                {
                                    desc_box = Actor.ItemDescriptionBox(i, true, true, max_length);
                                }
                            }
                            if (desc_box != null)
                            {
                                int h        = desc_box.Count;
                                int w        = desc_box[0].Length();
                                int player_r = Actor.player.row;
                                int player_c = Actor.player.col;
                                colorchar[,] array = new colorchar[h, w];
                                if (description_on_right)
                                {
                                    for (int i = 0; i < h; ++i)
                                    {
                                        for (int j = 0; j < w; ++j)
                                        {
                                            array[i, j] = desc_box[i][j];
                                            if (i == player_r && j + Global.COLS - w == player_c)
                                            {
                                                Screen.CursorVisible = false;
                                                player_r             = -1;                                     //to prevent further attempts to set CV to false
                                            }
                                        }
                                    }
                                    Screen.UpdateGLBuffer(Global.MAP_OFFSET_ROWS, Global.MAP_OFFSET_COLS + Global.COLS - w, array);
                                }
                                else
                                {
                                    for (int i = 0; i < h; ++i)
                                    {
                                        for (int j = 0; j < w; ++j)
                                        {
                                            array[i, j] = desc_box[i][j];
                                            if (i == player_r && j == player_c)
                                            {
                                                Screen.CursorVisible = false;
                                                player_r             = -1;
                                            }
                                        }
                                    }
                                    Screen.UpdateGLBuffer(Global.MAP_OFFSET_ROWS, Global.MAP_OFFSET_COLS, array);
                                }
                            }
                            if (MouseUI.VisiblePath)
                            {
                                MouseUI.mouse_path = Actor.player.GetPath(o.row, o.col, -1, true, true, Actor.UnknownTilePathingPreference.UnknownTilesAreOpen);
                                if (MouseUI.mouse_path.Count == 0)
                                {
                                    foreach (Tile t in Actor.M.TilesByDistance(o.row, o.col, true, true))
                                    {
                                        if (t.passable)
                                        {
                                            MouseUI.mouse_path = Actor.player.GetPath(t.row, t.col, -1, true, true, Actor.UnknownTilePathingPreference.UnknownTilesAreOpen);
                                            break;
                                        }
                                    }
                                }
                                pos box_start = new pos(0, 0);
                                int box_h     = -1;
                                int box_w     = -1;
                                if (desc_box != null)
                                {
                                    box_h = desc_box.Count;
                                    box_w = desc_box[0].Length();
                                    if (description_on_right)
                                    {
                                        box_start = new pos(0, Global.COLS - box_w);
                                    }
                                }
                                foreach (pos p in MouseUI.mouse_path)
                                {
                                    if (desc_box != null && p.row < box_start.row + box_h && p.row >= box_start.row && p.col < box_start.col + box_w && p.col >= box_start.col)
                                    {
                                        continue;
                                    }
                                    colorchar cch = Screen.MapChar(p.row, p.col);
                                    cch.bgcolor = Color.DarkGreen;
                                    if (cch.color == Color.DarkGreen)
                                    {
                                        cch.color = Color.Black;
                                    }
                                    //Game.gl.UpdateVertexArray(p.row+Global.MAP_OFFSET_ROWS,p.col+Global.MAP_OFFSET_COLS,text_surface,0,(int)cch.c);
                                    Game.gl.UpdateVertexArray(p.row + Global.MAP_OFFSET_ROWS, p.col + Global.MAP_OFFSET_COLS, text_surface, 0, (int)cch.c, cch.color.GetFloatValues(), cch.bgcolor.GetFloatValues());
                                }
                                if (MouseUI.mouse_path != null && MouseUI.mouse_path.Count == 0)
                                {
                                    MouseUI.mouse_path = null;
                                }
                            }
                        }
                    }
                }
                break;
            }
            }
        }