예제 #1
0
파일: Map.cs 프로젝트: Tomash667/hunters
 public Tile this[Pos pos]
 {
     get
     {
         return m[pos.x + pos.y * w];
     }
 }
예제 #2
0
파일: Map.cs 프로젝트: Tomash667/hunters
        public void CalculateFov(Pos pos, int radius)
        {
            if (radius != mask_radius)
                CreateMask(radius);

            for (int i = 0; i < w * h; ++i)
                m[i].flags &= ~Tile.Flags.Lit;

            source = pos;
            shallowOrigin = new Pos(fov_sourceOffset, fov_sourceLimit);
            steepOrigin = new Pos(fov_sourceLimit, fov_sourceOffset);
            extent = new Pos(radius, radius);

            quadrant = new Pos(1,1);
            calculateFovQuadrant();

            quadrant = new Pos(-1,1);
            calculateFovQuadrant();

            quadrant = new Pos(-1,-1);
            calculateFovQuadrant();

            quadrant = new Pos(1,-1);
            calculateFovQuadrant();
        }
예제 #3
0
파일: Game.cs 프로젝트: Tomash667/hunters
        public void DrawDialog()
        {
            Pos dialog_pos = (Console.Size - dialog_size) / 2;

            DrawWindow(dialog_pos, dialog_size, Console.MakeColor(ConsoleColor.Black, ConsoleColor.Gray));

            // text
            for(int y=0; y<lines.Count; ++y)
            {
                string s = lines[y].text;
                Pos off = new Pos(dialog_pos.x + 1, dialog_pos.y + 1);

                switch (lines[y].align)
                {
                    case Line.Align.Left:
                    default:
                        break;
                    case Line.Align.Center:
                        off.x += (dialog_size.x - s.Length) / 2;
                        break;
                    case Line.Align.Right:
                        off.x += dialog_size.x - s.Length;
                        break;
                }

                for(int x=0; x<s.Length; ++x)
                    Console.buf[x + off.x + (y + off.y) * Console.Width].Char.UnicodeChar = s[x];
            }
        }
예제 #4
0
파일: Map.cs 프로젝트: Tomash667/hunters
 public Bump(Pos _pos, Bump _parent)
 {
     pos = _pos;
     parent = _parent;
 }
예제 #5
0
파일: Map.cs 프로젝트: Tomash667/hunters
 public bool isBelowOrContains(Pos pt)
 {
     return relativeSlope(pt) >= 0;
 }
예제 #6
0
파일: Map.cs 프로젝트: Tomash667/hunters
 public bool isAboveOrContains(Pos pt)
 {
     return relativeSlope(pt) <= 0;
 }
예제 #7
0
파일: Map.cs 프로젝트: Tomash667/hunters
 public bool doesContain(Pos pt)
 {
     return relativeSlope(pt) == 0;
 }
예제 #8
0
파일: Map.cs 프로젝트: Tomash667/hunters
 void visit(Pos pos)
 {
     Tile t = m[pos.x + pos.y * w];
     t.flags |= Tile.Flags.Known | Tile.Flags.Lit;
 }
예제 #9
0
 public static void WriteText(string text, Pos pos)
 {
     int x = pos.x;
     int y = pos.y;
     for (int i = 0; i < text.Length; ++i)
     {
         if (text[i] == '\n')
         {
             x = pos.x;
             ++y;
         }
         else if(text[i] != '\r')
         {
             Console.buf[x + y * Console.Width].Char.UnicodeChar = text[i];
             ++x;
         }
     }
 }
