Пример #1
0
        static MapReach canReachTargetCalc(Struct_1D1BC groundTilesMap, Point outPos, Point attacker) /* sub_733F1 */
        {
            SteppingPath var_31 = new SteppingPath();
            SteppingPath var_19 = new SteppingPath();

            int max_range = (256 * 2) + 1;

            var_19.attacker = attacker;
            var_19.target   = outPos;

            var_19.CalculateDeltas();

            var_31.attacker.x = 0;
            var_31.attacker.y = gbl.BackGroundTiles[groundTilesMap[attacker]].field_1;

            if (var_19.diff_x > var_19.diff_y)
            {
                var_31.target.x = var_19.diff_x;
            }
            else
            {
                var_31.target.x = var_19.diff_y;
            }

            var_31.target.y = gbl.BackGroundTiles[groundTilesMap[attacker]].field_1;
            var_31.CalculateDeltas();
            bool finished = false;

            do
            {
                int          gt   = groundTilesMap[var_19.current];
                Struct_189B4 s189 = gbl.BackGroundTiles[gt];

                if (groundTilesMap.ignoreWalls == false && s189.field_2 > var_31.current.y)
                {
                    return(new MapReach(false, var_19.steps, var_19.current));
                }

                // range is for cache hard coded to 256, thus max_range = 513, so skip this.
                if (var_19.steps > max_range)
                {
                    return(new MapReach(false, var_19.steps, var_19.current));
                }

                var_31.Step();
                finished = !var_19.Step();
            } while (finished == false);

            return(new MapReach(true, var_19.steps, outPos));
        }
