height_map.cpp

Go to the documentation of this file.

/*
 Copyright (c) 1996-2020 Freeciv21 and Freeciv contributors. This file is
 __    __          part of Freeciv21. Freeciv21 is free software: you can
/ \\..// \    redistribute it and/or modify it under the terms of the GNU
  ( oo )        General Public License  as published by the Free Software
   \__/         Foundation, either version 3 of the License,  or (at your
                      option) any later version. You should have received
    a copy of the GNU General Public License along with Freeciv21. If not,
                  see https://www.gnu.org/licenses/.
 */
// utility
#include "rand.h"
 
// common
#include "map.h"
 
/* server/generator */
#include "mapgen_topology.h"
#include "mapgen_utils.h"
 
#include "height_map.h"
 
int *height_map = nullptr;
int hmap_shore_level = 0, hmap_mountain_level = 0;
 
static float hmap_pole_factor(struct tile *ptile)
{
  float factor = 1.0;
 
  if (near_singularity(ptile)) {
    /* Map edge near pole: clamp to what linear ramp would give us at pole
     * (maybe greater than 0) */
    factor = (100 - wld.map.server.flatpoles) / 100.0;
  } else if (wld.map.server.flatpoles > 0) {
    /* Linear ramp down from 100% at 2.5*ICE_BASE_LEVEL to (100-flatpoles) %
     * at the poles */
    factor = 1
             - ((1 - (map_colatitude(ptile) / (2.5 * ICE_BASE_LEVEL)))
                * wld.map.server.flatpoles / 100);
  }
  if (wld.map.server.separatepoles
      && map_colatitude(ptile) >= 2 * ICE_BASE_LEVEL) {
    /* A band of low height to try to separate the pole (this function is
     * only assumed to be called <= 2.5*ICE_BASE_LEVEL) */
    factor = MIN(factor, 0.1);
  }
  return factor;
}
 
void normalize_hmap_poles()
{
  whole_map_iterate(&(wld.map), ptile)
  {
    if (map_colatitude(ptile) <= 2.5 * ICE_BASE_LEVEL) {
      hmap(ptile) *= hmap_pole_factor(ptile);
    } else if (near_singularity(ptile)) {
      // Near map edge but not near pole.
      hmap(ptile) = 0;
    }
  }
  whole_map_iterate_end;
}
 
void renormalize_hmap_poles()
{
  whole_map_iterate(&(wld.map), ptile)
  {
    if (hmap(ptile) == 0) {
      // Nothing left to restore.
    } else if (map_colatitude(ptile) <= 2.5 * ICE_BASE_LEVEL) {
      float factor = hmap_pole_factor(ptile);
 
      if (factor > 0) {
        // Invert the previously applied function
        hmap(ptile) /= factor;
      }
    }
  }
  whole_map_iterate_end;
}
 
void make_random_hmap()
{
  int smooth = MAX(1, 1 + get_sqsize()
                          - (MAPSTARTPOS_DEFAULT != wld.map.server.startpos
                                 ? player_count() / 4
                                 : 0));
 
  height_map = new int[MAP_INDEX_SIZE];
 
  INITIALIZE_ARRAY(height_map, MAP_INDEX_SIZE, fc_rand(1000 * smooth));
 
  for (int i = 0; i < smooth; i++) {
    smooth_int_map(height_map, true);
  }
 
  adjust_int_map(height_map, hmap_max_level);
}
 
static void gen5rec(int step, int xl, int yt, int xr, int yb)
{
  int val[2][2];
  int x1wrap = xr; // to wrap correctly
  int y1wrap = yb;
 
  // All x and y values are native.
 
  if (((yb - yt <= 0) || (xr - xl <= 0))
      || ((yb - yt == 1) && (xr - xl == 1))) {
    return;
  }
 
  if (xr == wld.map.xsize) {
    x1wrap = 0;
  }
  if (yb == wld.map.ysize) {
    y1wrap = 0;
  }
 
  val[0][0] = hmap(native_pos_to_tile(&(wld.map), xl, yt));
  val[0][1] = hmap(native_pos_to_tile(&(wld.map), xl, y1wrap));
  val[1][0] = hmap(native_pos_to_tile(&(wld.map), x1wrap, yt));
  val[1][1] = hmap(native_pos_to_tile(&(wld.map), x1wrap, y1wrap));
 
  // set midpoints of sides to avg of side's vertices plus a random factor
  // unset points are zero, don't reset if set
#define set_midpoints(X, Y, V)                                              \
  {                                                                         \
    struct tile *ptile = native_pos_to_tile(&(wld.map), (X), (Y));          \
    if (map_colatitude(ptile) <= ICE_BASE_LEVEL / 2) {                      \
      /* possibly flatten poles, or possibly not (even at map edge) */      \
      hmap(ptile) = (V) * (100 - wld.map.server.flatpoles) / 100;           \
    } else if (near_singularity(ptile) || hmap(ptile) != 0) {               \
      /* do nothing */                                                      \
    } else {                                                                \
      hmap(ptile) = (V);                                                    \
    }                                                                       \
  }
 
  set_midpoints((xl + xr) / 2, yt,
                (val[0][0] + val[1][0]) / 2 + (int) fc_rand(step)
                    - step / 2);
  set_midpoints((xl + xr) / 2, y1wrap,
                (val[0][1] + val[1][1]) / 2 + (int) fc_rand(step)
                    - step / 2);
  set_midpoints(xl, (yt + yb) / 2,
                (val[0][0] + val[0][1]) / 2 + (int) fc_rand(step)
                    - step / 2);
  set_midpoints(x1wrap, (yt + yb) / 2,
                (val[1][0] + val[1][1]) / 2 + (int) fc_rand(step)
                    - step / 2);
 
  // set middle to average of midpoints plus a random factor, if not set
  set_midpoints((xl + xr) / 2, (yt + yb) / 2,
                ((val[0][0] + val[0][1] + val[1][0] + val[1][1]) / 4
                 + (int) fc_rand(step) - step / 2));
 
#undef set_midpoints
 
  // now call recursively on the four subrectangles
  gen5rec(2 * step / 3, xl, yt, (xr + xl) / 2, (yb + yt) / 2);
  gen5rec(2 * step / 3, xl, (yb + yt) / 2, (xr + xl) / 2, yb);
  gen5rec(2 * step / 3, (xr + xl) / 2, yt, xr, (yb + yt) / 2);
  gen5rec(2 * step / 3, (xr + xl) / 2, (yb + yt) / 2, xr, yb);
}
 