예제 #10
0
파일: Game.cs 프로젝트: Tomash667/hunters
        bool UpdatePlayer()
        {
            Dir dir = Dir.None;

            ConsoleKeyInfo k = Console.ReadKey();
            if(GetDir(k.Key, out dir))
            {
                DirInfo di = dirs[(int)dir];
                Pos new_pos = player.pos + di.change;

                if (new_pos.x < 0 || new_pos.y < 0 || new_pos.x >= map.w || new_pos.y >= map.h)
                {
                    // can't move, out of world
                }
                else
                {
                    Tile t = map[new_pos];
                    if (t.unit != null)
                    {
                        Attack(player, t.unit);
                        return true;
                    }
                    else if (map.CanMove(player.pos, new_pos, di.diagonal))
                    {
                        t.unit = player;
                        map[player.pos].unit = null;
                        player.pos = new_pos;
                        map.CalculateFov(player.pos, RADIUS);
                        if (t.items != null)
                        {
                            if (t.items.Count == 1)
                            {
                                if (t.items[0].count == 1)
                                    AddText("There is {0} on ground.", t.items[0].item.name);
                                else
                                    AddText("There are {0} {1}s ground.", t.items[0].count, t.items[0].item.name);
                            }
                            else
                                AddText("There are many items on ground.");
                        }
                        return true;
                    }
                    else if (t.type == Tile.Type.Door && (t.flags & Tile.Flags.Open) == 0)
                    {
                        // open doors
                        t.flags |= Tile.Flags.Open;
                        map.CalculateFov(player.pos, RADIUS);
                        AddText("You opened door.");
                    }
                }
            }
            else if (k.KeyChar == 'Q')
            {
                ShowDialog("$amQuit WITHOUT saving?\n(y/n)", HandleQuitDialog);
            }
            else if(k.KeyChar == 'S')
            {
                SaveGame();
            }
            else if (k.KeyChar == '?')
            {
                ShowDialog("$amControls\n==========\n$a"
                    + "lNumpad 1-9 - walk around, Numpad 5 - wait, l - look\n"
                    + "t - throw\n"
                    + "o - open door, c - close door\n"
                    + "i - inventory, e - equip, r - remove, u - use, d - drop, g/G - get\n"
                    + "? - controls, S - save, Q - quit");
            }
            else if (k.Key == ConsoleKey.NumPad5)
            {
                // wait turn
                return true;
            }
            else if (k.KeyChar == 'i')
                inv.Show(Inventory.Action.None);
            else if (k.KeyChar == 'd')
                inv.Show(Inventory.Action.Drop);
            else if (k.KeyChar == 'g' || k.KeyChar == 'G')
            {
                Tile t = map[player.pos];
                if (t.items == null)
                    ShowDialog("There is nothing on ground.");
                else if (t.items.Count == 1 && k.KeyChar == 'g')
                {
                    player.AddItem(t.items[0]);
                    if (t.items[0].count == 1)
                        AddText("You picked {0} from ground.", t.items[0].item.name);
                    else
                        AddText("You picked {0} {1}s from ground.", t.items[0].count, t.items[0].item.name);
                    t.items = null;
                    return true;
                }
                else
                    inv.ShowGet(t.items);
            }
            else if (k.KeyChar == 'e')
            {
                // equip item
                inv.Show(Inventory.Action.Equip);
            }
            else if (k.KeyChar == 'r')
            {
                // remove item
                inv.Show(Inventory.Action.Remove);
            }
            else if (k.KeyChar == 'u')
            {
                // use item
                inv.Show(Inventory.Action.Use);
            }
            else if (k.KeyChar == 'l')
            {
                // look around
                mode = Mode.Look;
                look_pos = player.pos;
                look_timer = 0;
                look_blink = true;
            }
            else if (k.KeyChar == 't')
            {
                // throw, use last throwable
                if (throw_prev != null)
                {
                    var to_throw = player.items.GetIndexes().Where(x => x.item.item == throw_prev).SingleOrDefault();
                    if (to_throw.item == null)
                        throw_prev = null;
                    else
                    {
                        throw_index = to_throw.index;
                        mode = Mode.Throw;
                        PickThrowTarget();
                    }
                }
                if (throw_prev == null)
                    inv.Show(Inventory.Action.Throw);
            }
            else if (k.KeyChar == 'T')
            {
                // throw, pick what to throw
                inv.Show(Inventory.Action.Throw);
            }
            else if (k.KeyChar == 'o')
            {
                var tiles = map.GetNearTiles(player.pos).Where(x => x.type == Tile.Type.Door && (x.flags & Tile.Flags.Open) == 0);
                if (tiles.Any())
                {
                    if (tiles.Count() == 1)
                    {
                        tiles.First().flags |= Tile.Flags.Open;
                        map.CalculateFov(player.pos, RADIUS);
                        AddText("You opened door.");
                        return true;
                    }
                    else
                        mode = Mode.OpenDoor;
                }
                else
                    ShowDialog("No nearby doors to open.");
            }
            else if (k.KeyChar == 'c')
            {
                var tiles = map.GetNearTiles(player.pos).Where(x => x.type == Tile.Type.Door && (x.flags & Tile.Flags.Open) != 0);
                if(tiles.Any())
                {
                    if(tiles.Count() == 1)
                    {
                        tiles.First().flags &= ~Tile.Flags.Open;
                        map.CalculateFov(player.pos, RADIUS);
                        AddText("You closed door.");
                        return true;
                    }
                    else
                        mode = Mode.CloseDoor;
                }
                else
                    ShowDialog("No nearby doors to close.");
            }

            return false;
        }