Пример #2
0
        internal static void draw_missile_attack(int delay, int frameCount, Point target, Point attacker)         /* sub_67AA4 */
        {
            Point        center;
            bool         var_B4;
            bool         var_B3;
            SteppingPath path = new SteppingPath();

            byte[] pathDir = new byte[0x94];


            seg051.FillChar(8, 0x94, pathDir);

            int var_AF = 0;
            int frame  = 0;

            path.attacker = attacker * 3;
            path.target   = target * 3;

            path.CalculateDeltas();

            do
            {
                var_B4 = !path.Step();

                pathDir[var_AF] = path.direction;

                var_AF++;
            } while (var_B4 == false);

            int var_B0 = var_AF - 2;

            if (var_B0 < 2 || var_AF < 2)
            {
                return;
            }

            var diff = target - attacker;

            if (ovr033.CoordOnScreen(attacker - gbl.mapToBackGroundTile.mapScreenTopLeft) == false ||
                ovr033.CoordOnScreen(target - gbl.mapToBackGroundTile.mapScreenTopLeft) == false)
            {
                if (System.Math.Abs(diff.x) <= 6 &&
                    System.Math.Abs(diff.y) <= 6)
                {
                    var_B3 = true;
                    center = (diff / 2) + attacker;
                }
                else
                {
                    var_B3 = false;
                    center = gbl.mapToBackGroundTile.mapScreenTopLeft + Point.ScreenCenter;
                }
            }
            else
            {
                var_B3 = true;
                center = gbl.mapToBackGroundTile.mapScreenTopLeft + Point.ScreenCenter;
            }

            ovr033.redrawCombatArea(8, 0xFF, center);
            var_AF = 0;
            Point delta = new Point(0, 0);

            do
            {
                Point cur = ((attacker - gbl.mapToBackGroundTile.mapScreenTopLeft) * 3) + delta;

                var_B4 = false;

                do
                {
                    Point var_C6 = gbl.MapDirectionDelta[pathDir[var_AF]];
                    cur += var_C6;

                    if (delay > 0 ||
                        (cur.x % 3) == 0 ||
                        (cur.y % 3) == 0)
                    {
                        Display.SaveVidRam();
                        seg040.OverlayBounded(gbl.missile_dax, 5, frame, cur.y, cur.x);
                        seg040.DrawOverlay();

                        seg049.SysDelay(delay);

                        Display.RestoreVidRam();
                        frame++;

                        if (frame >= frameCount)
                        {
                            frame = 0;
                        }
                    }


                    var_AF++;
                    if (cur.x < 0 || cur.x > 0x12 || cur.y < 0 || cur.y > 0x12)
                    {
                        var_B4 = true;
                    }

                    if (var_B4 == false &&
                        var_AF < var_B0)
                    {
                        delta += var_C6;

                        if (Math.Abs(delta.x) == 3)
                        {
                            attacker.x += Math.Sign(delta.x);
                            center.x   += Math.Sign(delta.x);
                            delta.x     = 0;
                        }

                        if (Math.Abs(delta.y) == 3)
                        {
                            attacker.y += Math.Sign(delta.y);
                            center.y   += Math.Sign(delta.y);
                            delta.y     = 0;
                        }
                    }
                } while (var_AF < var_B0 && var_B4 == false);

                if (var_AF < var_B0)
                {
                    int var_CE = 0;
                    int var_D0 = 0;
                    delta    = new Point(0, 0);
                    attacker = target;

                    if ((target.x + Point.ScreenHalfX) > Point.MapMaxX)
                    {
                        var_CE = target.x - Point.MapMaxX;
                    }
                    else if (target.x < Point.ScreenHalfX)
                    {
                        var_CE = Point.ScreenHalfX - target.x;
                    }

                    if ((target.y + Point.ScreenHalfY) > Point.MapMaxY)
                    {
                        var_D0 = target.y - Point.MapMaxY;
                    }
                    else if (target.y < Point.ScreenHalfY)
                    {
                        var_D0 = Point.ScreenHalfY - target.y;
                    }

                    center.x = target.x + var_CE;
                    center.y = target.y + var_D0;

                    ovr033.redrawCombatArea(8, 0xff, center);
                    cur    = (target - gbl.mapToBackGroundTile.mapScreenTopLeft) * 3;
                    var_AF = var_B0;
                    var_B4 = false;

                    do
                    {
                        Point var_C6 = new Point(0, 0) - gbl.MapDirectionDelta[pathDir[var_AF]];

                        cur += var_C6;

                        if (cur.x > 18)
                        {
                            attacker.x = gbl.mapToBackGroundTile.mapScreenTopLeft.x + Point.ScreenMaxX;
                        }
                        else if (cur.x < 0)
                        {
                            attacker.x = gbl.mapToBackGroundTile.mapScreenTopLeft.x;
                        }

                        if (cur.y > 18)
                        {
                            attacker.y = gbl.mapToBackGroundTile.mapScreenTopLeft.y + Point.ScreenMaxY;
                        }
                        else if (cur.y < 0)
                        {
                            attacker.y = gbl.mapToBackGroundTile.mapScreenTopLeft.y;
                        }

                        if (cur.x < 0 || cur.x > 18 || cur.y < 0 || cur.y > 18)
                        {
                            var_B4 = true;
                        }

                        if (var_B4 == false)
                        {
                            delta += var_C6;

                            if (System.Math.Abs(delta.x) == Point.ScreenHalfX)
                            {
                                attacker.x += Math.Sign(delta.x);
                                center.x   += Math.Sign(delta.x);
                                delta.x     = 0;
                            }

                            if (System.Math.Abs(delta.y) == Point.ScreenHalfY)
                            {
                                attacker.y += Math.Sign(delta.y);
                                center.y   += Math.Sign(delta.y);
                                delta.y     = 0;
                            }

                            var_AF -= 1;
                        }
                    } while (var_B4 == false);
                }
                else
                {
                    var_B3 = true;

                    if (ovr033.CoordOnScreen(target - gbl.mapToBackGroundTile.mapScreenTopLeft) == false)
                    {
                        ovr033.redrawCombatArea(8, 3, target);
                    }

                    cur = (target - gbl.mapToBackGroundTile.mapScreenTopLeft) * 3;

                    Display.SaveVidRam();
                    seg040.OverlayBounded(gbl.missile_dax, 5, frame, cur.y, cur.x);

                    if (delay > 0)
                    {
                        seg040.DrawOverlay();

                        seg049.SysDelay(delay);

                        Display.RestoreVidRam();
                    }
                }
            } while (var_B3 == false);

            seg040.DrawOverlay();
        }