The MOO2 Book / Game / Mapgen

    void Init_New_Game() {
        // ... intialize various variables
        Set_Game_Random_Seed(); // set from command line parameter if given, otherwise randomize
        Universe_Generation(gal_size, gal_age, diff);
        while(1) {
            book ok = Generate_Home_Worlds();
            if (ok) {
                Enforce_Planet_Max();
                Set_Black_Hole_Visited_Flags(); // ?!
                Confirm_Planet_And_Star_Index_Link();
                if (settings.civ == ADVANCED_CIV) {
                    Advanced_Civilization_Colonies();
                    Assign_Advanced_Civilization_Starting_Ships();
                }
                break;
            }
        }
        Make_System_Monsters();
        Make_System_Monsters_Into_Ships();
        Generate_Wormhole_Links();
        if (settings.civ == ADVANCED_CIV) {
            Allocate_Adv_Civ_Officers();
        }
        Assign_Marooned_Heroes();
        Initialize_Black_Hole_Blocks();
        Initialize_Star_In_Nebula_Info();
        // ... named defaults, inits
        Update_Star_Owners();
        Twiddle_Initial_Homeworlds();
        // ... further inits
    }

    void Universe_Generation(int gal_size, int gal_age, int diff) {
        Generate_Nebulas();
        int steps_x, steps_y <- from gal_size
        while(!gctx.f122) {
            Set_Star_XYs(steps_x, steps_y, gal_age, 1, 1);
            for (int si = 0; si < n_stars; ++si) {
                Star *star = &game.stars[si];
                star->owner = -1;
                star->size = weighted_roll(3, 4, 3); // cosmetic
                star->picture = Random(3) - 1; // cosmetic
                if (!is_bh(star)) {
                    int n_sat = Gnerate_Number_Of_Satellites(si);
                    while (n_sat--)
                        Planet_Generation(si);
                }
                if (!is_bh(star) && gctx.f2[si] && si != 0 /*Orion*/)
                    Generate_Star_Special(si, gctx.f110, a_mask12);
                star->wormhole = -1;
            }
            while(1) {
                if (n_nebulas)
                    Black_Hole_Fix(gctx.fm86); // black holes aren't allowed in nebulas
                Initialize_Black_Hole_Blocks();
                if (Map_Is_Connected())
                    break;
                Set_Star_XYs(gctx, 0, 0);
            }
            ...
        }
    }

    int weighted_roll(weight1, ..., weight_n) {
        roll 1 .. sum of weights, return index of appropriate interval 0..n-1
    }

    bool is_bh(Star *star) { return star->color == 6; } // check star is black hole

    void Set_Star_XYs(int steps_x, int steps_y, int gal_age, bool make_colors, bool make_names) {
        int dx = size_x / steps_x;
        int dy = size_y / steps_y;
        for (int si = 0; si < n_stars; ++si) {
            Star *star = &game.stars[si];
            if (make_colors)
                star->color = Generate_Spectral_Class(gal_age);
            if (make_names) {
                width = Get_String_Width(format);
            } else {
                width = Random(8) + Random(8) + Random(8) + 32; // wtf
            }
            int off_x = si % steps_x * step_x;
            int off_y = si * step_y / steps_x; // unusual sliding window, appears uniform

            ysz, yextra = cur_scale == 20 ? 36, 6
                        : cur_scale == 30 ? v7, 4
                                          : 50, 8;

            bool is_invalid = 0;
            int retries = 0;
            do {

                do
                    x = (Random(2 * step_x) + off_x) % size_x;
                while (scale(x) not in [24, scale(size_x) - star_width / 2); // not too close to sides

                do
                    y = (Random(2 * step_y) + off_y) % size_y;
                while (scale(y) not in [22, scale(size_y) - (star_height / 2 + yextra));

                star->x = x;
                star->y = y;
                is_invalid = Star_XY_Invalid(si, width, ysz, v32);
                int retries = 0;
                if (is_invalid == 1 && ++retries > 150) {
                    while(1) {
                        int rx = Get_Up_Scaled_Value(Random(393) + 20);
                        int ry = Get_Up_Scaled_Value(Random(341) + 20);
                        star->x = rx;
                        star->y = ry;
                        if (!Star_XY_Invalid(i, width, ysz, upscale(rx)))
                            break;
                        if (++retries > 150)
                            return;
                    }
                    is_invalid = 0;
                }
            } while (is_invalid);
        }
    }

    // Get_Scaled_Value
    int scale(int value) {
        return value * 10 / cur_scale;
    }

    // Get_Up_Scaled_Value
    int upscale(int value) {
        return value * cur_scale / 10;
    }

    // checks if star is too close to any other star with _smaller_ index
    bool Star_XY_Invalid(int si, int x_box, int y_box, int x_scaled) {
        Star *a = &game.stars[si];
        for (int i = 0; i < si; ++i) {
            Star *b = &game.stars[i];
            int sdx = scale(a->x - b->x);
            int sdy = scale(a->y - b->y);
            if (!is_bh(a) && !is_bh(b)) {
                bool too_close = sdx * sdx + sdy * sdy <= 800;
                bool in_the_box = abs(sdx) < x_box && abs(sdy) < y_box;
                bool in_fixed_box = abs(sdx) < 15 && abs(sdy) < scaled(60);
                bool too_far_right = x_scaled + 2 * x_box / 3 > scale(size_x); // wtf
                if (too_close || in_the_box || in_fixed_box || too_far_right)
                    return 1;
            } else if (Parsecs_Between_Stars(a, b) < 5) {
                return 1;
            }
        }
        return 0;
    }