예제 #11
0
파일: Game.cs 프로젝트: Tomash667/hunters
        bool UpdateLook(float dt)
        {
            bool blink = false;

            look_timer += dt;
            if (look_timer >= 0.33f)
            {
                look_timer = 0;
                look_blink = !look_blink;
                blink = true;
            }

            ConsoleKeyInfo? ka = Console.ReadKey2();
            if (ka == null)
                return blink;

            Dir dir = Dir.None;
            ConsoleKeyInfo k = ka.Value;

            if(GetDir(k.Key, out dir))
            {
                Pos change = dirs[(int)dir].change;
                if (k.Modifiers == ConsoleModifiers.Shift)
                    change *= 5;
                look_pos += change;
                if (look_pos.x < 0)
                    look_pos.x = 0;
                else if (look_pos.x >= map.w)
                    look_pos.x = map.w - 1;
                if (look_pos.y < 0)
                    look_pos.y = 0;
                else if (look_pos.y >= map.h)
                    look_pos.y = map.h - 1;
            }
            else if (k.KeyChar == '?')
            {
                ShowDialog("$amLook controls\nArrows/numpad - navigate\nl - examine tile\nc - center on yourself\n"
                    + "Escape - exit");
            }
            else if (k.KeyChar == 'l')
            {
                Tile t = map[look_pos];
                if ((t.flags & Tile.Flags.Known) != 0)
                {
                    List<string> items = new List<string>();

                    if (t.type == Tile.Type.Wall)
                        items.Add("wall");

                    if ((t.flags & Tile.Flags.Lit) != 0)
                    {
                        if (t.type == Tile.Type.Door)
                        {
                            if ((t.flags & Tile.Flags.Open) != 0)
                                items.Add("open door");
                            else
                                items.Add("closed door");
                        }

                        if (t.unit != null)
                        {
                            if (t.unit.ai)
                                items.Add("enemy");
                            else
                                items.Add("you");
                        }

                        if (t.items != null)
                        {
                            if (t.items.Count == 1)
                            {
                                if (t.items[0].count == 1)
                                    items.Add(t.items[0].item.name);
                                else
                                    items.Add(string.Format("{0} {1}s", t.items[0].count, t.items[0].item.name));
                            }
                            else
                                items.Add("many items");
                        }
                    }
                    else
                    {
                        if (t.type == Tile.Type.Door)
                        {
                            if ((t.flags & Tile.Flags.LastOpen) != 0)
                                items.Add("open door");
                            else
                                items.Add("closed door");
                        }
                    }

                    if (items.Count == 0)
                        ShowDialog("There is nothing there.");
                    else
                    {
                        StringBuilder s = new StringBuilder("There is ");
                        s.Join(items);
                        if (look_pos == player.pos)
                            s.Append(" here.");
                        else
                            s.Append(" there.");
                        ShowDialog(s.ToString());
                    }
                }
                else
                    ShowDialog("You don't know what is there.");
            }
            else if (k.KeyChar == 'c')
            {
                look_pos = player.pos;
            }
            else if (k.Key == ConsoleKey.Escape)
            {
                mode = Mode.Game;
            }
            else
                return blink;

            return true;
        }
