Beispiel #1
0
        /*
         * Save a slope
         */
        static void vinfo_init_aux(vinfo_hack hack, int y, int x, long m)
        {
            int i;

            /* Handle "legal" slopes */
            if ((m > 0) && (m <= SCALE))
            {
                /* Look for that slope */
                for (i = 0; i < hack.num_slopes; i++)
                {
                    if (hack.slopes[i] == m) break;
                }

                /* New slope */
                if (i == hack.num_slopes)
                {
                    /* Paranoia */
                    if (hack.num_slopes >= VINFO_MAX_SLOPES)
                    {
                        Utilities.quit("Too many slopes (" + VINFO_MAX_SLOPES +")!");
                    }

                    /* Save the slope, and advance */
                    hack.slopes[hack.num_slopes++] = m;
                }
            }

            /* Track slope range */
            if (hack.slopes_min[y,x] > m) hack.slopes_min[y,x] = m;
            if (hack.slopes_max[y,x] < m) hack.slopes_max[y,x] = m;
        }
Beispiel #2
0
        /*
         * Initialize the "vinfo" array
         *
         * Full Octagon (radius 20), Grids=1149
         *
         * Quadrant (south east), Grids=308, Slopes=251
         *
         * Octant (east then south), Grids=161, Slopes=126
         *
         * This function assumes that VINFO_MAX_GRIDS and VINFO_MAX_SLOPES
         * have the correct values, which can be derived by setting them to
         * a number which is too high, running this function, and using the
         * error messages to obtain the correct values.
         */
        public static int vinfo_init()
        {
            int i, g;
            long m;

            int num_grids = 0;

            int queue_head = 0;
            int queue_tail = 0;
            vinfo_type[] queue = new vinfo_type[VINFO_MAX_GRIDS*2];

            //Nick: initialize v_info here, fill it with new stuffs to play with instead of nulls
            for (int n = 0; n < vinfo.Count(); n++){
                vinfo[n] = new vinfo_type();
            }

            /* Make hack */
            vinfo_hack hack = new vinfo_hack();

            /* Analyze grids */
            for (int y = 0; y <= Misc.MAX_SIGHT; ++y)
            {
                //Triangular array? Weird... Triangle is on top right corner
                for (int x = y; x <= Misc.MAX_SIGHT; ++x)
                {
                    /* Skip grids which are out of sight range */
                    if (distance(0, 0, y, x) > Misc.MAX_SIGHT) continue;

                    /* Default slope range */
                    hack.slopes_min[y,x] = 999999999;
                    hack.slopes_max[y,x] = 0;

                    /* Paranoia */
                    if (num_grids >= VINFO_MAX_GRIDS)
                    {
                        Utilities.quit("Too many grids (" + num_grids + " >= " + VINFO_MAX_GRIDS + ")!");
                    }

                    /* Count grids */
                    num_grids++;

                    /* Slope to the top right corner */
                    m = SCALE * (1000L * y - 500) / (1000L * x + 500);

                    /* Handle "legal" slopes */
                    vinfo_init_aux(hack, y, x, m);

                    /* Slope to top left corner */
                    m = SCALE * (1000L * y - 500) / (1000L * x - 500);

                    /* Handle "legal" slopes */
                    vinfo_init_aux(hack, y, x, m);

                    /* Slope to bottom right corner */
                    m = SCALE * (1000L * y + 500) / (1000L * x + 500);

                    /* Handle "legal" slopes */
                    vinfo_init_aux(hack, y, x, m);

                    /* Slope to bottom left corner */
                    m = SCALE * (1000L * y + 500) / (1000L * x - 500);

                    /* Handle "legal" slopes */
                    vinfo_init_aux(hack, y, x, m);
                }
            }

            /* Enforce maximal efficiency */
            if (num_grids < VINFO_MAX_GRIDS)
            {
                Utilities.quit("Too few grids (" + num_grids + " < " + VINFO_MAX_GRIDS + ")!");
            }

            /* Enforce maximal efficiency */
            if (hack.num_slopes < VINFO_MAX_SLOPES)
            {
                Utilities.quit("Too few slopes (" + hack.num_slopes + " < " + VINFO_MAX_SLOPES + ")!");
            }

            Utilities.sort(hack.slopes, cmp_longs);

            /* Enqueue player grid */
            queue[queue_tail++] = vinfo[0];

            /* Process queue */
            while (queue_head < queue_tail)
            {
                int e;

                /* Index */
                e = queue_head++;

                /* Main Grid */
                g = vinfo[e].grid[0];

                /* Location */
                int y = GRID_Y(g);
                int x = GRID_X(g);

                /* Compute grid offsets */
                vinfo[e].grid[0] = (short)GRID(+y,+x);
                vinfo[e].grid[1] = (short)GRID(+x,+y);
                vinfo[e].grid[2] = (short)GRID(+x,-y);
                vinfo[e].grid[3] = (short)GRID(+y,-x);
                vinfo[e].grid[4] = (short)GRID(-y,-x);
                vinfo[e].grid[5] = (short)GRID(-x,-y);
                vinfo[e].grid[6] = (short)GRID(-x,+y);
                vinfo[e].grid[7] = (short)GRID(-y,+x);

                /* Analyze slopes */
                for (i = 0; i < hack.num_slopes; ++i)
                {
                    m = hack.slopes[i];

                    /* Memorize intersection slopes (for non-player-grids) */
                    if ((e > 0) && (hack.slopes_min[y,x] < m) && (m < hack.slopes_max[y,x]))
                    {
                        switch (i / 32)
                        {
                            case 3: vinfo[e].bits_3 |= (uint)(1L << (i % 32)); break;
                            case 2: vinfo[e].bits_2 |= (uint)(1L << (i % 32)); break;
                            case 1: vinfo[e].bits_1 |= (uint)(1L << (i % 32)); break;
                            case 0: vinfo[e].bits_0 |= (uint)(1L << (i % 32)); break;
                        }
                    }
                }

                /* Default */
                vinfo[e].next_0 = vinfo[0];

                /* Grid next child */
                if (distance(0, 0, y, x+1) <= Misc.MAX_SIGHT)
                {
                    g = GRID(y,x+1);

                    if (queue[queue_tail-1].grid[0] != g)
                    {
                        vinfo[queue_tail].grid[0] = (short)g;
                        queue[queue_tail] = vinfo[queue_tail];
                        queue_tail++;
                    }

                    vinfo[e].next_0 = vinfo[queue_tail - 1];
                }

                /* Default */
                vinfo[e].next_1 = vinfo[0];

                /* Grid diag child */
                if (distance(0, 0, y+1, x+1) <= Misc.MAX_SIGHT)
                {
                    g = GRID(y+1,x+1);

                    if (queue[queue_tail-1].grid[0] != g)
                    {
                        vinfo[queue_tail].grid[0] = (short)g;
                        queue[queue_tail] = vinfo[queue_tail];
                        queue_tail++;
                    }

                    vinfo[e].next_1 = vinfo[queue_tail - 1];
                }

                /* Hack -- main diagonal has special children */
                if (y == x) vinfo[e].next_0 = vinfo[e].next_1;

                /* Extra values */
                vinfo[e].y = (byte)y;
                vinfo[e].x = (byte)x;
                vinfo[e].d = (byte)((y > x) ? (y + x/2) : (x + y/2));
                vinfo[e].r = (byte)((y==0) ? x : (x==0) ? y : (y == x) ? y : 0);
            }

            /* Verify maximal bits XXX XXX XXX */
            if (((vinfo[1].bits_3 | vinfo[2].bits_3) != VINFO_BITS_3) ||
                ((vinfo[1].bits_2 | vinfo[2].bits_2) != VINFO_BITS_2) ||
                ((vinfo[1].bits_1 | vinfo[2].bits_1) != VINFO_BITS_1) ||
                ((vinfo[1].bits_0 | vinfo[2].bits_0) != VINFO_BITS_0))
            {
                Utilities.quit("Incorrect bit masks!");
            }

            /* Kill hack */
            //FREE(hack); //lolc

            /* Success */
            return (0);
        }