void make_pseudofractal_hmap()
{
  const bool xnowrap = !current_topo_has_flag(TF_WRAPX);
  const bool ynowrap = !current_topo_has_flag(TF_WRAPY);
 
  /*
   * How many blocks should the x and y directions be divided into
   * initially.
   */
  const int extra_div = 1
                        + ((MAPSTARTPOS_DEFAULT == wld.map.server.startpos
                            || MAPSTARTPOS_ALL == wld.map.server.startpos)
                               ? 0
                               : player_count());
  const int xdiv = 5 + extra_div;
  const int ydiv = 5 + extra_div;
 
  int xdiv2 = xdiv + (xnowrap ? 1 : 0);
  int ydiv2 = ydiv + (ynowrap ? 1 : 0);
 
  int xmax = wld.map.xsize - (xnowrap ? 1 : 0);
  int ymax = wld.map.ysize - (ynowrap ? 1 : 0);
  int x_current, y_current;
  // just need something > log(max(xsize, ysize)) for the recursion
  int step = wld.map.xsize + wld.map.ysize;
  // edges are avoided more strongly as this increases
  int avoidedge = (100 - wld.map.server.landpercent) * step / 100 + step / 3;
 
  height_map = new int[MAP_INDEX_SIZE];
 
  // initialize map
  INITIALIZE_ARRAY(height_map, MAP_INDEX_SIZE, 0);
 
  // set initial points
  for (x_current = 0; x_current < xdiv2; x_current++) {
    for (y_current = 0; y_current < ydiv2; y_current++) {
      do_in_map_pos(&(wld.map), ptile, (x_current * xmax / xdiv),
                    (y_current * ymax / ydiv))
      {
        // set initial points
        hmap(ptile) = fc_rand(2 * step) - (2 * step) / 2;
 
        if (near_singularity(ptile)) {
          // avoid edges (topological singularities)
          hmap(ptile) -= avoidedge;
        }
 
        if (map_colatitude(ptile) <= ICE_BASE_LEVEL / 2) {
          // separate poles and avoid too much land at poles
          hmap(ptile) -= fc_rand(avoidedge * wld.map.server.flatpoles / 100);
        }
      }
      do_in_map_pos_end;
    }
  }
 
  // calculate recursively on each block
  for (x_current = 0; x_current < xdiv; x_current++) {
    for (y_current = 0; y_current < ydiv; y_current++) {
      gen5rec(step, x_current * xmax / xdiv, y_current * ymax / ydiv,
              (x_current + 1) * xmax / xdiv, (y_current + 1) * ymax / ydiv);
    }
  }
 
  // put in some random fuzz
  whole_map_iterate(&(wld.map), ptile)
  {
    hmap(ptile) = 8 * hmap(ptile) + fc_rand(4) - 2;
  }
  whole_map_iterate_end;
 
  adjust_int_map(height_map, hmap_max_level);
}
 
bool area_is_too_flat(struct tile *ptile, int thill, int my_height)
{
  int higher_than_me = 0;
 
  square_iterate(&(wld.map), ptile, 2, tile1)
  {
    if (hmap(tile1) > thill) {
      return false;
    }
    if (hmap(tile1) > my_height) {
      if (map_distance(ptile, tile1) == 1) {
        return false;
      }
      if (++higher_than_me > 2) {
        return false;
      }
    }
  }
  square_iterate_end;
 
  return (thill - hmap_shore_level) * higher_than_me
         <= (my_height - hmap_shore_level) * 4;
}