예제 #12
0
파일: Game.cs 프로젝트: Tomash667/hunters
        void PickThrowTarget()
        {
            var targets = units.Where(x => x != player)
                .Select(unit => new { unit, dist = unit.pos.Distance(player.pos) })
                .Where(x => x.dist < 12);
            if(!targets.Any(x => x.unit == throw_target))
            {
                // unit don't have old target, chose nearest
                if(targets.Any())
                {
                    throw_target = targets.MaxBy(x => x.dist).unit;
                    look_pos = throw_target.pos;
                }
                else
                {
                    throw_target = null;
                    look_pos = player.pos;
                }
            }
            else
            {
                // use old target
                look_pos = throw_target.pos;
            }

            look_timer = 0;
            look_blink = true;
        }
예제 #13
0
파일: Game.cs 프로젝트: Tomash667/hunters
        public void ShowDialog(string text, Func<bool> f = null)
        {
            lines.Clear();
            StringBuilder line_text = new StringBuilder();
            int w = 0;
            Line.Align align = Line.Align.Left;

            for (int i = 0; i < text.Length; ++i)
            {
                char c = text[i];
                if (c == '$')
                {
                    ++i;
                    c = text[i];
                    if(c == 'a')
                    {
                        // align
                        ++i;
                        c = text[i];
                        if (c == 'l')
                            align = Line.Align.Left;
                        else if (c == 'm')
                            align = Line.Align.Center;
                        else if (c == 'r')
                            align = Line.Align.Right;
                        else
                            throw new Exception(string.Format("Unkown format string $a{0}.", c));
                    }
                    else if(c == '$')
                        line_text.Append(c);
                    else
                        throw new Exception(string.Format("Unknown format string ${0}.", c));
                }
                else if (c == '\n')
                {
                    AddLine(line_text, ref w, align);
                    line_text.Clear();
                }
                else
                    line_text.Append(c);
            }

            AddLine(line_text, ref w, align);

            dialog_size = new Pos(w + 1, lines.Count + 1);
            have_dialog = true;
            dialog_f = f;
        }
예제 #14
0
파일: Game.cs 프로젝트: Tomash667/hunters
        public void Init()
        {
            Instance = this;

            // init log
            log = new StreamWriter("log.txt");
            log.WriteLine("Hunters - version 0");
            log.WriteLine(DateTime.Now.ToString());
            log.Flush();

            Item.LoadItems();

            // init console
            Console.Init("Hunters", 70, 26, 20);
            screen_size = new Pos(70, 20);
            map = new Map(50, 50);

            // start menu
            Console.Clear();
            string logo = @" .-. .-..-. .-..-. .-. _______ ,---.  ,---.    .---.
             | | | || | | ||  \| ||__   __|| .-'  | .-.\  ( .-._)
             | `-' || | | ||   | |  )| |   | `-.  | `-'/ (_) \
             | .-. || | | || |\  | (_) |   | .-'  |   (  _  \ \
             | | |)|| `-')|| | |)|   | |   |  `--.| |\ \( `-'  )
             /(  (_)`---(_)/(  (_)   `-'   /( __.'|_| \)\`----'
            (__)          (__)            (__)        (__)       ";

            Console.WriteText2(logo);
            Console.WriteText2("\nCreated by Tomashu - Version 0\n\nYour name: ");
            player_name = Console.GetText();
            if (player_name == null)
                Environment.Exit(0);

            // try load save
            if(!TryLoad())
                NewGame();
        }
예제 #15
0
파일: Game.cs 프로젝트: Tomash667/hunters
        public void DrawWindow(Pos pos, Pos size, short bkg)
        {
            int left = pos.x,
                right = pos.x + size.x,
                top = pos.y,
                bottom = pos.y + size.y;

            // background
            for (int y = top; y <= bottom; ++y)
            {
                for (int x = left; x <= right; ++x)
                {
                    Console.buf[x + y * Console.Width].Attributes = bkg;
                    Console.buf[x + y * Console.Width].Char.UnicodeChar = ' ';
                }
            }

            // top/bottom bar
            for (int x = left + 1; x <= right - 1; ++x)
            {
                Console.buf[x + top * Console.Width].Char.UnicodeChar = '-';
                Console.buf[x + bottom * Console.Width].Char.UnicodeChar = '-';
            }

            // left/right bar
            for (int y = top + 1; y <= bottom - 1; ++y)
            {
                Console.buf[left + y * Console.Width].Char.UnicodeChar = '|';
                Console.buf[right + y * Console.Width].Char.UnicodeChar = '|';
            }

            // corners
            Console.buf[left + top * Console.Width].Char.UnicodeChar = '+';
            Console.buf[right + top * Console.Width].Char.UnicodeChar = '+';
            Console.buf[left + bottom * Console.Width].Char.UnicodeChar = '+';
            Console.buf[right + bottom * Console.Width].Char.UnicodeChar = '+';
        }
예제 #16
0
파일: Map.cs 프로젝트: Tomash667/hunters
        void calculateFovQuadrant()
        {
            Field field = new Field();
            activeFields.Add(field);
            field.shallow.near = shallowOrigin;
            field.shallow.far = new Pos(fov_size, 0);
            field.steep.near = steepOrigin;
            field.steep.far = new Pos(0, fov_size);

            // Visit the source square exactly once (in quadrant 1).
            if (quadrant.x == 1 && quadrant.y == 1)
                visit(source);

            var currentField = activeFields.Begin();
            int i, j, maxI = extent.x + extent.y;
            Pos dest = new Pos();

            // For each square outline
            for (i = 1; i <= maxI && activeFields.Count > 0; ++i)
            {
                int startJ = Math.Max(0, i - extent.x);
                int maxJ = Math.Min(i, extent.y);
                // Visit the nodes in the outline
                for (j = startJ; j <= maxJ && currentField != activeFields.End(); ++j)
                {
                    dest.x = (i-j) * fov_size;
                    dest.y = j * fov_size;
                    visitSquare(dest, ref currentField);
                }
                currentField = activeFields.Begin();
            }

            steepBumps.Clear();
            shallowBumps.Clear();
            activeFields.Clear();
        }
예제 #17
0
파일: Map.cs 프로젝트: Tomash667/hunters
        void checkVisit(Pos pos, Pos adjustedPos)
        {
            if (adjustedPos.x < 0 || adjustedPos.y < 0 || adjustedPos.x >= w || adjustedPos.y >= w)
                return;

            if (!((quadrant.x * quadrant.y == 1 && pos.x == 0 && pos.y != 0)
              || (quadrant.x * quadrant.y == -1 && pos.y == 0 && pos.x != 0)
              || doesPermissiveVisit(pos.x/fov_size * quadrant.x, pos.y/fov_size * quadrant.y)))
                visit(adjustedPos);
        }
예제 #18
0
 public static void WriteText(string text, Pos pos, short color)
 {
     for (int x = 0; x < text.Length; ++x)
         Console.buf[x + pos.x + pos.y * Console.Width].Set(text[x], color);
 }
예제 #19
0
파일: Map.cs 프로젝트: Tomash667/hunters
        void visitSquare(Pos dest, ref LList<Field>.Iterator currentField)
        {
            //Debug.Print(string.Format("{0}, {1}", dest.x, dest.y));

            // The top-left and bottom-right corners of the destination square.
            Pos topLeft = new Pos(dest.x, dest.y + fov_size);
            Pos bottomRight = new Pos(dest.x + fov_size, dest.y);
            LList<Field>.Iterator end = activeFields.End();
            while (currentField != end && currentField.Current.steep.isBelowOrContains(bottomRight))
            {
                //Debug.Print("ABOVE");
                // case ABOVE
                // The square is in case 'above'. This means that it is ignored
                // for the currentField. But the steeper fields might need it.
                ++currentField;
            }

            if (currentField == activeFields.End())
            {
                //Debug.Print("ABOVE ALL");
                // The square was in case 'above' for all fields. This means that
                // we no longer care about it or any squares in its diagonal rank.
                return;
            }

            // Now we check for other cases.
            if (currentField.Current.shallow.isAboveOrContains(topLeft))
            {
                //Debug.Print("BELOW");
                // case BELOW
                // The shallow line is above the extremity of the square, so that
                // square is ignored.
                return;
            }
            // The square is between the lines in some way. This means that we
            // need to visit it and determine whether it is blocked.
            bool isBlocked = actIsBlocked(dest, currentField.Current);
            if (!isBlocked)
            {
                //Debug.Print("NOT BLOCKED");
                // We don't care what case might be left, because this square does
                // not obstruct.
                return;
            }

            if (currentField.Current.shallow.isAbove(bottomRight) && currentField.Current.steep.isBelow(topLeft))
            {
                //Debug.Print("BLOCKING");
                // case BLOCKING
                // Both lines intersect the square. This current field has ended.
                currentField = activeFields.Erase(currentField);
            }
            else if (currentField.Current.shallow.isAbove(bottomRight))
            {
                //Debug.Print("SHALLOW BUMP");
                // case SHALLOW BUMP
                // The square intersects only the shallow line.
                addShallowBump(topLeft, currentField.Current);
                currentField = checkField(currentField);
            }
            else if (currentField.Current.steep.isBelow(topLeft))
            {
                //Debug.Print("STEEP BUMP");
                // case STEEP BUMP
                // The square intersects only the steep line.
                addSteepBump(bottomRight, currentField.Current);
                checkField(currentField);
            }
            else
            {
               // Debug.Print("BETWEEN");
                // case BETWEEN
                // The square intersects neither line. We need to split into two fields.
                LList<Field>.Iterator steeperField = currentField;
                LList<Field>.Iterator shallowerField = activeFields.Insert(currentField, currentField.Current.Copy());
                addSteepBump(bottomRight, shallowerField.Current);
                checkField(shallowerField);
                addShallowBump(topLeft, steeperField.Current);
                currentField = checkField(steeperField);
            }
        }
예제 #20
0
파일: Map.cs 프로젝트: Tomash667/hunters
        public void Draw(Pos size, Pos offset, Pos buf_offset)
        {
            int left = Math.Max(0, offset.x);
            int right = Math.Min(w, offset.x + size.x);
            int top = Math.Max(0, offset.y);
            int bottom = Math.Min(h, offset.y + size.y);
            bool lit;
            char glyph;

            for(int y=top; y<bottom; ++y)
            {
                for (int x = left; x < right; ++x)
                {
                    glyph = m[x + y * w].GetGlyph(out lit);
                    Console.buf[x - offset.x - buf_offset.x + (y - offset.y - buf_offset.y) * Console.Width].Set(glyph, (short)(lit ? ConsoleColor.Gray : ConsoleColor.DarkBlue));
                }
            }
        }
예제 #21
0
파일: Map.cs 프로젝트: Tomash667/hunters
 public bool isAbove(Pos pt)
 {
     return relativeSlope(pt) < 0;
 }
예제 #22
0
파일: Map.cs 프로젝트: Tomash667/hunters
 public IEnumerable<Tile> GetNearTiles(Pos pos)
 {
     if(pos.x > 0)
     {
         if (pos.y > 0)
             yield return m[pos.x - 1 + (pos.y - 1) * w];
         yield return m[pos.x - 1 + pos.y * w];
         if (pos.y < h)
             yield return m[pos.x - 1 + (pos.y + 1) * w];
     }
     if(pos.x < w)
     {
         if (pos.y > 0)
             yield return m[pos.x + 1 + (pos.y - 1) * w];
         yield return m[pos.x + 1 + pos.y * w];
         if (pos.y < h)
             yield return m[pos.x + 1 + (pos.y + 1) * w];
     }
     if (pos.y > 0)
         yield return m[pos.x + (pos.y - 1) * w];
     if (pos.y < h)
         yield return m[pos.x + (pos.y + 1) * w];
 }
예제 #23
0
파일: Map.cs 프로젝트: Tomash667/hunters
 public bool isBelow(Pos pt)
 {
     return relativeSlope(pt) > 0;
 }
예제 #24
0
파일: Map.cs 프로젝트: Tomash667/hunters
 public Tile GetTileSafe(Pos pos)
 {
     if (pos.x < 0 || pos.y < 0 || pos.x >= w || pos.y >= h)
         return null;
     else
         return m[pos.x + pos.y * w];
 }
예제 #25
0
파일: Map.cs 프로젝트: Tomash667/hunters
 // negative if the line is above the point.
 // positive if the line is below the point.
 // 0 if the line is on the point.
 public int relativeSlope(Pos pt)
 {
     return (far.y - near.y)*(far.x - pt.x)
         - (far.y - pt.y)*(far.x - near.x);
 }
예제 #26
0
파일: Map.cs 프로젝트: Tomash667/hunters
 bool actIsBlocked(Pos pos, Field currentField)
 {
     Pos adjustedPos = new Pos(pos.x/fov_size*quadrant.x + source.x, pos.y/fov_size*quadrant.y + source.y);
     bool result = isBlocked(adjustedPos.x, adjustedPos.y);
     Pos topLeft;
     Pos bottomRight;
     if (result)
     {
         topLeft = new Pos(pos.x, pos.y + fov_size);
         bottomRight = new Pos(pos.x + fov_size, pos.y);
     }
     else
     {
         topLeft = new Pos(pos.x + fov_destOffset, pos.y + fov_destLimit);
         bottomRight = new Pos(pos.x + fov_destLimit, pos.y + fov_destOffset);
     }
     if (currentField.steep.isAbove(bottomRight) && currentField.shallow.isBelow(topLeft))
         checkVisit(pos, adjustedPos);
     return result;
 }
예제 #27
0
파일: Map.cs 프로젝트: Tomash667/hunters
 void addShallowBump(Pos pos, Field currentField)
 {
     // First, the far point of shallow is set to the new point.
     currentField.shallow.far = pos;
     // Second, we need to add the new bump to the shallow bump list for
     // future steep bump handling.
     Bump bump = new Bump(pos, currentField.shallowBump);
     shallowBumps.Add(bump);
     currentField.shallowBump = bump;
     // Now we have too look through the list of steep bumps and see if
     // any of them are below the line.
     // If there are, we need to replace near point too.
     Bump currentBump = currentField.steepBump;
     while(currentBump != null)
     {
         if(currentField.shallow.isAbove(currentBump.pos))
             currentField.shallow.near = currentBump.pos;
         currentBump = currentBump.parent;
     }
 }
예제 #28
0
파일: Map.cs 프로젝트: Tomash667/hunters
 void addSteepBump(Pos pos, Field currentField)
 {
     currentField.steep.far = pos;
     Bump bump = new Bump(pos, currentField.steepBump);
     steepBumps.Add(bump);
     currentField.steepBump = bump;
     // Now look through the list of shallow bumps and see if any of them
     // are below the line.
     Bump currentBump = currentField.shallowBump;
     while (currentBump != null)
     {
         if(currentField.steep.isBelow(currentBump.pos))
             currentField.steep.near = currentBump.pos;
         currentBump = currentBump.parent;
     }
 }
예제 #29
0
파일: Map.cs 프로젝트: Tomash667/hunters
 public bool CanMove(Pos old_pos, Pos new_pos, bool diagonal)
 {
     Tile t = m[new_pos.x + new_pos.y * w];
     if(t.unit == null && t.CanMove())
     {
         if (!diagonal)
             return true;
         if (m[old_pos.x + new_pos.y * w].CanMove() || m[new_pos.x + old_pos.y * w].CanMove())
             return true;
     }
     return false;
 }
예제 #30
0
파일: Game.cs 프로젝트: Tomash667/hunters
 public DirInfo(Dir _dir, Pos _change, Dir _other, Dir _other2, bool _diagonal)
 {
     dir = _dir;
     change = _change;
     other = _other;
     other2 = _other2;
     diagonal = _diagonal;
 }