[Freeciv-Dev] Re: (PR#6721) A Quincuncial topology
[Top] [All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index] [Thread Index]
<URL: http://rt.freeciv.org/Ticket/Display.html?id=6721 >
Le mer 07/01/2004 à 00:12, Jason Short a écrit :
> The patch appears to have been corrupted by RT.
>
> You can send it uncompressed.
Hi, ok
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/citydlg_common.c
freeciv/client/citydlg_common.c
--- freeciv-cvs-Jan-04/client/citydlg_common.c 2003-11-29 07:05:21.000000000
+0100
+++ freeciv/client/citydlg_common.c 2004-01-06 18:30:59.000000000 +0100
@@ -20,6 +20,8 @@
#include "log.h"
#include "support.h"
+#include "mapview_common.h" /* for mapview_reverse_canvas */
+
#include "clinet.h"
#include "control.h"
#include "options.h" /* for concise_city_production */
@@ -70,6 +72,10 @@
*canvas_x = (iso_x - 1) * NORMAL_TILE_WIDTH / 2;
*canvas_y = (iso_y - 1) * NORMAL_TILE_HEIGHT / 2;
} else {
+ if (mapview_canvas_reverse) {
+ city_x = CITY_MAP_SIZE-1-city_x;
+ city_y = CITY_MAP_SIZE-1-city_y;
+ }
*canvas_x = city_x * NORMAL_TILE_WIDTH;
*canvas_y = city_y * NORMAL_TILE_HEIGHT;
}
@@ -108,6 +114,10 @@
} else {
*city_x = canvas_x / NORMAL_TILE_WIDTH;
*city_y = canvas_y / NORMAL_TILE_HEIGHT;
+ if (mapview_canvas_reverse) {
+ *city_x = CITY_MAP_SIZE-1-*city_x;
+ *city_y = CITY_MAP_SIZE-1-*city_y;
+ }
}
freelog(LOG_DEBUG, "canvas_to_city_pos(pos=(%d,%d))=(%d,%d)",
orig_canvas_x, orig_canvas_y, *city_x, *city_y);
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/control.c
freeciv/client/control.c
--- freeciv-cvs-Jan-04/client/control.c 2003-12-17 07:09:41.000000000 +0100
+++ freeciv/client/control.c 2004-01-06 18:30:59.000000000 +0100
@@ -35,6 +35,7 @@
#include "gui_main_g.h"
#include "mapctrl_g.h"
#include "mapview_g.h"
+#include "mapview_common.h"
#include "menu_g.h"
#include "options.h"
#include "tilespec.h"
@@ -1243,6 +1244,7 @@
**************************************************************************/
void do_map_click(int xtile, int ytile, enum quickselect_type qtype)
{
+ normalize_map_pos(&xtile, &ytile);
struct city *pcity = map_get_city(xtile, ytile);
struct tile *ptile = map_get_tile(xtile, ytile);
struct unit *punit = player_find_unit_by_id(game.player_ptr, hover_unit);
@@ -1580,7 +1582,8 @@
void key_unit_move(enum direction8 gui_dir)
{
if (punit_focus) {
- enum direction8 map_dir = gui_to_map_dir(gui_dir);
+ enum direction8 map_dir
+ = NORMALIZE_DIR(gui_to_map_dir(gui_dir),mapview_canvas_reverse);
request_move_unit_direction(punit_focus, map_dir);
}
}
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/goto.c freeciv/client/goto.c
--- freeciv-cvs-Jan-04/client/goto.c 2004-01-04 07:15:53.000000000 +0100
+++ freeciv/client/goto.c 2004-01-06 18:30:59.000000000 +0100
@@ -59,6 +59,8 @@
* only one has number less than 4
* 2. There _can_ be more than one line drawn between two tiles, because of
* the waypoints. */
+ /* FIX ME there are no more good, in reversed topoloies, we can not more
+ * choice the number less than 4 in the borders areas [mburda] */
struct {
unsigned char drawn[4];
} *tiles;
@@ -569,6 +571,7 @@
{
int x1, y1;
bool is_real;
+ REVERSE_DESCRIPTOR_TYPE is_reversed;
assert(is_valid_dir(dir));
@@ -576,10 +579,12 @@
assert(is_real_map_pos(x, y));
normalize_map_pos(&x, &y);
- is_real = MAPSTEP(x1, y1, x, y, dir);
+ is_real = MAPSTEP_REVDES(x1, y1, x, y, dir, is_reversed);
/* It makes no sense to draw a goto line to a non-existent tile. */
assert(is_real);
+ /* we need to review this for reversed topologies */
+ assert(!is_reversed);
if (dir >= 4) {
x = x1;
@@ -630,8 +635,10 @@
int get_drawn(int x, int y, int dir)
{
int dummy_x, dummy_y;
+ REVERSE_DESCRIPTOR_TYPE is_reversed;
- if (!MAPSTEP(dummy_x, dummy_y, x, y, dir)) {
+ if (!MAPSTEP_REVDES(dummy_x, dummy_y, x, y, dir, is_reversed)
+ || is_reversed) {
return 0;
}
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/gui-gtk/citydlg.c
freeciv/client/gui-gtk/citydlg.c
--- freeciv-cvs-Jan-04/client/gui-gtk/citydlg.c 2003-11-29 07:05:22.000000000
+0100
+++ freeciv/client/gui-gtk/citydlg.c 2004-01-06 18:30:59.000000000 +0100
@@ -1827,28 +1827,37 @@
for (y = 0; y < CITY_MAP_SIZE; y++)
for (x = 0; x < CITY_MAP_SIZE; x++) {
- int map_x, map_y;
+ int map_x, map_y, nmap_x, nmap_y, rx=x, ry=y;
+
+ if (mapview_canvas_reverse) {
+ rx = CITY_MAP_SIZE -1 -x;
+ ry = CITY_MAP_SIZE -1 -y;
+ }
- if (is_valid_city_coords(x, y)
- && city_map_to_map(&map_x, &map_y, pcity, x, y)
- && tile_get_known(map_x, map_y)) {
- put_one_tile(&store, map_x, map_y,
- x * NORMAL_TILE_WIDTH, y * NORMAL_TILE_WIDTH, TRUE);
- if (pcity->city_map[x][y] == C_TILE_WORKER)
- put_city_tile_output(pdialog->map_canvas_store,
- x * NORMAL_TILE_WIDTH,
- y * NORMAL_TILE_HEIGHT,
- city_get_food_tile(x, y, pcity),
- city_get_shields_tile(x, y, pcity),
- city_get_trade_tile(x, y, pcity));
- else if (pcity->city_map[x][y] == C_TILE_UNAVAILABLE)
- pixmap_frame_tile_red(pdialog->map_canvas_store,
- x * NORMAL_TILE_WIDTH,
- y * NORMAL_TILE_HEIGHT);
+ if (is_valid_city_coords(x, y)) {
+ city_map_to_map(&map_x, &map_y, pcity, x, y);
+ nmap_x = map_x;
+ nmap_y = map_y;
+ normalize_map_pos(&nmap_x, &nmap_y);
+ if (tile_get_known(nmap_x,nmap_y)) {
+ put_one_tile(&store, map_x, map_y,
+ rx * NORMAL_TILE_WIDTH, ry * NORMAL_TILE_WIDTH, TRUE);
+ if (pcity->city_map[x][y] == C_TILE_WORKER)
+ put_city_tile_output(pdialog->map_canvas_store,
+ rx * NORMAL_TILE_WIDTH,
+ ry * NORMAL_TILE_HEIGHT,
+ city_get_food_tile(x, y, pcity),
+ city_get_shields_tile(x, y, pcity),
+ city_get_trade_tile(x, y, pcity));
+ else if (pcity->city_map[x][y] == C_TILE_UNAVAILABLE)
+ pixmap_frame_tile_red(pdialog->map_canvas_store,
+ rx * NORMAL_TILE_WIDTH,
+ ry * NORMAL_TILE_HEIGHT);
+ }
} else {
- pixmap_put_black_tile(pdialog->map_canvas_store,
- x * NORMAL_TILE_WIDTH,
- y * NORMAL_TILE_HEIGHT);
+ pixmap_put_black_tile(pdialog->map_canvas_store,
+ rx * NORMAL_TILE_WIDTH,
+ ry * NORMAL_TILE_HEIGHT);
}
}
}
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/gui-gtk/mapctrl.c
freeciv/client/gui-gtk/mapctrl.c
--- freeciv-cvs-Jan-04/client/gui-gtk/mapctrl.c 2004-01-04 07:15:54.000000000
+0100
+++ freeciv/client/gui-gtk/mapctrl.c 2004-01-06 18:30:59.000000000 +0100
@@ -214,6 +214,7 @@
gtk_widget_grab_focus(turn_done_button);
is_real = canvas_to_map_pos(&xtile, &ytile, ev->x, ev->y);
if (is_real) {
+ normalize_map_pos( &xtile, &ytile);
pcity = map_get_city(xtile, ytile);
}
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/gui-gtk/mapview.c
freeciv/client/gui-gtk/mapview.c
--- freeciv-cvs-Jan-04/client/gui-gtk/mapview.c 2003-11-20 07:02:21.000000000
+0100
+++ freeciv/client/gui-gtk/mapview.c 2004-01-06 18:30:59.000000000 +0100
@@ -38,6 +38,7 @@
#include "climisc.h"
#include "control.h" /* get_unit_in_focus() */
#include "goto.h"
+#include "mapview_common.h"
#include "options.h"
#include "tilespec.h"
@@ -1269,6 +1270,7 @@
**************************************************************************/
void draw_segment(int src_x, int src_y, int dir)
{
+ REVERSE_DESCRIPTOR_TYPE is_reversed;
assert(get_drawn(src_x, src_y, dir) > 0);
if (is_isometric) {
@@ -1279,14 +1281,27 @@
is_real = MAPSTEP(dest_x, dest_y, src_x, src_y, dir);
assert(is_real);
- if (tile_visible_mapcanvas(src_x, src_y)) {
- put_line(map_canvas_store, src_x, src_y, dir);
- put_line(map_canvas->window, src_x, src_y, dir);
- }
- if (tile_visible_mapcanvas(dest_x, dest_y)) {
- put_line(map_canvas_store, dest_x, dest_y, DIR_REVERSE(dir));
- put_line(map_canvas->window, dest_x, dest_y, DIR_REVERSE(dir));
- }
+ near_orbit_iterate(src_x, src_y, orb_x, orb_y) {
+ is_reversed = COMBINE_DESCRIPTOR(revdes_map_pos(orb_x, orb_y),
+ mapview_canvas_reverse);
+ if (tile_visible_mapcanvas(orb_x, orb_y)) {
+ put_line(map_canvas_store, orb_x, orb_y,
+ NORMALIZE_DIR(dir, is_reversed));
+ put_line(map_canvas->window, orb_x, orb_y,
+ NORMALIZE_DIR(dir, is_reversed));
+ }
+ } near_orbit_iterate_end;
+
+ near_orbit_iterate(dest_x, dest_y, orb_x, orb_y) {
+ is_reversed = COMBINE_DESCRIPTOR(revdes_map_pos(orb_x, orb_y),
+ mapview_canvas_reverse);
+ if (tile_visible_mapcanvas(orb_x, orb_y)) {
+ put_line(map_canvas_store, orb_x, orb_y,
+ NORMALIZE_DIR(dir, !is_reversed));
+ put_line(map_canvas->window, orb_x, orb_y,
+ NORMALIZE_DIR(dir, !is_reversed));
+ }
+ } near_orbit_iterate_end;
}
}
@@ -1483,14 +1498,21 @@
struct unit *punit, *pfocus;
enum tile_special_type special;
int count, i = 0;
- bool solid_bg, fog, tile_hilited;
+ bool solid_bg, fog, tile_hilited, is_reversed;
struct canvas_store canvas_store = {pm};
if (!width || !(height || height_unit))
return;
+
- count = fill_tile_sprite_array_iso(tile_sprs, coasts, dither,
- x, y, citymode, &solid_bg);
+ if (normalize_map_pos_revdes(&x, &y, &is_reversed)) {
+ is_reversed = COMBINE_DESCRIPTOR(is_reversed, mapview_canvas_reverse);
+ count = fill_tile_sprite_array_iso(tile_sprs, coasts, dither,
+ x, y, citymode, &solid_bg,
+ is_reversed);
+ } else {
+ count = -1;
+ }
if (count == -1) { /* tile is unknown */
pixmap_put_black_tile_iso(pm, canvas_x, canvas_y,
@@ -1498,10 +1520,6 @@
return;
}
- /* Replace with check for is_normal_tile later */
- assert(is_real_map_pos(x, y));
- normalize_map_pos(&x, &y);
-
fog = tile_get_known(x, y) == TILE_KNOWN_FOGGED && draw_fog_of_war;
pcity = map_get_city(x, y);
punit = get_drawable_unit(x, y, citymode);
@@ -1656,7 +1674,8 @@
}
/* National borders */
- tile_draw_borders_iso(&canvas_store, x, y, canvas_x, canvas_y, draw);
+ tile_draw_borders_iso(&canvas_store, x, y, canvas_x, canvas_y, draw,
+ is_reversed);
if (draw_coastline && !draw_terrain) {
enum tile_terrain_type t1 = map_get_terrain(x, y), t2;
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/gui-sdl/mapview.c
freeciv/client/gui-sdl/mapview.c
--- freeciv-cvs-Jan-04/client/gui-sdl/mapview.c 2004-01-05 07:15:55.000000000
+0100
+++ freeciv/client/gui-sdl/mapview.c 2004-01-06 18:30:59.000000000 +0100
@@ -2109,7 +2109,7 @@
count =
fill_tile_sprite_array_iso(pTile_sprs, pCoasts, NULL, map_col,
- map_row, citymode, &solid_bg);
+ map_row, citymode, &solid_bg,FALSE);
if (count == -1) { /* tile is unknown */
des.x = map_x;
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/gui-xaw/citydlg.c
freeciv/client/gui-xaw/citydlg.c
--- freeciv-cvs-Jan-04/client/gui-xaw/citydlg.c 2003-11-29 07:05:25.000000000
+0100
+++ freeciv/client/gui-xaw/citydlg.c 2004-01-06 18:30:59.000000000 +0100
@@ -1539,22 +1539,26 @@
for(y=0; y<CITY_MAP_SIZE; y++) {
for(x=0; x<CITY_MAP_SIZE; x++) {
- int map_x, map_y, canvas_x, canvas_y;
+ int map_x, map_y, nmap_x, nmap_y, canvas_x, canvas_y;
- if (is_valid_city_coords(x, y)
- && city_map_to_map(&map_x, &map_y, pcity, x, y)
- && tile_get_known(map_x, map_y)
- && city_to_canvas_pos(&canvas_x, &canvas_y, x, y)) {
- put_one_tile(&store, map_x, map_y, canvas_x, canvas_y, TRUE);
- if (pcity->city_map[x][y] == C_TILE_WORKER)
- put_city_tile_output(XtWindow(pdialog->map_canvas),
- canvas_x, canvas_y,
- city_get_food_tile(x, y, pcity),
- city_get_shields_tile(x, y, pcity),
- city_get_trade_tile(x, y, pcity));
- else if (pcity->city_map[x][y] == C_TILE_UNAVAILABLE)
- pixmap_frame_tile_red(XtWindow(pdialog->map_canvas),
- canvas_x, canvas_y);
+ if (is_valid_city_coords(x, y)) {
+ city_map_to_map(&map_x, &map_y, pcity, x, y);
+ nmap_x=map_x;
+ nmap_y=map_y;
+ normalize_map_pos(&nmap_x, &nmap_y);
+ if(tile_get_known(nmap_x, nmap_y)
+ && city_to_canvas_pos(&canvas_x, &canvas_y, x, y)) {
+ put_one_tile(&store, map_x, map_y, canvas_x, canvas_y, TRUE);
+ if (pcity->city_map[x][y] == C_TILE_WORKER)
+ put_city_tile_output(XtWindow(pdialog->map_canvas),
+ canvas_x, canvas_y,
+ city_get_food_tile(x, y, pcity),
+ city_get_shields_tile(x, y, pcity),
+ city_get_trade_tile(x, y, pcity));
+ else if (pcity->city_map[x][y] == C_TILE_UNAVAILABLE)
+ pixmap_frame_tile_red(XtWindow(pdialog->map_canvas),
+ canvas_x, canvas_y);
+ }
}
}
}
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/gui-xaw/mapview.c
freeciv/client/gui-xaw/mapview.c
--- freeciv-cvs-Jan-04/client/gui-xaw/mapview.c 2003-11-20 07:02:21.000000000
+0100
+++ freeciv/client/gui-xaw/mapview.c 2004-01-06 18:30:59.000000000 +0100
@@ -1110,21 +1110,31 @@
void draw_segment(int src_x, int src_y, int dir)
{
int dest_x, dest_y, is_real;
-
- assert(get_drawn(src_x, src_y, dir) > 0);
-
+ REVERSE_DESCRIPTOR_TYPE is_reversed;
is_real = MAPSTEP(dest_x, dest_y, src_x, src_y, dir);
assert(is_real);
- if (tile_visible_mapcanvas(src_x, src_y)) {
- put_line(map_canvas_store, src_x, src_y, dir);
- put_line(XtWindow(map_canvas), src_x, src_y, dir);
- }
-
- if (tile_visible_mapcanvas(dest_x, dest_y)) {
- put_line(map_canvas_store, dest_x, dest_y, DIR_REVERSE(dir));
- put_line(XtWindow(map_canvas), dest_x, dest_y, DIR_REVERSE(dir));
- }
+ near_orbit_iterate(src_x, src_y, orb_x, orb_y) {
+ is_reversed = COMBINE_DESCRIPTOR(revdes_map_pos(orb_x, orb_y),
+ mapview_canvas_reverse);
+ if (tile_visible_mapcanvas(orb_x, orb_y)) {
+ put_line(map_canvas_store, orb_x, orb_y,
+ NORMALIZE_DIR(dir, is_reversed));
+ put_line(XtWindow(map_canvas), orb_x, orb_y,
+ NORMALIZE_DIR(dir, is_reversed));
+ }
+ } near_orbit_iterate_end;
+
+ near_orbit_iterate(dest_x, dest_y, orb_x, orb_y) {
+ is_reversed = COMBINE_DESCRIPTOR(revdes_map_pos(orb_x, orb_y),
+ mapview_canvas_reverse);
+ if (tile_visible_mapcanvas(orb_x, orb_y)) {
+ put_line(map_canvas_store, orb_x, orb_y,
+ NORMALIZE_DIR(dir, !is_reversed));
+ put_line(XtWindow(map_canvas), orb_x, orb_y,
+ NORMALIZE_DIR(dir, !is_reversed));
+ }
+ } near_orbit_iterate_end;
}
/**************************************************************************
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/mapctrl_common.c
freeciv/client/mapctrl_common.c
--- freeciv-cvs-Jan-04/client/mapctrl_common.c 2004-01-04 07:15:53.000000000
+0100
+++ freeciv/client/mapctrl_common.c 2004-01-06 18:30:59.000000000 +0100
@@ -141,6 +141,7 @@
/* Tile passed all tests; process it.
*/
+ normalize_map_pos(&tile_x, &tile_y);
ptile = map_get_tile(tile_x, tile_y);
pcity = ptile->city;
if (pcity && pcity->owner == game.player_idx) {
@@ -594,7 +595,8 @@
&& draw_goto_line) {
int x, y, old_x, old_y;
- if (!canvas_to_map_pos(&x, &y, canvas_x, canvas_y)) {
+ canvas_to_map_pos(&x, &y, canvas_x, canvas_y);
+ if (!normalize_map_pos(&x, &y)) {
nearest_real_pos(&x, &y);
}
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/mapview_common.c
freeciv/client/mapview_common.c
--- freeciv-cvs-Jan-04/client/mapview_common.c 2003-11-18 07:02:24.000000000
+0100
+++ freeciv/client/mapview_common.c 2004-01-06 23:27:01.000000000 +0100
@@ -9,7 +9,7 @@
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-***********************************************************************/
+******************************************************************2*****/
#ifdef HAVE_CONFIG_H
#include <config.h>
@@ -32,8 +32,9 @@
#include "mapview_common.h"
struct canvas mapview_canvas;
+bool mapview_canvas_reverse=FALSE;
-/* Overview oordinates of the upper left corner of the map overview. */
+/* Overview coordinates of the upper left corner of the map overview. */
int map_overview_x0, map_overview_y0;
static void base_canvas_to_map_pos(int *map_x, int *map_y,
@@ -43,70 +44,67 @@
/**************************************************************************
Refreshes a single tile on the map canvas.
**************************************************************************/
-void refresh_tile_mapcanvas(int x, int y, bool write_to_screen)
-{
- assert(is_real_map_pos(x, y));
- if (!normalize_map_pos(&x, &y)) {
- return;
- }
-
- if (tile_visible_mapcanvas(x, y)) {
- update_map_canvas(x, y, 1, 1, FALSE);
- if (update_city_text_in_refresh_tile
- && (draw_city_names || draw_city_productions)) {
- /* FIXME: update_map_canvas() will overwrite the city descriptions.
- * This is a workaround that redraws the city descriptions (most of
- * the time). Although it seems inefficient to redraw the
- * descriptions for so many tiles, remember that most of them don't
- * have cities on them.
- *
- * This workaround is unnecessary for clients that use a separate
- * buffer for the city descriptions, and will not work well for
- * anti-aliased text (since it uses partial transparency). Thus some
- * clients may turn it off by setting
- * update_city_text_in_refresh_tile. */
- int canvas_x, canvas_y;
- struct city *pcity;
-
- if (is_isometric) {
- /* We assume the city description will be directly below the city,
- * with a width of 1-2 tiles and a height of less than one tile.
- * Remember that units are 50% taller than the normal tile height.
- * 9
- * 7 8
- * 6 4 5
- * 2 3
- * 1
- * Tile 1 is the one being updated; we redraw the city description
- * for tiles 2-8 (actually we end up drawing 1 as well). */
- rectangle_iterate(x - 2, y - 2, 3, 3, city_x, city_y) {
- if ((pcity = map_get_city(city_x, city_y))) {
- map_to_canvas_pos(&canvas_x, &canvas_y, city_x, city_y);
- show_city_desc(pcity, canvas_x, canvas_y);
- }
- } rectangle_iterate_end;
- } else {
+void refresh_tile_mapcanvas(int map_x, int map_y, bool write_to_screen)
+{
+ near_orbit_iterate(map_x, map_y, orb_x, orb_y) {
+ if (tile_visible_mapcanvas(orb_x, orb_y)) {
+ update_map_canvas(orb_x, orb_y, 1, 1, FALSE);
+
+ if (update_city_text_in_refresh_tile
+ && (draw_city_names || draw_city_productions)) {
+ /* FIXME: update_map_canvas() will overwrite the city descriptions.
+ * This is a workaround that redraws the city descriptions (most of
+ * the time). Although it seems inefficient to redraw the
+ * descriptions for so many tiles, remember that most of them don't
+ * have cities on them.
+ *
+ * This workaround is unnecessary for clients that use a separate
+ * buffer for the city descriptions, and will not work well for
+ * anti-aliased text (since it uses partial transparency). Thus some
+ * clients may turn it off by setting
+ * update_city_text_in_refresh_tile. */
+ int canvas_x, canvas_y;
+ struct city *pcity;
+ if (is_isometric) {
+ /* We assume the city description will be directly below the city,
+ * with a width of 1-2 tiles and a height of less than one tile.
+ * Remember that units are 50% taller than the normal tile height.
+ * 9
+ * 7 8
+ * 6 4 5
+ * 2 3
+ * 1
+ * Tile 1 is the one being updated; we redraw the city description
+ * for tiles 2-8 (actually we end up drawing 1 as well). */
+ rectangle_iterate(orb_x - 2, orb_y - 2, 3, 3, city_x, city_y) {
+ if ((pcity = map_get_city(city_x, city_y))) {
+ map_to_canvas_pos(&canvas_x, &canvas_y, city_x, city_y);
+ show_city_desc(pcity, canvas_x, canvas_y);
+ }
+ } rectangle_iterate_end;
+ } else {
/* We assume the city description will be held in the three tiles
* right below the city.
* 234
* 1
* Tile 1 is the one being updated; we redraw the city description
* for tiles 2, 3, and 4. */
- rectangle_iterate(x - 1, y - 1, 3, 1, city_x, city_y) {
+ rectangle_iterate(orb_x - 1, orb_y - 1, 3, 1, city_x, city_y) {
if ((pcity = map_get_city(city_x, city_y))) {
map_to_canvas_pos(&canvas_x, &canvas_y, city_x, city_y);
show_city_desc(pcity, canvas_x, canvas_y);
}
} rectangle_iterate_end;
+ }
}
}
if (write_to_screen) {
flush_dirty();
- }
- }
- overview_update_tile(x, y);
+ }
+ } near_orbit_iterate_end;
+ overview_update_tile(map_x, map_y);
}
/**************************************************************************
@@ -173,22 +171,15 @@
parts of the code assume NORMAL_TILE_WIDTH and NORMAL_TILE_HEIGHT
to be even numbers.
**************************************************************************/
-bool map_to_canvas_pos(int *canvas_x, int *canvas_y, int map_x, int map_y)
+bool map_to_canvas_pos(int *pcancas_x, int *pcancas_y, int map_x, int map_y)
{
- int center_map_x, center_map_y, dx, dy;
+ map_x -= mapview_canvas.map_x0;
+ map_y -= mapview_canvas.map_y0;
- /*
- * First we wrap the coordinates to hopefully be within the the mapview
- * window. We do this by finding the position closest to the center
- * of the window.
- */
- /* TODO: Cache the value of this position */
- base_canvas_to_map_pos(¢er_map_x, ¢er_map_y,
- mapview_canvas.width / 2,
- mapview_canvas.height / 2);
- map_distance_vector(&dx, &dy, center_map_x, center_map_y, map_x, map_y);
- map_x = center_map_x + dx;
- map_y = center_map_y + dy;
+ if (mapview_canvas_reverse) {
+ map_x = -map_x + mapview_canvas.tile_width - 1;
+ map_y = -map_y + mapview_canvas.tile_height - 1;
+ }
if (is_isometric) {
/* For a simpler example of this math, see city_to_canvas_pos(). */
@@ -205,11 +196,9 @@
* 789 4 8
* 7
*/
- iso_x = (map_x - map_y)
- - (mapview_canvas.map_x0 - mapview_canvas.map_y0);
- iso_y = (map_x + map_y)
- - (mapview_canvas.map_x0 + mapview_canvas.map_y0);
-
+ iso_x = (map_x - map_y);
+ iso_y = (map_x + map_y);
+
/*
* As the above picture shows, each isometric-coordinate unit
* corresponds to a half-tile on the canvas. Since the (x0, y0)
@@ -218,24 +207,27 @@
* corner of the surrounding rectangle we must subtract off an
* additional half-tile in the X direction.
*/
- *canvas_x = (iso_x - 1) * NORMAL_TILE_WIDTH / 2;
- *canvas_y = iso_y * NORMAL_TILE_HEIGHT / 2;
+
+ *pcancas_x = (iso_x - 1) * NORMAL_TILE_WIDTH / 2;
+ *pcancas_y = iso_y * NORMAL_TILE_HEIGHT / 2;
+
} else { /* is_isometric */
- *canvas_x = map_x - mapview_canvas.map_x0;
- *canvas_y = map_y - mapview_canvas.map_y0;
- *canvas_x *= NORMAL_TILE_WIDTH;
- *canvas_y *= NORMAL_TILE_HEIGHT;
+ *pcancas_x = map_x;
+ *pcancas_y = map_y;
+
+ *pcancas_x *= NORMAL_TILE_WIDTH;
+ *pcancas_y *= NORMAL_TILE_HEIGHT;
}
/*
* Finally we clip; checking to see if _any part_ of the tile is
* visible on the canvas.
*/
- return (*canvas_x > -NORMAL_TILE_WIDTH
- && *canvas_x < mapview_canvas.width
- && *canvas_y > -NORMAL_TILE_HEIGHT
- && *canvas_y < mapview_canvas.height);
+ return (*pcancas_x > -NORMAL_TILE_WIDTH
+ && *pcancas_x < mapview_canvas.width
+ && *pcancas_y > -NORMAL_TILE_HEIGHT
+ && *pcancas_y < mapview_canvas.height);
}
/****************************************************************************
@@ -273,8 +265,10 @@
*
* For another example of this math, see canvas_to_city_pos().
*/
- *map_x = DIVIDE(canvas_x * H + canvas_y * W, W * H);
- *map_y = DIVIDE(canvas_y * W - canvas_x * H, W * H);
+
+ *map_x = DIVIDE(canvas_x * H + canvas_y * W, W * H);
+ *map_y = DIVIDE(canvas_y * W - canvas_x * H, W * H);
+
} else { /* is_isometric */
/* We use DIVIDE so that we will get the correct result even
* for negative (off-canvas) coordinates. */
@@ -282,6 +276,10 @@
*map_y = DIVIDE(canvas_y, H);
}
+ if (mapview_canvas_reverse) {
+ *map_x = mapview_canvas.tile_width - 1 - *map_x;
+ *map_y = mapview_canvas.tile_height - 1 - *map_y;
+ }
*map_x += mapview_canvas.map_x0;
*map_y += mapview_canvas.map_y0;
}
@@ -292,11 +290,12 @@
TRUE if the position is real; in this case it will be normalized. Returns
FALSE if the tile is unreal - caller may use nearest_real_pos() if
required.
+ no more, in reversed wrapping we need to preserve non normal pos ![mburda]
**************************************************************************/
bool canvas_to_map_pos(int *map_x, int *map_y, int canvas_x, int canvas_y)
{
base_canvas_to_map_pos(map_x, map_y, canvas_x, canvas_y);
- return normalize_map_pos(map_x, map_y);
+ return is_real_map_pos(*map_x, *map_y);
}
/****************************************************************************
@@ -304,29 +303,37 @@
****************************************************************************/
static void set_mapview_origin(int map_x0, int map_y0)
{
- int nat_x0, nat_y0, xmin, xmax, ymin, ymax, xsize, ysize;
-
+ int nat_x0, nat_y0, nat_center_x, nat_center_y, xmin, xmax, ymin, ymax,
+ xsize, ysize;
+ REVERSE_DESCRIPTOR_TYPE reverse;
+
/* First wrap/clip the position. Wrapping is done in native positions
* while clipping is done in scroll (native) positions. */
map_to_native_pos(&nat_x0, &nat_y0, map_x0, map_y0);
get_mapview_scroll_window(&xmin, &ymin, &xmax, &ymax, &xsize, &ysize);
- if (topo_has_flag(TF_WRAPX)) {
- nat_x0 = FC_WRAP(nat_x0, map.xsize);
- } else {
+ if (XWRAP_TYPE_IS(WT_NONE)) {
nat_x0 = CLIP(xmin, nat_x0, xmax - xsize);
}
-
- if (topo_has_flag(TF_WRAPY)) {
- nat_y0 = FC_WRAP(nat_y0, map.ysize);
- } else {
+ if (YWRAP_TYPE_IS(WT_NONE)) {
nat_y0 = CLIP(ymin, nat_y0, ymax - ysize);
}
+ nat_center_x = nat_x0 + mapview_canvas.tile_width / 2;
+ nat_center_y = nat_y0 + mapview_canvas.tile_height / 2;
+ normalize_nat_pos_revdes(&nat_center_x, &nat_center_y, &reverse);
+ if ((REVERSE_CANVAS_IN_ISOVIEW && is_isometric) || !is_isometric) {
+ mapview_canvas_reverse =
+ COMBINE_DESCRIPTOR(reverse, mapview_canvas_reverse);
+ refresh_overview_canvas();
+ }
+ nat_x0= nat_center_x - mapview_canvas.tile_width/2;
+ nat_y0= nat_center_y - mapview_canvas.tile_height/2;
native_to_map_pos(&map_x0, &map_y0, nat_x0, nat_y0);
/* Then update everything. */
- if (mapview_canvas.map_x0 != map_x0 || mapview_canvas.map_y0 != map_y0) {
+ if (mapview_canvas.map_x0 != map_x0 || mapview_canvas.map_y0 != map_y0
+ || reverse != REVERSE_NONE) {
int map_center_x, map_center_y;
mapview_canvas.map_x0 = map_x0;
@@ -464,13 +471,13 @@
/* Now override the above to satisfy wrapping constraints. We allow the
* scrolling to cover the full range of the map, plus one unit in each
* direction (to allow scrolling with the scroll bars, for instance). */
- if (topo_has_flag(TF_WRAPX)) {
- *xmin = -1;
- *xmax = map.xsize + *xsize;
- }
- if (topo_has_flag(TF_WRAPY)) {
- *ymin = -1;
- *ymax = map.ysize + *ysize;
+ if (!XWRAP_TYPE_IS(WT_NONE)) {
+ *xmin = -mapview_canvas.tile_width / 2;
+ *xmax = map.xsize-1 + mapview_canvas.tile_width / 2;
+ }
+ if (!YWRAP_TYPE_IS(WT_NONE)) {
+ *ymin = -mapview_canvas.tile_height / 2;
+ *ymax = map.ysize-1 + mapview_canvas.tile_height / 2;
}
freelog(LOG_DEBUG, "x: %d<-%d->%d; y: %d<-%d->%d",
@@ -480,10 +487,17 @@
/****************************************************************************
Find the current scroll position (origin) of the mapview.
****************************************************************************/
-void get_mapview_scroll_pos(int *scroll_x, int *scroll_y)
+void get_mapview_scroll_pos(int *pscroll_x, int *pscroll_y)
{
- map_to_native_pos(scroll_x, scroll_y,
+ int xmin, ymin, xmax, ymax, xsize, ysize;
+
+ map_to_native_pos(pscroll_x, pscroll_y,
mapview_canvas.map_x0, mapview_canvas.map_y0);
+ if (mapview_canvas_reverse) {
+ get_mapview_scroll_window(&xmin, &ymin, &xmax, &ymax, &xsize, &ysize);
+ *pscroll_x = xmax - *pscroll_x + xmin - xsize;
+ *pscroll_y = ymax - *pscroll_y + ymin - ysize;
+ }
}
/****************************************************************************
@@ -492,6 +506,16 @@
void set_mapview_scroll_pos(int scroll_x, int scroll_y)
{
int map_x0, map_y0;
+ int xmin, ymin, xmax, ymax, xsize, ysize;
+
+ get_mapview_scroll_window(&xmin, &ymin, &xmax, &ymax, &xsize, &ysize);
+
+ if (scroll_x > xmax - xsize) { scroll_x = xmax - xsize;}
+ if (scroll_y > ymax - ysize) { scroll_y = ymax - ysize;}
+ if (mapview_canvas_reverse) {
+ scroll_x = xmax - scroll_x + xmin - xsize;
+ scroll_y = ymax - scroll_y + ymin - ysize;
+ }
native_to_map_pos(&map_x0, &map_y0, scroll_x, scroll_y);
set_mapview_origin(map_x0, map_y0);
@@ -515,13 +539,20 @@
void center_tile_mapcanvas(int map_center_x, int map_center_y)
{
int map_x = map_center_x, map_y = map_center_y;
+
+ if(mapview_canvas_reverse) {
+ map_center_x = map.xsize - 1 - map_center_x;
+ map_center_y = map.ysize - 1 - map_center_y;
+ }
/* Find top-left corner. */
if (is_isometric) {
- map_x -= mapview_canvas.tile_width / 2;
- map_y += mapview_canvas.tile_width / 2;
- map_x -= mapview_canvas.tile_height / 2;
- map_y -= mapview_canvas.tile_height / 2;
+ {
+ map_x -= mapview_canvas.tile_width / 2;
+ map_y += mapview_canvas.tile_width / 2;
+ map_x -= mapview_canvas.tile_height / 2;
+ map_y -= mapview_canvas.tile_height / 2;
+ }
} else {
map_x -= mapview_canvas.tile_width / 2;
map_y -= mapview_canvas.tile_height / 2;
@@ -575,19 +606,19 @@
* border, then it's a border tile. We can only really check the
* scrolling when the mapview window lines up with the map. */
if (canvas_x < border_x
- && (!same || scroll_x > xmin || topo_has_flag(TF_WRAPX))) {
+ && (!same || scroll_x > xmin || !XWRAP_TYPE_IS(WT_NONE))) {
return FALSE;
}
if (canvas_y < border_y
- && (!same || scroll_y > ymin || topo_has_flag(TF_WRAPY))) {
+ && (!same || scroll_y > ymin || !YWRAP_TYPE_IS(WT_NONE))) {
return FALSE;
}
if (canvas_x + NORMAL_TILE_WIDTH > mapview_canvas.width - border_x
- && (!same || scroll_x + xsize >= xmax || topo_has_flag(TF_WRAPX))) {
+ && (!same || scroll_x + xsize >= xmax || !XWRAP_TYPE_IS(WT_NONE))) {
return FALSE;
}
if (canvas_y + NORMAL_TILE_HEIGHT > mapview_canvas.height - border_y
- && (!same || scroll_y + ysize >= ymax || topo_has_flag(TF_WRAPY))) {
+ && (!same || scroll_y + ysize >= ymax || !YWRAP_TYPE_IS(WT_NONE))) {
return FALSE;
}
@@ -650,7 +681,7 @@
**************************************************************************/
static void tile_draw_borders(struct canvas_store *pcanvas_store,
int map_x, int map_y,
- int canvas_x, int canvas_y)
+ int canvas_x, int canvas_y, bool is_reversed)
{
struct player *this_owner = map_get_owner(map_x, map_y), *adjc_owner;
int x1, y1;
@@ -660,7 +691,7 @@
}
/* left side */
- if (MAPSTEP(x1, y1, map_x, map_y, DIR8_WEST)
+ if (MAPSTEP(x1, y1, map_x, map_y, NORMALIZE_DIR(DIR8_WEST,is_reversed))
&& this_owner != (adjc_owner = map_get_owner(x1, y1))
&& tile_get_known(x1, y1)
&& this_owner) {
@@ -670,7 +701,7 @@
}
/* top side */
- if (MAPSTEP(x1, y1, map_x, map_y, DIR8_NORTH)
+ if (MAPSTEP(x1, y1, map_x, map_y, NORMALIZE_DIR(DIR8_NORTH,is_reversed))
&& this_owner != (adjc_owner = map_get_owner(x1, y1))
&& tile_get_known(x1, y1)
&& this_owner) {
@@ -679,7 +710,7 @@
}
/* right side */
- if (MAPSTEP(x1, y1, map_x, map_y, DIR8_EAST)
+ if (MAPSTEP(x1, y1, map_x, map_y, NORMALIZE_DIR(DIR8_EAST,is_reversed))
&& this_owner != (adjc_owner = map_get_owner(x1, y1))
&& tile_get_known(x1, y1)
&& this_owner) {
@@ -689,7 +720,7 @@
}
/* bottom side */
- if (MAPSTEP(x1, y1, map_x, map_y, DIR8_SOUTH)
+ if (MAPSTEP(x1, y1, map_x, map_y, NORMALIZE_DIR(DIR8_SOUTH,is_reversed))
&& this_owner != (adjc_owner = map_get_owner(x1, y1))
&& tile_get_known(x1, y1)
&& this_owner) {
@@ -709,11 +740,15 @@
struct drawn_sprite tile_sprs[80];
bool solid_bg;
struct player *pplayer;
- bool is_real = normalize_map_pos(&map_x, &map_y);
+ REVERSE_DESCRIPTOR_TYPE is_tile_reversed;
+ bool is_real =
+ normalize_map_pos_revdes(&map_x, &map_y, &is_tile_reversed);
+ int combined_reversed =
+ COMBINE_DESCRIPTOR(is_tile_reversed, mapview_canvas_reverse);
if (is_real && tile_get_known(map_x, map_y)) {
int count = fill_tile_sprite_array(tile_sprs, map_x, map_y, citymode,
- &solid_bg, &pplayer);
+ &solid_bg, &pplayer, combined_reversed);
int i = 0;
if (solid_bg) {
@@ -775,14 +810,16 @@
}
/* Draw national borders. */
- tile_draw_borders(pcanvas_store, map_x, map_y, canvas_x, canvas_y);
+ tile_draw_borders(pcanvas_store, map_x, map_y, canvas_x, canvas_y,
+ combined_reversed);
if (draw_coastline && !draw_terrain) {
enum tile_terrain_type t1 = map_get_terrain(map_x, map_y), t2;
int x1, y1;
/* left side */
- if (MAPSTEP(x1, y1, map_x, map_y, DIR8_WEST)) {
+ if (MAPSTEP(x1, y1, map_x, map_y,
+ NORMALIZE_DIR(DIR8_WEST, combined_reversed))) {
t2 = map_get_terrain(x1, y1);
if (is_ocean(t1) ^ is_ocean(t2)) {
gui_put_line(pcanvas_store, COLOR_STD_OCEAN, LINE_NORMAL,
@@ -791,7 +828,8 @@
}
/* top side */
- if (MAPSTEP(x1, y1, map_x, map_y, DIR8_NORTH)) {
+ if (MAPSTEP(x1, y1, map_x, map_y,
+ NORMALIZE_DIR(DIR8_NORTH, combined_reversed))) {
t2 = map_get_terrain(x1, y1);
if (is_ocean(t1) ^ is_ocean(t2)) {
gui_put_line(pcanvas_store, COLOR_STD_OCEAN, LINE_NORMAL,
@@ -854,7 +892,7 @@
void tile_draw_borders_iso(struct canvas_store *pcanvas_store,
int map_x, int map_y,
int canvas_x, int canvas_y,
- enum draw_type draw)
+ enum draw_type draw, bool is_reversed)
{
struct player *this_owner = map_get_owner(map_x, map_y), *adjc_owner;
int x1, y1;
@@ -864,7 +902,9 @@
}
/* left side */
- if ((draw & D_M_L) && MAPSTEP(x1, y1, map_x, map_y, DIR8_WEST)
+ if ((draw & D_M_L)
+ && MAPSTEP(x1, y1, map_x, map_y,
+ NORMALIZE_DIR(DIR8_WEST, is_reversed))
&& this_owner != (adjc_owner = map_get_owner(x1, y1))
&& tile_get_known(x1, y1)) {
if (adjc_owner) {
@@ -884,7 +924,9 @@
}
/* top side */
- if ((draw & D_M_R) && MAPSTEP(x1, y1, map_x, map_y, DIR8_NORTH)
+ if ((draw & D_M_R)
+ && MAPSTEP(x1, y1, map_x, map_y,
+ NORMALIZE_DIR(DIR8_NORTH, is_reversed))
&& this_owner != (adjc_owner = map_get_owner(x1, y1))
&& tile_get_known(x1, y1)) {
if (adjc_owner) {
@@ -955,15 +997,9 @@
offset_y_unit = NORMAL_TILE_HEIGHT;
}
- if (normalize_map_pos(&map_x, &map_y)) {
- gui_map_put_tile_iso(map_x, map_y, canvas_x, canvas_y,
- offset_x, offset_y, offset_y_unit,
- width, height, height_unit,
- draw);
- } else {
- gui_put_sprite(mapview_canvas.store, canvas_x, canvas_y,
- sprites.black_tile, offset_x, offset_y, width, height);
- }
+ gui_map_put_tile_iso(map_x, map_y, canvas_x, canvas_y,
+ offset_x, offset_y, offset_y_unit,
+ width, height, height_unit, draw);
}
}
@@ -1232,6 +1268,11 @@
static struct timer *anim_timer = NULL;
int dest_x, dest_y;
+ if (mapview_canvas_reverse) {
+ dx = -dx;
+ dy = -dy;
+ }
+
/* only works for adjacent-square moves */
if (dx < -1 || dx > 1 || dy < -1 || dy > 1 || (dx == 0 && dy == 0)) {
return;
@@ -1529,7 +1570,7 @@
/**************************************************************************
Finds the overview (canvas) coordinates for a given map position.
**************************************************************************/
-void map_to_overview_pos(int *overview_x, int *overview_y,
+void map_to_overview_pos(int *poverview_x, int *poverview_y,
int map_x, int map_y)
{
int gui_x, gui_y;
@@ -1541,27 +1582,38 @@
map_to_native_pos(&gui_x, &gui_y, map_x, map_y);
gui_x -= map_overview_x0;
gui_y -= map_overview_y0;
+
+ if( mapview_canvas_reverse) {
+ gui_x = map.xsize - 1 - gui_x;
+ gui_y = map.ysize - 1 - gui_y;
+ }
+
if (topo_has_flag(TF_WRAPX)) {
gui_x = FC_WRAP(gui_x, map.xsize);
}
if (topo_has_flag(TF_WRAPY)) {
gui_y = FC_WRAP(gui_y, map.ysize);
}
- *overview_x = OVERVIEW_TILE_WIDTH * gui_x;
- *overview_y = OVERVIEW_TILE_HEIGHT * gui_y;
+
+ *poverview_x = OVERVIEW_TILE_WIDTH * gui_x;
+ *poverview_y = OVERVIEW_TILE_HEIGHT * gui_y;
}
/**************************************************************************
Finds the map coordinates for a given overview (canvas) position.
**************************************************************************/
-void overview_to_map_pos(int *map_x, int *map_y,
+void overview_to_map_pos(int *pmap_x, int *pmap_y,
int overview_x, int overview_y)
{
int nat_x = overview_x / OVERVIEW_TILE_WIDTH + map_overview_x0;
int nat_y = overview_y / OVERVIEW_TILE_HEIGHT + map_overview_y0;
-
- native_to_map_pos(map_x, map_y, nat_x, nat_y);
- if (!normalize_map_pos(map_x, map_y)) {
+
+ if( mapview_canvas_reverse) {
+ nat_x = map.xsize - 1 - nat_x;
+ nat_y = map.ysize - 1 - nat_y;
+ }
+ native_to_map_pos(pmap_x, pmap_y, nat_x, nat_y);
+ if (!normalize_map_pos(pmap_x, pmap_y)) {
/* All positions on the overview should be valid. */
assert(FALSE);
}
@@ -1575,7 +1627,7 @@
{
map_to_overview_pos(&x[0], &y[0],
mapview_canvas.map_x0, mapview_canvas.map_y0);
-
+
/* Note: these calculations operate on overview coordinates as if they
* are native. */
if (is_isometric && !topo_has_flag(TF_ISO)) {
@@ -1611,6 +1663,11 @@
int screen_width = mapview_canvas.tile_width;
int screen_height = mapview_canvas.tile_height * (is_isometric ? 2 : 1);
+ if (mapview_canvas_reverse) {
+ *x -= OVERVIEW_TILE_WIDTH * screen_width;
+ *y -= OVERVIEW_TILE_HEIGHT * screen_height;
+ }
+
/* Northeast */
x[1] = x[0] + OVERVIEW_TILE_WIDTH * screen_width - 1;
y[1] = y[0];
@@ -1622,6 +1679,7 @@
/* Southwest */
x[3] = x[0];
y[3] = y[2];
+
}
freelog(LOG_DEBUG, "(%d,%d)->(%d,%x)->(%d,%d)->(%d,%d)",
@@ -1633,14 +1691,18 @@
position. This may be used by the GUI code to draw to the minimap's
backing store.
**************************************************************************/
-void map_to_base_overview_pos(int *base_overview_x, int *base_overview_y,
+void map_to_base_overview_pos(int *pbase_overview_x, int *pbase_overview_y,
int map_x, int map_y)
{
/* Base overview positions are just like native positions, but scaled to
* the overview tile dimensions. */
- map_to_native_pos(base_overview_x, base_overview_y, map_x, map_y);
- *base_overview_x *= OVERVIEW_TILE_WIDTH;
- *base_overview_y *= OVERVIEW_TILE_HEIGHT;
+ map_to_native_pos(pbase_overview_x, pbase_overview_y, map_x, map_y);
+ if( mapview_canvas_reverse) {
+ *pbase_overview_x = map.xsize - 1 - *pbase_overview_x;
+ *pbase_overview_y = map.ysize - 1 - *pbase_overview_y;
+ }
+ *pbase_overview_x *= OVERVIEW_TILE_WIDTH;
+ *pbase_overview_y *= OVERVIEW_TILE_HEIGHT;
}
/**************************************************************************
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/mapview_common.h
freeciv/client/mapview_common.h
--- freeciv-cvs-Jan-04/client/mapview_common.h 2003-10-01 06:59:02.000000000
+0200
+++ freeciv/client/mapview_common.h 2004-01-06 18:30:59.000000000 +0100
@@ -158,7 +158,7 @@
void tile_draw_borders_iso(struct canvas_store *pcanvas_store,
int map_x, int map_y,
int canvas_x, int canvas_y,
- enum draw_type draw);
+ enum draw_type draw,bool is_reversed);
void update_map_canvas(int x, int y, int width, int height,
bool write_to_screen);
@@ -198,4 +198,10 @@
extern int map_overview_x0, map_overview_y0;
+/* for auto reverse canvas in reversed wrapping topologies */
+extern bool mapview_canvas_reverse;
+/* activate reverse canvas in iso view, reverse canvas is actived all the
+ time in no iso view (this is a devel option only ) */
+#define REVERSE_CANVAS_IN_ISOVIEW FALSE
+
#endif /* FC__MAPVIEW_COMMON_H */
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/packhand.c
freeciv/client/packhand.c
--- freeciv-cvs-Jan-04/client/packhand.c 2003-12-09 07:08:02.000000000
+0100
+++ freeciv/client/packhand.c 2004-01-06 18:30:59.000000000 +0100
@@ -1239,9 +1239,12 @@
**************************************************************************/
void handle_map_info(int xsize, int ysize, bool is_earth, int topology_id)
{
- map.xsize = xsize;
+ /* FIX ME extend handle_map_info to map.size and map.ratio */
+ map.xsize = xsize; /* befor init topologies for avoid asserts */
+ map.ysize = ysize;
+ map_init_topology(topology_id);
+ map.xsize = xsize; /* after init for non default ratios */
map.ysize = ysize;
- map.topology_id = topology_id;
map.is_earth = is_earth;
map_allocate();
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/tilespec.c
freeciv/client/tilespec.c
--- freeciv-cvs-Jan-04/client/tilespec.c 2003-11-30 07:05:57.000000000
+0100
+++ freeciv/client/tilespec.c 2004-01-06 18:30:59.000000000 +0100
@@ -42,6 +42,8 @@
#include "support.h"
#include "unit.h"
+#include "mapview_common.h" /* for mapview_canvas_reverse */
+
#include "civclient.h" /* for get_client_state() */
#include "climap.h" /* for tile_get_known() */
#include "control.h" /* for fill_xxx */
@@ -961,6 +963,7 @@
SET_SPRITE_ALT(tx.fortress_back, "tx.fortress_back", "tx.fortress");
SET_SPRITE(tx.airbase, "tx.airbase");
SET_SPRITE(tx.fog, "tx.fog");
+ SET_SPRITE(tx.lfog, "tx.lfog");
for(i=0; i<NUM_DIRECTION_NSEW; i++) {
my_snprintf(buffer, sizeof(buffer), "tx.s_river_%s", nsew_str(i));
@@ -1369,11 +1372,14 @@
ttype_near : terrain types of all adjacent terrain
tspecial_near : specials of all adjacent terrain
**************************************************************************/
-static void build_tile_data(int map_x, int map_y,
+#define build_tile_data(A,B,C,D,E,F)\
+ build_tile_data_reversed((A),(B),(C),(D),(E),(F),FALSE)
+static void build_tile_data_reversed(int map_x, int map_y,
enum tile_terrain_type *ttype,
enum tile_special_type *tspecial,
enum tile_terrain_type *ttype_near,
- enum tile_special_type *tspecial_near)
+ enum tile_special_type *tspecial_near,
+ bool is_reversed)
{
enum direction8 dir;
@@ -1390,8 +1396,7 @@
/* Loop over all adjacent tiles. We should have an iterator for this. */
for (dir = 0; dir < 8; dir++) {
int x1, y1;
-
- if (MAPSTEP(x1, y1, map_x, map_y, dir)
+ if (MAPSTEP(x1, y1, map_x, map_y,NORMALIZE_DIR(dir, is_reversed))
&& tile_get_known(x1, y1) != TILE_UNKNOWN) {
tspecial_near[dir] = map_get_special(x1, y1);
ttype_near[dir] = map_get_terrain(x1, y1);
@@ -1859,7 +1864,7 @@
struct Sprite **coasts,
struct Sprite **dither,
int x, int y, bool citymode,
- bool *solid_bg)
+ bool *solid_bg,bool is_reversed)
{
enum tile_terrain_type ttype, ttype_near[8];
enum tile_special_type tspecial, tspecial_near[8];
@@ -1874,7 +1879,8 @@
pcity = map_get_city(x, y);
- build_tile_data(x, y, &ttype, &tspecial, ttype_near, tspecial_near);
+ build_tile_data_reversed(x, y, &ttype, &tspecial, ttype_near,
+ tspecial_near, is_reversed);
if (draw_terrain) {
if (is_ocean(ttype)) {
@@ -2031,10 +2037,13 @@
for (dir = 0; dir < 4; dir++) {
int x1, y1, other;
- if (MAPSTEP(x1, y1, x, y, DIR4_TO_DIR8[dir]))
- other = (tile_get_known(x1, y1) != TILE_UNKNOWN) ?
ttype_near[DIR4_TO_DIR8[dir]]:T_UNKNOWN;
+ if (MAPSTEP
+ (x1, y1, x, y, NORMALIZE_DIR(DIR4_TO_DIR8[dir], is_reversed)))
+ other =
+ (tile_get_known(x1, y1) !=
+ TILE_UNKNOWN) ? ttype_near[DIR4_TO_DIR8[dir]] : T_UNKNOWN;
else
- other = ttype_near[dir];
+ other = ttype_near[dir];
dither[dir] = get_dither(ttype, other);
}
}
@@ -2058,10 +2067,11 @@
10) pollution
11) fallout
12) FoW
+13) ligth fog (reversed to canvas)
***********************************************************************/
int fill_tile_sprite_array(struct drawn_sprite *sprs, int abs_x0, int abs_y0,
bool citymode, bool *solid_bg,
- struct player **pplayer)
+ struct player **pplayer, bool is_reversed)
{
enum tile_terrain_type ttype, ttype_near[8];
enum tile_special_type tspecial, tspecial_near[8];
@@ -2106,8 +2116,8 @@
}
}
- build_tile_data(abs_x0, abs_y0,
- &ttype, &tspecial, ttype_near, tspecial_near);
+ build_tile_data_reversed(abs_x0, abs_y0,
+ &ttype, &tspecial, ttype_near, tspecial_near,is_reversed);
if(map.is_earth &&
abs_x0>=34 && abs_x0<=36 && abs_y0>=den_y && abs_y0<=den_y+1) {
@@ -2205,6 +2215,10 @@
ADD_SPRITE_SIMPLE(sprites.tx.fog);
}
+ if( mapview_canvas_reverse != is_reversed) {
+ ADD_SPRITE_SIMPLE(sprites.tx.lfog);
+ }
+
if (!citymode) {
/*
* We're looking to find the INDEX_NSEW for the directions that
@@ -2218,10 +2232,11 @@
for (dir = 0; dir < 4; dir++) {
int x1, y1;
- if (MAPSTEP(x1, y1, abs_x0, abs_y0, DIR4_TO_DIR8[dir]))
- known[dir] = (tile_get_known(x1, y1) != TILE_UNKNOWN);
+ if (MAPSTEP(x1, y1, abs_x0, abs_y0,
+ NORMALIZE_DIR(DIR4_TO_DIR8[dir], is_reversed)))
+ known[dir] = (tile_get_known(x1, y1) != TILE_UNKNOWN);
else
- known[dir] = TRUE;
+ known[dir] = TRUE;
}
tileno =
@@ -2412,10 +2427,13 @@
enum color_std overview_tile_color(int x, int y)
{
enum color_std color;
- struct tile *ptile=map_get_tile(x, y);
+ struct tile *ptile;
struct unit *punit;
struct city *pcity;
+ normalize_map_pos(&x, &y);
+ ptile = map_get_tile(x, y);
+
if (tile_get_known(x, y) == TILE_UNKNOWN) {
color=COLOR_STD_BLACK;
} else if((pcity=map_get_city(x, y))) {
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/client/tilespec.h
freeciv/client/tilespec.h
--- freeciv-cvs-Jan-04/client/tilespec.h 2003-10-16 06:59:07.000000000
+0200
+++ freeciv/client/tilespec.h 2004-01-06 18:30:59.000000000 +0100
@@ -53,15 +53,14 @@
void tilespec_free_city_tiles(int count);
/* Gfx support */
-
int fill_tile_sprite_array_iso(struct drawn_sprite *sprs,
struct Sprite **coasts,
struct Sprite **dither,
int x, int y, bool citymode,
- bool *solid_bg);
-int fill_tile_sprite_array(struct drawn_sprite *sprs, int abs_x0, int abs_y0,
- bool citymode, bool *solid_bg,
- struct player **pplayer);
+ bool *solid_bg,bool is_reversed);
+int fill_tile_sprite_array (struct drawn_sprite *sprs, int abs_x0,
+ int abs_y0, bool citymode, bool *solid_bg,
+ struct player **pplayer, bool is_reversed);
int fill_unit_sprite_array(struct drawn_sprite *sprs,
struct unit *punit, bool *solid_bg);
int fill_city_sprite_array_iso(struct drawn_sprite *sprs,
@@ -198,6 +197,7 @@
*airbase,
*fallout,
*fog,
+ *lfog,
*spec_river[NUM_DIRECTION_NSEW],
*darkness[NUM_DIRECTION_NSEW], /* first unused */
*river_outlet[4], /* indexed by enum direction4 */
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/common/aicore/cm.c
freeciv/common/aicore/cm.c
--- freeciv-cvs-Jan-04/common/aicore/cm.c 2003-11-23 07:07:50.000000000
+0100
+++ freeciv/common/aicore/cm.c 2004-01-06 18:30:59.000000000 +0100
@@ -217,15 +217,6 @@
} tiles[CITY_MAP_SIZE][CITY_MAP_SIZE];
};
-#define my_city_map_iterate(pcity, cx, cy) { \
- city_map_checked_iterate(pcity->x, pcity->y, cx, cy, map_x, map_y) { \
- if(!is_city_center(cx, cy)) {
-
-#define my_city_map_iterate_end \
- } \
- } city_map_checked_iterate_end; \
-}
-
/****************************************************************************
* implementation of utility functions (these are relatively independent
* of the algorithms used)
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/common/aicore/path_finding.c
freeciv/common/aicore/path_finding.c
--- freeciv-cvs-Jan-04/common/aicore/path_finding.c 2003-11-23
07:07:50.000000000 +0100
+++ freeciv/common/aicore/path_finding.c 2004-01-06 18:30:59.000000000
+0100
@@ -265,7 +265,7 @@
/* Processing Stage */
/* The previous position is contained in {x,y} fields of map */
- adjc_dir_iterate(pf_map->x, pf_map->y, x1, y1, dir) {
+ adjc_dir_iterate_full(pf_map->x, pf_map->y, x1, y1, dir, dir1, rev_des) {
mapindex_t index1 = map_pos_to_index(x1, y1);
struct pf_node *node1 = &pf_map->lattice[index1];
utiny_t *status = &pf_map->status[index1];
@@ -324,13 +324,13 @@
*status = NS_NEW;
node1->extra_cost = extra;
node1->cost = cost;
- node1->dir_to_here = dir;
+ node1->dir_to_here = dir1;
pq_insert(pf_map->queue, index1, -cost_of_path);
}
}
}
- adjc_dir_iterate_end;
+ adjc_dir_iterate_full_end;
}
/* Get the next nearest node */
@@ -707,7 +707,7 @@
/***********************************************************************
Creating path segment going back from d_node1 to a safe tile.
***********************************************************************/
-static void create_danger_segment(struct pf_map *pf_map, enum direction8 dir,
+static void create_danger_segment(struct pf_map *pf_map,
struct danger_node *d_node1, int length)
{
int i;
@@ -817,7 +817,7 @@
: d_node->step + 1);
/* The previous position is contained in {x,y} fields of map */
- adjc_dir_iterate(pf_map->x, pf_map->y, x1, y1, dir) {
+ adjc_dir_iterate_full(pf_map->x, pf_map->y, x1, y1, dir, dir1, rev_des) {
mapindex_t index1 = map_pos_to_index(x1, y1);
struct pf_node *node1 = &pf_map->lattice[index1];
struct danger_node *d_node1 = &pf_map->d_lattice[index1];
@@ -880,11 +880,11 @@
< get_total_CC(pf_map, node1->cost, node1->extra_cost))) {
node1->extra_cost = extra;
node1->cost = cost;
- node1->dir_to_here = dir;
+ node1->dir_to_here = dir1;
d_node1->step = loc_step + 1;
if (d_node->is_dangerous) {
/* Transition from red to blue, need to record the path back */
- create_danger_segment(pf_map, dir, d_node1,
+ create_danger_segment(pf_map, d_node1,
d_node->segment_length);
} else {
/* Clear the path back */
@@ -917,7 +917,7 @@
&& pf_map->status[index1] == NS_PROCESSED)) {
node1->extra_cost = extra;
node1->cost = cost;
- node1->dir_to_here = dir;
+ node1->dir_to_here = dir1;
d_node1->step = loc_step + 1;
if (d_node->is_dangerous) {
/* Increment the number of steps we are making across danger */
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/common/city.c freeciv/common/city.c
--- freeciv-cvs-Jan-04/common/city.c 2003-12-07 07:08:41.000000000 +0100
+++ freeciv/common/city.c 2004-01-06 18:30:59.000000000 +0100
@@ -126,32 +126,54 @@
map_x, map_y);
}
+
/**************************************************************************
Finds the map position for a given city map coordinate of a certain
-city. Returns true if the map position found is real.
+city.
**************************************************************************/
-bool base_city_map_to_map(int *map_x, int *map_y,
+void base_city_map_to_map(int *map_x, int *map_y,
int city_center_x, int city_center_y,
int city_map_x, int city_map_y)
{
assert(is_valid_city_coords(city_map_x, city_map_y));
*map_x = city_center_x + city_map_x - CITY_MAP_SIZE / 2;
*map_y = city_center_y + city_map_y - CITY_MAP_SIZE / 2;
- return normalize_map_pos(map_x, map_y);
}
/**************************************************************************
-Finds the map position for a given city map coordinate of a certain
-city. Returns true if the map position found is real.
+Finds the normal map position for a given city map coordinate of a
+certain city. Returns true if the map position found is real.
+**************************************************************************/
+bool normal_city_map_to_map(int *map_x, int *map_y,
+ int city_center_x, int city_center_y,
+ int city_map_x, int city_map_y)
+{
+ assert(is_valid_city_coords(city_map_x, city_map_y));
+ *map_x = city_center_x + city_map_x - CITY_MAP_SIZE / 2;
+ *map_y = city_center_y + city_map_y - CITY_MAP_SIZE / 2;
+ if(IS_BORDER_MAP_POS(city_center_x, city_center_y, 3)) {
+ return normalize_map_pos(map_x, map_y);
+ }
+ return TRUE;
+}
+
+/**************************************************************************
+Finds the map position for a given city map coordinate of a
+certain city. Returns true if the map position found is real.
**************************************************************************/
bool city_map_to_map(int *map_x, int *map_y,
const struct city *const pcity,
int city_map_x, int city_map_y)
{
- return base_city_map_to_map(map_x, map_y,
+ base_city_map_to_map(map_x, map_y,
pcity->x, pcity->y, city_map_x, city_map_y);
+ if(IS_BORDER_MAP_POS(pcity->x, pcity->y, 3)) {
+ return is_real_map_pos(*map_x, *map_y);
+ }
+ return TRUE;
}
+
/**************************************************************************
Set the worker on the citymap. Also sets the worked field in the map.
**************************************************************************/
@@ -160,7 +182,8 @@
{
int map_x, map_y;
- if (city_map_to_map(&map_x, &map_y, pcity, city_x, city_y)) {
+ if (normal_city_map_to_map(&map_x, &map_y, pcity->x, pcity->y,
+ city_x, city_y)) {
struct tile *ptile = map_get_tile(map_x, map_y);
if (pcity->city_map[city_x][city_y] == C_TILE_WORKER
@@ -563,7 +586,8 @@
int before_penalty = (is_celebrating ? g->celeb_shields_before_penalty
: g->shields_before_penalty);
- is_real = city_map_to_map(&map_x, &map_y, pcity, x, y);
+ is_real = normal_city_map_to_map(&map_x, &map_y,
+ pcity->x, pcity->y, x, y);
assert(is_real);
spec_t = map_get_special(map_x, map_y);
@@ -656,7 +680,8 @@
bool is_real;
int map_x, map_y, t;
- is_real = city_map_to_map(&map_x, &map_y, pcity, x, y);
+ is_real = normal_city_map_to_map(&map_x, &map_y,
+ pcity->x, pcity->y, x, y);
assert(is_real);
spec_t = map_get_special(map_x, map_y);
@@ -766,7 +791,8 @@
: g->food_before_penalty);
bool city_auto_water;
- is_real = city_map_to_map(&map_x, &map_y, pcity, x, y);
+ is_real = normal_city_map_to_map(&map_x, &map_y,
+ pcity->x, pcity->y, x, y);
assert(is_real);
spec_t = map_get_special(map_x, map_y);
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/common/city.h freeciv/common/city.h
--- freeciv-cvs-Jan-04/common/city.h 2003-12-07 07:08:41.000000000 +0100
+++ freeciv/common/city.h 2004-01-06 18:31:00.000000000 +0100
@@ -116,6 +116,16 @@
}
\
}
+#define my_city_map_iterate(pcity, cx, cy) { \
+ city_map_checked_iterate(pcity->x, pcity->y, cx, cy, map_x, map_y) { \
+ if(!is_city_center(cx, cy)) {
+
+#define my_city_map_iterate_end \
+ } \
+ } city_map_checked_iterate_end; \
+}
+
+
/*
* Iterate a city map in checked real map coordinates. The center of
* the city is given as a map position (x0,y0). cx and cy will be
@@ -125,7 +135,7 @@
#define city_map_checked_iterate(x0, y0, cx, cy, mx, my) { \
city_map_iterate_outwards(cx, cy) { \
int mx, my; \
- if (base_city_map_to_map(&mx, &my, x0, y0, cx, cy)) {
+ if (normal_city_map_to_map(&mx, &my, x0, y0, cx, cy)) {
#define city_map_checked_iterate_end \
} \
@@ -380,7 +390,10 @@
bool map_to_city_map(int *city_map_x, int *city_map_y,
const struct city *const pcity, int map_x, int map_y);
-bool base_city_map_to_map(int *map_x, int *map_y, int city_center_x,
+void base_city_map_to_map(int *map_x, int *map_y, int city_center_x,
+ int city_center_y, int city_map_x,
+ int city_map_y);
+bool normal_city_map_to_map(int *map_x, int *map_y, int city_center_x,
int city_center_y, int city_map_x,
int city_map_y);
bool city_map_to_map(int *map_x, int *map_y, const struct city *const pcity,
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/common/map.c freeciv/common/map.c
--- freeciv-cvs-Jan-04/common/map.c 2003-12-09 07:08:06.000000000 +0100
+++ freeciv/common/map.c 2004-01-06 18:31:50.000000000 +0100
@@ -170,15 +170,111 @@
{
return !map.tiles;
}
+/********************************************************************
+ refreshmapratio(),setmapratio(int ratio)
+ and ,setmapratio2(int Xratio, int Yratio)
+ choice of legal xsize and ysize with the selected ratio,
+ odd xsize and ysize are not allowed
+ all ratio must be exact
+ the size of map is unchanged if map.size=0
+ or base in map.size new xsize*ysize = 2000*map.size
+ where size get numbers from 1 to 10
+ 1 for a map of 2,000 tiles
+ 10 for a map of 20,000 tiles
+this limit is based assuming ratio is less than 2:1
+ and MAP_MAX_WIDTHandHEIGHT=200
+ [mburda]
+*********************************************************************/
+void refreshmapratio()
+{
+ assert(map.ratio >= 11 && map.ratio <= 100);
+ if (map.ratio != 100)
+ setmapratio2(map.ratio / 10, map.ratio % 10);
+}
+void setmapratio(int ratio)
+{
+ assert(ratio >= 11 && ratio <= 100);
+ if (ratio != 100)
+ setmapratio2(ratio / 10, ratio % 10);
+}
+void setmapratio2(int Xratio, int Yratio)
+{
+ bool odd_ratio = ((Xratio % 2) != 0) || ((Yratio % 2) != 0);
+ int size_max = MAP_MAX_WIDTHandHEIGHT / MAX(Xratio, Yratio);
+ int size_min = MAP_MIN_WIDTHandHEIGHT / MIN(Xratio, Yratio);
+ int size = floor(0.49 + sqrt(2000.0 * map.size / (Xratio * Yratio)));
+ if (map.size > 0) {
+ if (odd_ratio && ((size % 2) != 0)) {
+ size_max = 0.5 * MAP_MAX_WIDTHandHEIGHT / MAX(Xratio, Yratio);
+ size_min = 0.5 * MAP_MIN_WIDTHandHEIGHT / MIN(Xratio, Yratio);
+ size = floor(0.49 + sqrt(500.0 * map.size / (Xratio * Yratio)));
+ assert(size_min <= size_max);
+ if (size < size_min)
+ size = size_min;
+ if (size > size_max)
+ size = size_max;
+ map.xsize = 2 * Xratio * size;
+ map.ysize = 2 * Yratio * size;
+ } else {
+ assert(size_min <= size_max);
+ if (size < size_min)
+ size = size_min;
+ if (size > size_max)
+ size = size_max;
+ map.xsize = Xratio * size;
+ map.ysize = Yratio * size;
+ }
+ }
+}
+/***************************************************************************
+ WARNING: set topology_id this way or at last call it:
+ map_init_topology(map.topology_id)
+
+ Alow set xsize and ysize freely if ratio == 100 and size = -1
+ [mburda]
+*************************************************************************/
+#define INIT_TOPOLOGIE_CASE(TOPO,DEFAULTRATIO,XWRAPT,YWRAPT,POLES) \
+ case TOPO: \
+ if( map.ratio == 100){ \
+ setmapratio(DEFAULTRATIO); \
+ map.ratio=100; \
+ } \
+ refreshmapratio(); \
+ map.xwrap_type=XWRAPT; map.ywrap_type=YWRAPT; \
+ if (POLES >= 0){ \
+ map.separatepoles=POLES; \
+ } \
+ break;
+
+void map_init_topology(int topology_id)
+{
+ map.topology_id = topology_id;
+ switch (topology_id & TF_MASK) {
+ INIT_TOPOLOGIE_CASE(TF_FLAT, DEFAULTRATIO_FLAT, WT_NONE, WT_NONE, 0);
+ INIT_TOPOLOGIE_CASE(TF_CLASSIC, DEFAULTRATIO_CLASSIC, WT_SIMPLEST,
+ WT_NONE, -1);
+ INIT_TOPOLOGIE_CASE(TF_MOBIUS, DEFAULTRATIO_MOBIUS, WT_SIMPLEST,
+ WT_OFFSET, 0);
+ INIT_TOPOLOGIE_CASE(TF_TORUS, DEFAULTRATIO_TORUS, WT_SIMPLEST,
+ WT_SIMPLEST, 0);
+ INIT_TOPOLOGIE_CASE(TF_QUINCUNCIAL_SQ, DEFAULTRATIO_QUINCUNCIAL_SQ,
+ WT_REVERSED, WT_REVERSED, 0);
+ INIT_TOPOLOGIE_CASE(TF_QUINCUNCIAL, DEFAULTRATIO_QUINCUNCIAL,
+ WT_SIMPLEST, WT_REVERSED, 0);
+ INIT_TOPOLOGIE_CASE(TF_SPIN, DEFAULTRATIO_SPIN, WT_REVERSED, WT_NONE,
+ 0);
+ };
+}
/***************************************************************
put some sensible values into the map structure
***************************************************************/
void map_init(void)
{
- map.topology_id = MAP_DEFAULT_TOPO;
- map.xsize = MAP_DEFAULT_WIDTH;
+ map.xsize = MAP_DEFAULT_WIDTH;
map.ysize = MAP_DEFAULT_HEIGHT;
+ map.size = MAP_DEFAULT_SIZE;
+ map.ratio = MAP_DEFAULT_RATIO;
map.seed = MAP_DEFAULT_SEED;
map.riches = MAP_DEFAULT_RICHES;
map.is_earth = FALSE;
@@ -200,6 +296,7 @@
map.have_specials = FALSE;
map.have_rivers_overlay = FALSE;
map.have_huts = FALSE;
+ map_init_topology(MAP_DEFAULT_TOPO); /*at last place [mburda]*/
}
/***************************************************************
@@ -1040,7 +1137,7 @@
return SINGLE_MOVE;
if (tile_has_special(t1, S_RAILROAD) && tile_has_special(t2, S_RAILROAD))
return MOVE_COST_RAIL;
-/* return (unit_move_rate(punit)/RAIL_MAX) */
+ /* return (unit_move_rate(punit)/RAIL_MAX) */
if (punit && unit_flag(punit, F_IGTER))
return SINGLE_MOVE/3;
if (tile_has_special(t1, S_ROAD) && tile_has_special(t2, S_ROAD))
@@ -1145,14 +1242,14 @@
/* trying to move off the screen is the default */
memset(tile0->move_cost, maxcost, sizeof(tile0->move_cost));
- adjc_dir_iterate(x, y, x1, y1, dir) {
+ adjc_dir_iterate_full(x, y, x1, y1, dir, dir1, revdes) {
tile1 = map_get_tile(x1, y1);
tile0->move_cost[dir] = tile_move_cost_ai(tile0, tile1, x, y,
x1, y1, maxcost);
/* reverse: not at all obfuscated now --dwp */
- tile1->move_cost[DIR_REVERSE(dir)] =
+ tile1->move_cost[DIR_REVERSE(dir1)] =
tile_move_cost_ai(tile1, tile0, x1, y1, x, y, maxcost);
- } adjc_dir_iterate_end;
+ } adjc_dir_iterate_full_end;
debug_log_move_costs("Reset move costs for", x, y, tile0);
}
@@ -1202,9 +1299,9 @@
/***************************************************************
...
***************************************************************/
-struct tile *map_get_tile(int x, int y)
+struct tile *map_get_tile(int map_x, int map_y)
{
- return MAP_TILE(x, y);
+ return MAP_TILE(map_x, map_y);
}
/***************************************************************
@@ -1361,55 +1458,272 @@
}
/**************************************************************************
+ *return the reverse desciptor of a map pos*
+ * allow the 9 topology xwrap_type-ywrap_type with the WT_REVERSED,WT_SIMPLEST,
+ * WT_NONE and the 10th topology XRAP=WT_SIMPLEST , YWRAP=WT_OFFSET
+ * [mburda]
+**************************************************************************/
+REVERSE_DESCRIPTOR_TYPE revdes_map_pos(int x, int y)
+{
+ int nat_x, nat_y;
+
+ /* Normalization is best done in native coordinatees. */
+ map_to_native_pos(&nat_x, &nat_y, x, y);
+ return revdes_nat_pos(nat_x, nat_y);
+}
+
+REVERSE_DESCRIPTOR_TYPE revdes_nat_pos(int nat_x, int nat_y)
+{
+ int xfactor, yfactor;
+
+ /* If the position is out of range in a non-wrapping direction, it is
+ * unreal. */
+ if (!((!XWRAP_TYPE_IS(WT_NONE) || (nat_x >= 0 && nat_x < map.xsize)) &&
+ (!YWRAP_TYPE_IS(WT_NONE) || (nat_y >= 0 && nat_y < map.ysize))
+ )) {
+ return 0;
+ }
+ xfactor = XWRAP_TYPE_IS(WT_REVERSED) ? 2 : 1;
+ yfactor = YWRAP_TYPE_IS(WT_REVERSED) ? 2 : 1;
+ return ((MODULO(nat_x, xfactor * map.xsize) < map.xsize)
+ != (MODULO(nat_y, yfactor * map.ysize) < map.ysize)
+ );
+}
+/* ************************************************************
+ * retourn TRUE if a singularity is in a city radius
+ * ************************************************************/
+bool near_singularity(int map_x, int map_y)
+{
+ int count = 0;
+ square_dxy_iterate(map_x, map_y, 2, x_itr, y_itr, dx_itr, dy_itr) {
+ if (abs(dx_itr) + abs(dy_itr) == 4) {
+ continue;
+ }
+ count++;
+ } square_dxy_iterate_end;
+ if ( count < 21 ) {
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/**************************************************************************
If the position is real, it will be normalized and TRUE will be returned.
If the position is unreal, it will be left unchanged and FALSE will be
returned.
Note, we need to leave x and y with sane values even in the unreal case.
Some callers may for instance call nearest_real_pos on these values.
-**************************************************************************/
-bool normalize_map_pos(int *x, int *y)
+ *************************************************************************
+ * allow the 9 topology xwrap_type-ywrap_type with the WT_REVERSED,WT_SIMPLEST,
+ * WT_NONE and the 10th topology XRAP=WT_SIMPLEST , YWRAP=WT_OFFSET
+ * [mburda]
+ *************************************************************************/
+bool normalize_map_pos(int *px, int *py)
{
int nat_x, nat_y;
+ int xfactor, yfactor;
+ bool revdes;
/* Normalization is best done in native coordinatees. */
- map_to_native_pos(&nat_x, &nat_y, *x, *y);
+ map_to_native_pos(&nat_x, &nat_y, *px, *py);
/* If the position is out of range in a non-wrapping direction, it is
* unreal. */
- if (!((topo_has_flag(TF_WRAPX) || (nat_x >= 0 && nat_x < map.xsize))
- && (topo_has_flag(TF_WRAPY) || (nat_y >= 0 && nat_y < map.ysize)))) {
+ if (!((!XWRAP_TYPE_IS(WT_NONE) || (nat_x >= 0 && nat_x < map.xsize))
+ && (!YWRAP_TYPE_IS(WT_NONE)
+ || (nat_y >= 0 && nat_y < map.ysize))
+ )) {
return FALSE;
}
- /* Wrap in X and Y directions, as needed. */
- if (topo_has_flag(TF_WRAPX)) {
- nat_x = FC_WRAP(nat_x, map.xsize);
+ xfactor = XWRAP_TYPE_IS(WT_REVERSED) ? 2 : 1;
+ yfactor = YWRAP_TYPE_IS(WT_REVERSED) ? 2 : 1;
+ revdes = ((MODULO(nat_x, xfactor * map.xsize) < map.xsize)
+ != (MODULO(nat_y, yfactor * map.ysize) < map.ysize)
+ );
+/* Wrap in X and Y directions and rotate, as needed. */
+ if (!YWRAP_TYPE_IS(WT_OFFSET)) { /* not Movius strip */
+ if (revdes) {
+ nat_x = MODULO(-nat_x - 1, map.xsize);
+ nat_y = MODULO(-nat_y - 1, map.ysize);
+ } else {
+ nat_x = MODULO(nat_x, map.xsize);
+ nat_y = MODULO(nat_y, map.ysize);
+ }
+ } else if (!XWRAP_TYPE_IS(WT_SIMPLEST)) {
+ assert(FALSE); /* not a valid topologie */
+ } else { /* Mobius *//* not the best all the time */
+ while (nat_y < 0) {
+ nat_y += map.ysize;
+ nat_x += map.xsize / 2;
+ }
+ while (nat_y >= map.ysize) {
+ nat_y -= map.ysize;
+ nat_x -= map.xsize / 2;
+ }
+ nat_x = MODULO(nat_x, map.xsize);
}
- if (topo_has_flag(TF_WRAPY)) {
- nat_y = FC_WRAP(nat_y, map.ysize);
+
+ /* Now transform things back to map coordinates. */
+ native_to_map_pos(px, py, nat_x, nat_y);
+ return TRUE;
+}
+
+/**************************************************************************
+ * Some of normalize_map_pos and return a reverseddecriptor if the tiles is
+ * turned 180° in the original x,y map pos (mburda)
+ * if unreal *pdescriptor not well defined!
+ **************************************************************************
+ * allow the 9 topology xwrap_type-ywrap_type with the WT_REVERSED,WT_SIMPLEST,
+ * WT_NONE and the 10th topology XRAP=WT_SIMPLEST , YWRAP=WT_OFFSET
+ * [mburda]
+ *****************************************************************************/
+
+bool normalize_map_pos_revdes(int *px, int *py, bool * prevdes)
+{
+ int nat_x, nat_y;
+ int xfactor, yfactor;
+
+ /* Normalization is best done in native coordinatees. */
+ map_to_native_pos(&nat_x, &nat_y, *px, *py);
+
+ /* If the position is out of range in a non-wrapping direction, it is
+ * unreal. */
+ if (!((!XWRAP_TYPE_IS(WT_NONE) || (nat_x >= 0 && nat_x < map.xsize))
+ && (!YWRAP_TYPE_IS(WT_NONE)
+ || (nat_y >= 0 && nat_y < map.ysize))
+ )) {
+ return FALSE;
+ }
+
+ xfactor = XWRAP_TYPE_IS(WT_REVERSED) ? 2 : 1;
+ yfactor = YWRAP_TYPE_IS(WT_REVERSED) ? 2 : 1;
+ *prevdes = ((MODULO(nat_x, xfactor * map.xsize) < map.xsize)
+ != (MODULO(nat_y, yfactor * map.ysize) < map.ysize)
+ );
+
+/* Wrap in X and Y directions and rotate, as needed. */
+ if (!YWRAP_TYPE_IS(WT_OFFSET)) { /* not Movius strip */
+ if (*prevdes) {
+ nat_x = MODULO(-nat_x - 1, map.xsize);
+ nat_y = MODULO(-nat_y - 1, map.ysize);
+ } else {
+ nat_x = MODULO(nat_x, map.xsize);
+ nat_y = MODULO(nat_y, map.ysize);
+ }
+ } else if (!XWRAP_TYPE_IS(WT_SIMPLEST)) {
+ assert(FALSE); /* not a valid topologie */
+ } else { /* Mobius *//* not the best all the time */
+ while (nat_y < 0) {
+ nat_y += map.ysize;
+ nat_x += map.xsize / 2;
+ }
+ while (nat_y >= map.ysize) {
+ nat_y -= map.ysize;
+ nat_x -= map.xsize / 2;
+ }
+ nat_x = MODULO(nat_x, map.xsize);
}
/* Now transform things back to map coordinates. */
- native_to_map_pos(x, y, nat_x, nat_y);
+ native_to_map_pos(px, py, nat_x, nat_y);
+ return TRUE;
+}
+
+/*************************************************************************
+ * in nat coordinated
+ **************************************************************************/
+
+bool normalize_nat_pos_revdes(int *pnat_x, int *pnat_y, bool * prevdes)
+{
+ int xfactor, yfactor;
+
+ /* If the position is out of range in a non-wrapping direction, it is
+ * unreal. */
+ if (!((!XWRAP_TYPE_IS(WT_NONE) || (*pnat_x >= 0 && *pnat_x < map.xsize))
+ && (!YWRAP_TYPE_IS(WT_NONE)
+ || (*pnat_y >= 0 && *pnat_y < map.ysize))
+ )) {
+ return FALSE;
+ }
+
+ xfactor = XWRAP_TYPE_IS(WT_REVERSED) ? 2 : 1;
+ yfactor = YWRAP_TYPE_IS(WT_REVERSED) ? 2 : 1;
+ *prevdes = ((MODULO(*pnat_x, xfactor * map.xsize) < map.xsize)
+ != (MODULO(*pnat_y, yfactor * map.ysize) < map.ysize)
+ );
+
+ /* Wrap in X and Y directions and rotate, as needed. */
+ if (!YWRAP_TYPE_IS(WT_OFFSET)) { /* not Movius strip */
+ if (*prevdes) {
+ *pnat_x = MODULO(-*pnat_x - 1, map.xsize);
+ *pnat_y = MODULO(-*pnat_y - 1, map.ysize);
+ } else {
+ *pnat_x = MODULO(*pnat_x, map.xsize);
+ *pnat_y = MODULO(*pnat_y, map.ysize);
+ }
+ } else if (!XWRAP_TYPE_IS(WT_SIMPLEST)) {
+ assert(FALSE); /* not a valid topologie */
+ } else { /* Mobius *//* not the best all the time */
+ while (*pnat_y < 0) {
+ *pnat_y += map.ysize;
+ *pnat_x += map.xsize / 2;
+ }
+ while (*pnat_y >= map.ysize) {
+ *pnat_y -= map.ysize;
+ *pnat_x -= map.xsize / 2;
+ }
+ *pnat_x = MODULO(*pnat_x, map.xsize);
+ }
return TRUE;
}
/**************************************************************************
Twiddle *x and *y to point the the nearest real tile, and ensure that the
-position is normalized.
+position is normalized.
+**************************************************************************
+allow the 9 topology xwrap_type-ywrap_type with the WT_REVERSED,WT_SIMPLEST,
+WT_NONE and the 10th topology XRAP=WT_SIMPLEST , YWRAP=WT_OFFSET
+ [mburda]
**************************************************************************/
void nearest_real_pos(int *x, int *y)
{
- int nat_x, nat_y;
+ int nat_x, nat_y, xfactor, yfactor;
+ bool revdes;
- map_to_native_pos(&nat_x, &nat_y, *x, *y);
- if (!topo_has_flag(TF_WRAPX)) {
- nat_x = CLIP(0, nat_x, map.xsize - 1);
+ if (!XWRAP_TYPE_IS(WT_NONE) && !YWRAP_TYPE_IS(WT_NONE)) {
+ normalize_map_pos(x, y);
+ return;
}
- if (!topo_has_flag(TF_WRAPY)) {
- nat_y = CLIP(0, nat_y, map.ysize - 1);
+
+ assert(!XWRAP_TYPE_IS(WT_OFFSET) && !YWRAP_TYPE_IS(WT_OFFSET));
+
+ map_to_native_pos(&nat_x, &nat_y, *x, *y);
+
+ xfactor = XWRAP_TYPE_IS(WT_REVERSED) ? 2 : 1;
+ yfactor = YWRAP_TYPE_IS(WT_REVERSED) ? 2 : 1;
+ revdes = ((MODULO(nat_x, xfactor * map.xsize) < map.xsize)
+ != (MODULO(nat_y, yfactor * map.ysize) < map.ysize)
+ );
+ if (revdes) {
+ nat_x = XWRAP_TYPE_IS(WT_NONE)
+ ? CLIP(0, map.xsize - nat_x - 1, map.xsize - 1)
+ : MODULO(-nat_x - 1, map.xsize);
+
+ nat_y = YWRAP_TYPE_IS(WT_NONE)
+ ? CLIP(0, map.ysize - nat_y - 1, map.ysize - 1)
+ : MODULO(-nat_y - 1, map.ysize);
+
+ } else {
+ nat_x = XWRAP_TYPE_IS(WT_NONE)
+ ? CLIP(0, nat_x, map.xsize - 1)
+ : MODULO(nat_x, map.xsize);
+ nat_y = YWRAP_TYPE_IS(WT_NONE)
+ ? CLIP(0, nat_y, map.ysize - 1)
+ : MODULO(nat_y, map.ysize);
}
+
native_to_map_pos(x, y, nat_x, nat_y);
if (!normalize_map_pos(x, y)) {
@@ -1437,42 +1751,234 @@
(See also: real_map_distance, map_distance, and sq_map_distance.)
- With the standard topology the ranges of the return value are:
- -map.xsize/2 <= dx <= map.xsize/2
+ With all topology the ranges of the return value are:
+ -map.xsize < dx < map.xsize
-map.ysize < dy < map.ysize
+ **************************************************************************
+ allow the 9 topology xwrap_type-ywrap_type with the WT_REVERSED,WT_SIMPLEST,
+ WT_NONE and the 10th topology XRAP=WT_SIMPLEST , YWRAP=WT_OFFSET
+ [mburda]
****************************************************************************/
+
void map_distance_vector(int *dx, int *dy, int x0, int y0, int x1, int y1)
{
- if (topo_has_flag(TF_WRAPX) || topo_has_flag(TF_WRAPY)) {
- /* Wrapping is done in native coordinates. */
- map_to_native_pos(&x0, &y0, x0, y0);
- map_to_native_pos(&x1, &y1, x1, y1);
-
- /* Find the "native" distance vector. This corresponds closely to the
- * map distance vector but is easier to wrap. */
- *dx = x1 - x0;
- *dy = y1 - y0;
- if (topo_has_flag(TF_WRAPX)) {
- /* Wrap dx to be in [-map.xsize/2, map.xsize/2). */
- *dx = FC_WRAP(*dx + map.xsize / 2, map.xsize) - map.xsize / 2;
- }
- if (topo_has_flag(TF_WRAPY)) {
- /* Wrap dy to be in [-map.ysize/2, map.ysize/2). */
- *dy = FC_WRAP(*dy + map.ysize / 2, map.ysize) - map.ysize / 2;
- }
-
- /* Convert the native delta vector back to a pair of map positions. */
- x1 = x0 + *dx;
- y1 = y0 + *dy;
- native_to_map_pos(&x0, &y0, x0, y0);
- native_to_map_pos(&x1, &y1, x1, y1);
+ int Dist, _Dist, Dx, Dy, _dx, _dy;
+ /* Work is done in native coordinates. */
+ map_to_native_pos(&x0, &y0, x0, y0);
+ map_to_native_pos(&x1, &y1, x1, y1);
+ *dx = x1 - x0;
+ *dy = y1 - y0;
+ /* offset wrap */
+ if (YWRAP_TYPE_IS(WT_OFFSET)) {
+ while (*dy > map.ysize / 2) {
+ *dy -= map.ysize;
+ *dx -= map.xsize / 2;
+ }
+ while (*dy <= -map.ysize / 2) {
+ *dy += map.ysize;
+ *dx += map.xsize / 2;
+ }
}
+ assert(!XWRAP_TYPE_IS(WT_OFFSET));
+ /* simplest wraps */
+ if (XWRAP_TYPE_IS(WT_SIMPLEST)) {
+ while (*dx > map.xsize / 2)
+ *dx -= map.xsize;
+ while (*dx <= -map.xsize / 2)
+ *dx += map.xsize;
+ }
+ if (YWRAP_TYPE_IS(WT_SIMPLEST)) {
+ while (*dy > map.ysize / 2)
+ *dy -= map.ysize;
+ while (*dy <= -map.ysize / 2)
+ *dy += map.ysize;
+ }
+ Dist = MAX(abs(*dx), abs(*dy));
+ /* reversed toologies : */
+ if (XWRAP_TYPE_IS(WT_REVERSED) && YWRAP_TYPE_IS(WT_REVERSED)) {
+ /* Selection of best vector to a unmirrored destination */
+ _dx = *dx - map.xsize;
+ _dy = *dy - map.ysize;
+ while (_dx > map.xsize)
+ _dx -= 2 * map.xsize;
+ while (_dx <= -map.xsize)
+ _dx += 2 * map.xsize;
+ while (_dy > map.ysize)
+ _dy -= 2 * map.ysize;
+ while (_dy <= -map.ysize)
+ _dy += 2 * map.ysize;
+ _Dist = MAX(abs(_dx), abs(_dy));
+ /* best way a this point of code */
+ if (Dist > _Dist) {
+ *dx = _dx;
+ *dy = _dy;
+ Dist = _Dist;
+ }
+
+ /* Selection of best vector to a mirrored verticaly destination */
+ _dx = (map.xsize - 1 - x1) - x0;
+ _dy = (-1 - y1) - y0;
+ while (_dx > map.xsize)
+ _dx -= 2 * map.xsize;
+ while (_dx <= -map.xsize)
+ _dx += 2 * map.xsize;
+ while (_dy > map.ysize)
+ _dy -= 2 * map.ysize;
+ while (_dy <= -map.ysize)
+ _dy += 2 * map.ysize;
+ _Dist = MAX(abs(_dx), abs(_dy));
+ /* best way a this point of code */
+ if (Dist > _Dist) {
+ *dx = _dx;
+ *dy = _dy;
+ Dist = _Dist;
+ }
+
+ /* Selection of best vector to a mirrored horizontaly destination */
+ _dx = (-1 - x1) - x0;
+ _dy = (map.ysize - 1 - y1) - y0;
+ while (_dx > map.xsize)
+ _dx -= 2 * map.xsize;
+ while (_dx <= -map.xsize)
+ _dx += 2 * map.xsize;
+ while (_dy > map.ysize)
+ _dy -= 2 * map.ysize;
+ while (_dy <= -map.ysize)
+ _dy += 2 * map.ysize;
+ _Dist = MAX(abs(_dx), abs(_dy));
+
+ /* best way is...*/
+ if (Dist > _Dist) {
+ *dx = _dx;
+ *dy = _dy;
+ Dist = _Dist;
+ }
+ } else if (YWRAP_TYPE_IS(WT_REVERSED))
+ {
+ // central symetry
+ Dy = (-1 - y1) - y0;
+ Dx = (map.xsize - x1 - 1) - x0;
+
+ /* periodicity in y over 2 maps */
+ while (Dy > map.ysize)
+ Dy -= 2 * map.ysize;
+ while (Dy <= -map.ysize)
+ Dy += 2 * map.ysize;
+
+ _Dist = MAX(abs(Dx), abs(Dy));
+ // get the best way
+ if (_Dist < Dist) {
+ Dist = _Dist;
+ *dx = Dx;
+ *dy = Dy;
+ }
+ } else if( XWRAP_TYPE_IS(WT_REVERSED) )
+ {
+ // central symetry
+ Dx = (-1 - x1) - x0;
+ Dy = (map.ysize - y1 - 1) - y0;
+
+ /* periodicity in y over 2 maps */
+ while (Dx > map.xsize)
+ Dx -= 2 * map.xsize;
+ while (Dx <= -map.xsize)
+ Dx += 2 * map.xsize;
+
+ _Dist = MAX(abs(Dx), abs(Dy));
+ // get the best way
+ if (_Dist < Dist) {
+ Dist = _Dist;
+ *dx = Dx;
+ *dy = Dy;
+ }
+ }
+
+ /* Convert the native delta vector back to a pair of map positions. */
+ x1 = x0 + *dx;
+ y1 = y0 + *dy;
+ native_to_map_pos(&x0, &y0, x0, y0);
+ native_to_map_pos(&x1, &y1, x1, y1);
+
/* Find the final (map) vector. */
*dx = x1 - x0;
*dy = y1 - y0;
}
+/*************************************************************************
+Return begin in px, py, all the cordiantes of one tile,
+normalized and near non normalized ones
+the return value are the number of this (0 to 9)
+the first one is the normalized if exist
+ [mburda]
+*************************************************************************/
+int map_near_orbit(int x, int y, int *px, int *py)
+{
+ int n = 1, i;
+
+ if (!normalize_map_pos(&x, &y)) {
+ return 0;
+ }
+
+ map_to_native_pos(px, py, x, y);
+
+ if (XWRAP_TYPE_IS(WT_REVERSED)) {
+ // central symetry
+ *(px + n) = -1 - x;
+ *(py + n) = map.ysize - y - 1;
+ n++;
+ *(px + n) = 2 * map.xsize - 1 - x;
+ *(py + n) = map.ysize - y - 1;
+ n++;
+ } else if (XWRAP_TYPE_IS(WT_SIMPLEST)) {
+ int i, ni = n;
+ for (i = 0; i < ni; i++) {
+ *(py + n) = *(py + i);
+ *(px + n) = *(px + i) + map.xsize;
+ n++;
+ *(py + n) = *(py + i);
+ *(px + n) = *(px + i) - map.xsize;
+ n++;
+ }
+ }
+
+ if (YWRAP_TYPE_IS(WT_REVERSED)) {
+ int i, ni = n;
+ for (i = 0; i < ni; i++) {
+ *(py + n) = -1 - *(py + i);
+ *(px + n) = map.xsize - *(px + i) - 1;
+ n++;
+ *(py + n) = 2 * map.ysize - 1 - *(py + i);
+ *(px + n) = map.xsize - *(px + i) - 1;
+ n++;
+ }
+ } else if (YWRAP_TYPE_IS(WT_SIMPLEST)) {
+ int i, ni = n;
+ for (i = 0; i < ni; i++) {
+ *(py + n) = *(py + i) + map.ysize;
+ *(px + n) = *(px + i);
+ n++;
+ *(py + n) = *(py + i) - map.ysize;
+ *(px + n) = *(px + i);
+ n++;
+ }
+ } else if (YWRAP_TYPE_IS(WT_OFFSET)) {
+ int i, ni = n;
+ for (i = 0; i < ni; i++) {
+ *(py + n) = *(py + i) + map.ysize;
+ *(px + n) = *(px + i) + map.xsize / 2;
+ n++;
+ *(py + n) = *(py + i) - map.ysize;
+ *(px + n) = *(px + i) - map.xsize / 2;
+ n++;
+ }
+ }
+ for (i = 0; i < n; i++) {
+ native_to_map_pos(px, py, *px, *py);
+ }
+ return n;
+}
+
/**************************************************************************
Random neighbouring square.
**************************************************************************/
@@ -1667,10 +2173,11 @@
{
int diff_x, diff_y;
- assert(is_tiles_adjacent(start_x, start_y, end_x, end_y));
+ assert(is_tiles_adjacent(start_x, start_y, end_x, end_y) ||
+ (start_x == end_x && start_y == end_y));
map_distance_vector(&diff_x, &diff_y, start_x, start_y, end_x, end_y);
- return (diff_x == 0) || (diff_y == 0);
+ return (diff_x == 0) != (diff_y == 0);
}
/**************************************************************************
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/common/map.h freeciv/common/map.h
--- freeciv-cvs-Jan-04/common/map.h 2003-11-29 07:05:26.000000000 +0100
+++ freeciv/common/map.h 2004-01-06 18:31:00.000000000 +0100
@@ -135,9 +135,14 @@
char *helptext;
};
-struct civ_map {
- int topology_id;
- int xsize, ysize; /* native dimensions */
+
+struct civ_map {
+ int topology_id; /*index of topologies and some flags */
+ int xwrap_type;
+ int ywrap_type;
+ int size; /* size of map in log units for 0 to 14, -1 for manual sizes */
+ int ratio; /* xsize-ysize ratio form 11 to 99 or 100 for auto ratio */
+ int xsize, ysize; /* native dimensions, determined form size and ratio */
int seed;
int riches;
bool is_earth;
@@ -165,18 +170,82 @@
};
enum topo_flag {
- /* Bit-values. */
- TF_WRAPX = 1,
- TF_WRAPY = 2,
- TF_ISO = 4
+ /* Bit-values(deprecated). and topos index
+ * For Users
+ * cartographics topologies
+ */
+ TF_FLAT = 0, /* xwrap_type = 0 , ywrap_type = 0 */
+ TF_CLASSIC, /* xwrap_type = 1 , ywrap_type = 0 */
+ TF_QUINCUNCIAL_SQ, /* xwrap_type = 2 , ywrap_type = 2 */
+ /* scfi topologies */
+ TF_TORUS, /* xwrap_type = 1 , ywrap_type = 1 */
+ TF_MOBIUS, /* xwrap_type = 1 , ywrap_type = 3 */
+ TF_SPIN, /* xwrap_type = 2 , ywrap_type = 0 */
+ /*
+ * variants vor developpers
+ */
+ TF_QUINCUNCIAL, /* xwrap_type = 1 , ywrap_type = 2 */
+
+ /* index_mask */
+ TF_MASK=15,
+ /* Bit-value, non deprecated flag */
+ TF_ISO = 16,
+ /* Bit-values(deprecated) */
+ TF_WRAPX = 32,
+ TF_WRAPY = 64,
+};
+
+enum topo_wrap_type {
+ WT_NONE=0,
+ WT_SIMPLEST=1,
+ WT_REVERSED=2,
+ WT_OFFSET /* this simple wrap only good combine with SIMPLEST */
};
+/*
+
+ TF_WRAPX and TF_WRAPY are deprecated. i precerve its fontionality for
+ the simplest topologies
+ new code can use XWRAP_TYPE_IS() and YWRAP_TYPE_IS()
+
+ xwrap_type = WT_NONE : no wrap
+ xwrap_type = WT_SIMPLEST : simple wrap
+ xwrap_type = WT_REVERSED : wrap and reverse
+ xwrap_type = WT_OFFSET : wrap and size/2 offset
+ (mburda)
+*/
+
+
#define CURRENT_TOPOLOGY (map.topology_id)
-#define topo_has_flag(flag) ((CURRENT_TOPOLOGY & (flag)) != 0)
+/* when deprecated bit diapear we can simplify this */
+
+#define topo_has_flag(flag) ((((flag) & (TF_WRAPX | TF_WRAPY)) == 0) \
+ ? ((CURRENT_TOPOLOGY & (flag)) != 0) \
+ : ((flag) == TF_WRAPX \
+ ? XWRAP_TYPE_IS(WT_SIMPLEST) \
+ : YWRAP_TYPE_IS(WT_SIMPLEST)))
+
+
+#define XWRAP_TYPE_IS(WTYPE) (map.xwrap_type==(WTYPE))
+
+#define YWRAP_TYPE_IS(WTYPE) (map.ywrap_type==(WTYPE))
+
+/* Actuealy a bool is ok for determine revertion type, full reverse or not */
+
+#define REVERSE_DESCRIPTOR_TYPE bool
+#define REVERSE_NONE FALSE
+
+#define COMBINE_DESCRIPTOR(REVERSE1,REVERSE2) ((REVERSE1)!=(REVERSE2))
+
+#define NORMALIZE_DIR(DIR, REVERSE) \
+ ((REVERSE)?DIR_REVERSE(DIR):(DIR))
+
+bool near_singularity(int map_x, int map_y);
bool map_is_empty(void);
void map_init(void);
+void map_init_topology(int);
void map_allocate(void);
void map_free(void);
@@ -258,11 +327,26 @@
* MAPSTEP(x, y, x, y, dir)
* we bend this rule here.
*/
+
+
+
#define MAPSTEP(dest_x, dest_y, src_x, src_y, dir) \
( (dest_x) = (src_x) + DIR_DX[(dir)], \
(dest_y) = (src_y) + DIR_DY[(dir)], \
normalize_map_pos(&(dest_x), &(dest_y)))
+#define MAPSTEP_REVDES(dest_x, dest_y, src_x, src_y, dir, rev_des) \
+( (dest_x) = (src_x) + DIR_DX[(dir)], \
+ (dest_y) = (src_y) + DIR_DY[(dir)], \
+ normalize_map_pos_revdes(&(dest_x), &(dest_y),&(rev_des)))
+
+#define MAPSTEP_FULL(dest_x, dest_y, src_x, src_y, dir, ndir, rev_des) \
+( (dest_x) = (src_x) + DIR_DX[(dir)], \
+ (dest_y) = (src_y) + DIR_DY[(dir)], \
+ normalize_map_pos_revdes(&(dest_x), &(dest_y), &(rev_des))) \
+ (ndir) = NORMALIZE_DIR(dir, rev_des)
+
+
struct player *map_get_owner(int x, int y);
void map_set_owner(int x, int y, struct player *pplayer);
struct city *map_get_city(int x, int y);
@@ -298,14 +382,21 @@
|| (x) < (dist) || (x) >= map.xsize - (dist) \
|| (y) < (dist) || (y) >= map.ysize - (dist))
+int map_near_orbit(int x, int y, int *px, int *py);
+void refreshmapratio(void);
+void setmapratio(int ratio);
+void setmapratio2(int Xratio, int Yratio);
+REVERSE_DESCRIPTOR_TYPE revdes_map_pos(int x, int y);
+REVERSE_DESCRIPTOR_TYPE revdes_nat_pos(int x, int y);
+bool normalize_nat_pos_revdes(int *x, int *y, bool * prevdes);
bool normalize_map_pos(int *x, int *y);
+bool normalize_map_pos_revdes(int *x, int *y,
+ REVERSE_DESCRIPTOR_TYPE * descriptor);
void nearest_real_pos(int *x, int *y);
void map_distance_vector(int *dx, int *dy, int x0, int y0, int x1, int y1);
int map_num_tiles(void);
-
void rand_neighbour(int x0, int y0, int *x, int *y);
void rand_map_pos(int *x, int *y);
-
bool is_water_adjacent_to_tile(int x, int y);
bool is_tiles_adjacent(int x0, int y0, int x1, int y1);
bool is_move_cardinal(int start_x, int start_y, int end_x, int end_y);
@@ -379,54 +470,65 @@
As a special case positive is initialized as 0 (ie we start in step 2) ),
as the center tile would else be returned by both step 1) and 2).
*/
-#define iterate_outward(ARG_start_x, ARG_start_y, ARG_max_dist, ARG_x_itr,
ARG_y_itr) \
-{ \
- int ARG_x_itr, ARG_y_itr; \
- int MACRO_max_dx = map.xsize/2; \
- int MACRO_min_dx = -MACRO_max_dx - 1 + (map.xsize % 2); \
- bool MACRO_xcycle = TRUE; \
- bool MACRO_positive = FALSE; \
- bool MACRO_is_border = IS_BORDER_MAP_POS(ARG_start_x, ARG_start_y, \
- ARG_max_dist); \
- int MACRO_dxy = 0, MACRO_do_xy; \
- CHECK_MAP_POS(ARG_start_x, ARG_start_y); \
- while(MACRO_dxy <= (ARG_max_dist)) { \
- for (MACRO_do_xy = -MACRO_dxy; MACRO_do_xy <= MACRO_dxy; MACRO_do_xy++) { \
- if (MACRO_xcycle) { \
- ARG_x_itr = (ARG_start_x) + MACRO_do_xy; \
- if (MACRO_positive) \
- ARG_y_itr = (ARG_start_y) + MACRO_dxy; \
- else \
- ARG_y_itr = (ARG_start_y) - MACRO_dxy; \
- } else { /* ! MACRO_xcycle */ \
- if (MACRO_dxy == MACRO_do_xy || MACRO_dxy == -MACRO_do_xy) \
- continue; \
- ARG_y_itr = (ARG_start_y) + MACRO_do_xy; \
- if (MACRO_positive) \
- ARG_x_itr = (ARG_start_x) + MACRO_dxy; \
- else \
- ARG_x_itr = (ARG_start_x) - MACRO_dxy; \
- } \
- { \
- int MACRO_dx = (ARG_start_x) - ARG_x_itr; \
- if (MACRO_dx > MACRO_max_dx || MACRO_dx < MACRO_min_dx) \
- continue; \
- } \
- if (MACRO_is_border && !normalize_map_pos(&ARG_x_itr, &ARG_y_itr)) { \
- continue; \
- }
-
-#define iterate_outward_end \
- } \
- if (!MACRO_positive) { \
- if (!MACRO_xcycle) \
- MACRO_dxy++; \
- MACRO_xcycle = !MACRO_xcycle; \
- } \
- MACRO_positive = !MACRO_positive; \
- } \
+/* Only one time in reversed-wrapping (mburda) (TODO verify cycles !)*/
+#define iterate_outward(ARG_start_x, ARG_start_y, ARG_max_dist, \
+ ARG_x_itr, ARG_y_itr)\
+{ \
+ int ARG_x_itr, ARG_y_itr; \
+ int MACRO_max_dx = map.xsize/2; \
+ int MACRO_min_dx = -MACRO_max_dx - 1 + (map.xsize % 2); \
+ bool MACRO_xcycle = TRUE; \
+ bool MACRO_positive = FALSE; \
+ bool MACRO_is_border = IS_BORDER_MAP_POS(ARG_start_x, ARG_start_y, \
+ ARG_max_dist); \
+ bool MACRO_revdes_out=0; \
+ int MACRO_dxy = 0, MACRO_do_xy; \
+ CHECK_MAP_POS(ARG_start_x, ARG_start_y); \
+ while(MACRO_dxy <= (ARG_max_dist)) { \
+ for (MACRO_do_xy = -MACRO_dxy; MACRO_do_xy <= MACRO_dxy; MACRO_do_xy++) {\
+ if (MACRO_xcycle) { \
+ ARG_x_itr = (ARG_start_x) + MACRO_do_xy; \
+ if (MACRO_positive) \
+ ARG_y_itr = (ARG_start_y) + MACRO_dxy; \
+ else \
+ ARG_y_itr = (ARG_start_y) - MACRO_dxy; \
+ } else { /* ! MACRO_xcycle */ \
+ if (MACRO_dxy == MACRO_do_xy || MACRO_dxy == -MACRO_do_xy) \
+ continue; \
+ ARG_y_itr = (ARG_start_y) + MACRO_do_xy; \
+ if (MACRO_positive) \
+ ARG_x_itr = (ARG_start_x) + MACRO_dxy; \
+ else \
+ ARG_x_itr = (ARG_start_x) - MACRO_dxy; \
+ } \
+ { \
+ int MACRO_dx = (ARG_start_x) - ARG_x_itr; \
+ if (MACRO_dx > MACRO_max_dx || MACRO_dx < MACRO_min_dx) \
+ continue; \
+ } \
+ if (MACRO_is_border && !normalize_map_pos_revdes(&ARG_x_itr, \
+ &ARG_y_itr,&MACRO_revdes_out)) { \
+ continue; \
+ } \
+ ONETIME((ARG_start_x),(ARG_start_y),(ARG_x_itr),(ARG_y_itr), \
+ (ARG_max_dist),(MACRO_revdes_out))
+
+/* end iterate if more than one time in reversed topologies */
+#define ONETIME(XC,YC,X,Y,D,rev_des) \
+ if( (rev_des) && (MAX(abs((XC)-(X)),abs((YC)-(Y)))<=(D))) { \
+ continue; \
+ }
+
+#define iterate_outward_end \
+ } \
+ if (!MACRO_positive) { \
+ if (!MACRO_xcycle) \
+ MACRO_dxy++; \
+ MACRO_xcycle = !MACRO_xcycle; \
+ } \
+ MACRO_positive = !MACRO_positive; \
+ } \
}
-
#define rectangle_iterate(map_x0, map_y0, map_width, map_height, \
x_itr, y_itr) \
{ \
@@ -450,18 +552,26 @@
* position. Note that when the square is larger than the map the
* distance vector may not be the minimum distance vector.
*/
+/*
+ * only one time if reversed wrapping [mburda]
+ */
+
#define square_dxy_iterate(center_x, center_y, radius, x_itr, y_itr, \
dx_itr, dy_itr) \
{ \
int dx_itr, dy_itr; \
+ REVERSE_DESCRIPTOR_TYPE macro_revdes=REVERSE_NONE; \
bool _is_border = IS_BORDER_MAP_POS((center_x), (center_y), (radius)); \
CHECK_MAP_POS((center_x), (center_y)); \
for (dy_itr = -(radius); dy_itr <= (radius); dy_itr++) { \
for (dx_itr = -(radius); dx_itr <= (radius); dx_itr++) { \
int x_itr = dx_itr + (center_x), y_itr = dy_itr + (center_y); \
- if (_is_border && !normalize_map_pos(&x_itr, &y_itr)) { \
+ if (_is_border && \
+ !normalize_map_pos_revdes(&(x_itr), &(y_itr),¯o_revdes)) { \
continue; \
- }
+ } \
+ ONETIME((center_x), (center_y),(x_itr), (y_itr), (radius),macro_revdes)
+
#define square_dxy_iterate_end \
} \
@@ -473,12 +583,12 @@
* Positions returned will have adjusted x, and positions with illegal
* y will be automatically discarded.
*/
-#define square_iterate(center_x, center_y, radius, x_itr, y_itr) \
-{ \
- square_dxy_iterate(center_x, center_y, radius, x_itr, y_itr, \
- _dummy_x, _dummy_y);
+#define square_iterate(center_x, center_y, radius, x_itr, y_itr) \
+{ \
+ square_dxy_iterate(center_x, center_y, radius, x_itr, y_itr, \
+ _dummy_x, _dummy_y)
-#define square_iterate_end square_dxy_iterate_end \
+#define square_iterate_end square_dxy_iterate_end \
}
/*
@@ -486,50 +596,96 @@
* radius. Positions returned will have adjusted (x, y); unreal
* positions will be automatically discarded.
*/
-#define circle_iterate(center_x, center_y, sq_radius, x_itr, y_itr) \
-{ \
- int _cr_radius = (int)sqrt((double)(sq_radius)); \
- square_dxy_iterate(center_x, center_y, _cr_radius, \
- x_itr, y_itr, _dx, _dy) { \
+#define circle_iterate(center_x, center_y, sq_radius, x_itr, y_itr) \
+{ \
+ int _cr_radius = (int)sqrt((double)(sq_radius)); \
+ square_dxy_iterate(center_x, center_y, _cr_radius, \
+ x_itr, y_itr, _dx, _dy) { \
if (_dy * _dy + _dx * _dx <= (sq_radius)) {
-#define circle_iterate_end \
- } \
- } square_dxy_iterate_end; \
+#define circle_iterate_end \
+ } \
+ } square_dxy_iterate_end; \
}
/* Iterate through all tiles adjacent to a tile */
-#define adjc_iterate(RI_center_x, RI_center_y, RI_x_itr, RI_y_itr) \
-{ \
- square_iterate(RI_center_x, RI_center_y, 1, RI_x_itr, RI_y_itr) { \
- if (RI_x_itr == RI_center_x && RI_y_itr == RI_center_y) { \
- continue; \
+#define adjc_iterate(RI_center_x, RI_center_y, RI_x_itr, RI_y_itr) \
+{ \
+ square_iterate(RI_center_x, RI_center_y, 1, RI_x_itr, RI_y_itr) { \
+ if (RI_x_itr == RI_center_x && RI_y_itr == RI_center_y) { \
+ continue; \
}
-#define adjc_iterate_end \
- } square_iterate_end; \
+#define adjc_iterate_end \
+ } square_iterate_end; \
}
/* Iterate through all tiles adjacent to a tile. dir_itr is the
directional value (see DIR_D[XY]). This assumes that center_x and
center_y are normalized. --JDS */
-#define adjc_dir_iterate(center_x, center_y, x_itr, y_itr, dir_itr) \
-{ \
- int x_itr, y_itr, dir_itr; \
- bool MACRO_border = IS_BORDER_MAP_POS((center_x), (center_y), 1); \
- int MACRO_center_x = (center_x); \
- int MACRO_center_y = (center_y); \
- CHECK_MAP_POS(MACRO_center_x, MACRO_center_y); \
- for (dir_itr = 0; dir_itr < 8; dir_itr++) { \
- DIRSTEP(x_itr, y_itr, dir_itr); \
- x_itr += MACRO_center_x; \
- y_itr += MACRO_center_y; \
- if (MACRO_border && !normalize_map_pos(&x_itr, &y_itr)) { \
- continue; \
+
+#define adjc_dir_iterate(center_x, center_y, x_itr, y_itr, dir_itr) \
+{ \
+ int x_itr, y_itr, dir_itr; \
+ bool MACRO_border = IS_BORDER_MAP_POS((center_x), (center_y), 1); \
+ int MACRO_center_x = (center_x); \
+ int MACRO_center_y = (center_y); \
+ CHECK_MAP_POS(MACRO_center_x, MACRO_center_y); \
+ for (dir_itr = 0; dir_itr < 8; dir_itr++) { \
+ DIRSTEP(x_itr, y_itr, dir_itr); \
+ x_itr += MACRO_center_x; \
+ y_itr += MACRO_center_y; \
+ if (MACRO_border && !normalize_map_pos(&x_itr, &y_itr)) { \
+ continue; \
+ }
+
+#define adjc_dir_iterate_revdes(center_x, center_y, x_itr, y_itr, dir_itr, \
+ revdes ) \
+{ \
+ int x_itr, y_itr, dir_itr; \
+ REVERSE_DESCRIPTOR_TYPE revdes= REVERSE_NONE; \
+ bool MACRO_border = IS_BORDER_MAP_POS((center_x), (center_y), 1); \
+ int MACRO_center_x = (center_x); \
+ int MACRO_center_y = (center_y); \
+ CHECK_MAP_POS(MACRO_center_x, MACRO_center_y); \
+ for (dir_itr = 0; dir_itr < 8; dir_itr++) { \
+ DIRSTEP(x_itr, y_itr, dir_itr); \
+ x_itr += MACRO_center_x; \
+ y_itr += MACRO_center_y; \
+ if (MACRO_border && !normalize_map_pos_isreversed(&x_itr, &y_itr, \
+ &revdes)) { \
+ continue; \
}
-#define adjc_dir_iterate_end \
- } \
+#define adjc_dir_iterate_full(center_x, center_y, x_itr, y_itr, \
+ dir_itr,ndir_itr, revdes ) \
+{ \
+ int x_itr, y_itr, dir_itr,ndir_itr; \
+ REVERSE_DESCRIPTOR_TYPE revdes= REVERSE_NONE; \
+ bool MACRO_border = IS_BORDER_MAP_POS((center_x), (center_y), 1); \
+ int MACRO_center_x = (center_x); \
+ int MACRO_center_y = (center_y); \
+ CHECK_MAP_POS(MACRO_center_x, MACRO_center_y); \
+ for (dir_itr = 0; dir_itr < 8; dir_itr++) { \
+ DIRSTEP(x_itr, y_itr, dir_itr); \
+ x_itr += MACRO_center_x; \
+ y_itr += MACRO_center_y; \
+ if (MACRO_border && !normalize_map_pos_revdes(&x_itr, &y_itr, \
+ &revdes)) { \
+ continue; \
+ } \
+ ndir_itr = NORMALIZE_DIR(dir_itr, revdes);
+
+#define adjc_dir_iterate_end \
+ } \
+}
+
+#define adjc_dir_iterate_revdes_end \
+ } \
+}
+
+#define adjc_dir_iterate_full_end \
+ } \
}
/* Iterate over all positions on the globe. */
@@ -546,6 +702,22 @@
} \
}
+/* Iterate: normal pos, then near no normal images of the provaides pos */
+#define near_orbit_iterate(map_x, map_y, itr_x, itr_y) \
+{ int MACRO_NO_xvec[9], MACRO_NO_yvec[9], MACRO_NO_i=0, MACRO_NO_ni; \
+ int itr_x, itr_y; \
+ MACRO_NO_ni = \
+ map_near_orbit((map_x),(map_y), MACRO_NO_xvec, MACRO_NO_yvec);\
+ while( MACRO_NO_i < MACRO_NO_ni) { \
+ itr_x = MACRO_NO_xvec[MACRO_NO_i]; \
+ itr_y = MACRO_NO_yvec[MACRO_NO_i]; \
+ MACRO_NO_i++; \
+ {
+
+#define near_orbit_iterate_end \
+ } \
+ } \
+}
/*
used to compute neighboring tiles:
using
@@ -602,15 +774,18 @@
{ \
int IAC_i; \
int IAC_x, IAC_y; \
- bool _is_border = IS_BORDER_MAP_POS(x, y, 1); \
+ bool car_revdes=FALSE, _is_border = IS_BORDER_MAP_POS(x, y, 1); \
CHECK_MAP_POS(x, y); \
for (IAC_i = 0; IAC_i < 4; IAC_i++) { \
IAC_x = x + CAR_DIR_DX[IAC_i]; \
IAC_y = y + CAR_DIR_DY[IAC_i]; \
\
- if (_is_border && !normalize_map_pos(&IAC_x, &IAC_y)) { \
+ if (_is_border && \
+ !normalize_map_pos_revdes(&IAC_x, &IAC_y, &car_revdes)) { \
continue; \
- }
+ } \
+ ONETIME((x),( y), IAC_x, IAC_y,1 ,car_revdes);
+
#define cartesian_adjacent_iterate_end \
} \
@@ -623,18 +798,47 @@
#define MAP_MIN_HUTS 0
#define MAP_MAX_HUTS 500
-#define MAP_DEFAULT_WIDTH 80
-#define MAP_MIN_WIDTH 40
-#define MAP_MAX_WIDTH 200
+/* map_init_topology() modifiy it by the x-y ratios */
+#define MAP_DEFAULT_WIDTH 80
#define MAP_DEFAULT_HEIGHT 50
-#define MAP_MIN_HEIGHT 25
-#define MAP_MAX_HEIGHT 100
-#define MAP_ORIGINAL_TOPO TF_WRAPX
-#define MAP_DEFAULT_TOPO TF_WRAPX
+#define MAP_MIN_WIDTHandHEIGHT 20
+#define MAP_MAX_WIDTHandHEIGHT 200
+
+
+#define MAP_MIN_WIDTH MAP_MIN_WIDTHandHEIGHT
+#define MAP_MAX_WIDTH MAP_MAX_WIDTHandHEIGHT
+
+#define MAP_MIN_HEIGHT MAP_MIN_WIDTHandHEIGHT
+#define MAP_MAX_HEIGHT MAP_MAX_WIDTHandHEIGHT
+
+#define MAP_DEFAULT_SIZE 2
+#define MAP_MIN_SIZE 0
+#define MAP_MAX_SIZE 10
+
+#define MAP_DEFAULT_RATIO 100
+#define MAP_MIN_RATIO 11 /* the 1:1 ratio */
+#define MAP_MAX_RATIO 100 /* 100 for default ratio */
+
+/* get DEFAULT RATIO facto Xratio*Yratio as litle as posible
+ * this is best for litrles map sizes
+ * get DEFAULT RATIO < 2:1 or 1:2
+ */
+
+
+#define DEFAULTRATIO_CLASSIC 74 /* 85 is too big 8*5=40, 7*4=28 best*/
+#define DEFAULTRATIO_FLAT 11
+#define DEFAULTRATIO_TORUS 11
+#define DEFAULTRATIO_MOBIUS 21
+#define DEFAULTRATIO_SPIN 23
+#define DEFAULTRATIO_QUINCUNCIAL_SQ 11
+#define DEFAULTRATIO_QUINCUNCIAL 21
+
+#define MAP_ORIGINAL_TOPO TF_CLASSIC
+#define MAP_DEFAULT_TOPO TF_CLASSIC
#define MAP_MIN_TOPO 0
-#define MAP_MAX_TOPO 3
+#define MAP_MAX_TOPO 6
#define MAP_DEFAULT_SEED 0
#define MAP_MIN_SEED 0
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/common/shared.h
freeciv/common/shared.h
--- freeciv-cvs-Jan-04/common/shared.h 2003-11-29 07:05:27.000000000 +0100
+++ freeciv/common/shared.h 2004-01-06 18:31:00.000000000 +0100
@@ -99,6 +99,9 @@
#define DIVIDE(n, d) \
( (n) / (d) - (( (n) < 0 && (n) % (d) < 0 ) ? 1 : 0) )
+/* Good version of % operator : */
+#define MODULO(X,M) ( (X) % (M) + ( (X) % (M) >= 0 ? 0 : (M) ))
+
/* Deletes bit no in val,
moves all bits larger than no one down,
and inserts a zero at the top. */
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/data/isotrident/terrain1.spec
freeciv/data/isotrident/terrain1.spec
--- freeciv-cvs-Jan-04/data/isotrident/terrain1.spec 2002-05-02
07:46:59.000000000 +0200
+++ freeciv/data/isotrident/terrain1.spec 2004-01-06 18:31:00.000000000
+0100
@@ -135,6 +135,7 @@
0, 3, "t.coast_color"
0, 4, "user.attention"
+ 0, 1, "tx.lfog"
}
diff -ruN -Xdiff_ignore
freeciv-cvs-Jan-04/data/scenario/WorldQuincuncial_100xx2_mburda_v0.41.sav
freeciv/data/scenario/WorldQuincuncial_100xx2_mburda_v0.41.sav
--- freeciv-cvs-Jan-04/data/scenario/WorldQuincuncial_100xx2_mburda_v0.41.sav
1970-01-01 01:00:00.000000000 +0100
+++ freeciv/data/scenario/WorldQuincuncial_100xx2_mburda_v0.41.sav
2004-01-06 18:31:00.000000000 +0100
@@ -0,0 +1,559 @@
+[game]
+version=11300
+server_state=2
+metastring="BigWrldQuincuncial V0.41 mburda@xxxxxxxxx"
+metaserver="meta.freeciv.org"
+gold=0
+tech=0
+skill_level=0
+timeout=0
+timeoutint=0
+timeoutintinc=0
+timeoutinc=0
+timeoutincmult=1
+timeoutcounter=1
+end_year=3000
+year=-5000
+turn=0
+researchcost=8
+min_players=1
+max_players=32
+nplayers=0
+globalwarming=0
+warminglevel=8
+nuclearwinter=0
+coolinglevel=8
+notradesize=0
+fulltradesize=1
+unhappysize=4
+angrycitizen=0
+cityfactor=14
+citymindist=0
+civilwarsize=10
+contactturns=20
+rapturedelay=1
+diplcost=0
+freecost=0
+conquercost=0
+foodbox=10
+techpenalty=80
+razechance=20
+civstyle=2
+save_nturns=20
+save_name="civgame_WQ41"
+aifill=10
+scorelog=0
+fogofwar=1
+spacerace=1
+auto_ai_toggle=1
+diplchance=80
+aqueductloss=0
+killcitizen=1
+turnblock=0
+savepalace=1
+fixedlength=0
+barbarians=3
+onsetbarbs=-3500
+occupychance=0
+demography="NASRLPEMOqrb"
+borders=7
+diplomacy=0
+watchtower_vision=2
+watchtower_extra_vision=0
+settlers=3
+explorer=2
+dispersion=3
+randseed=0
+save_random=0
+rulesetdir="default"
+save_starts=1
+save_known=0
+save_players=0
+
+[savefile]
+options="startoptions spacerace2 rulesets diplchance_percent worklists2
map_editor known32fix turn attributes watchtower rulesetdir client_worklists
startpos specials"
+
+[map]
+topology_id=2
+width=100
+height=100
+seed=0
+landpercent=60
+riches=0
+swampsize=2
+deserts=10
+riverlength=0
+mountains=10
+forestsize=0
+huts=100
+generator=0
+spesials=200
+have_huts=1
+is_earth=1
+fixed_start_positions=1
+r0sx=86
+r0sy=88
+r1sx=87
+r1sy=78
+r2sx=79
+r2sy=85
+r3sx=83
+r3sy=69
+r4sx=77
+r4sy=70
+r5sx=71
+r5sy=77
+r6sx=63
+r6sy=82
+r7sx=60
+r7sy=86
+r8sx=54
+r8sy=78
+r9sx=62
+r9sy=71
+r10sx=70
+r10sy=68
+r11sx=64
+r11sy=64
+r12sx=56
+r12sy=66
+r13sx=55
+r13sy=62
+r14sx=50
+r14sy=61
+r15sx=62
+r15sy=53
+r16sx=71
+r16sy=60
+r17sx=75
+r17sy=53
+r18sx=72
+r18sy=47
+r19sx=71
+r19sy=39
+r20sx=64
+r20sy=34
+r21sx=59
+r21sy=39
+r22sx=75
+r22sy=13
+r23sx=71
+r23sy=8
+r24sx=76
+r24sy=3
+r25sx=85
+r25sy=13
+r26sx=68
+r26sy=10
+r27sx=48
+r27sy=60
+r28sx=36
+r28sy=65
+r29sx=32
+r29sy=59
+r30sx=28
+r30sy=63
+r31sx=24
+r31sy=53
+r32sx=30
+r32sy=73
+t000="aaaa h
aaaaa"
+t001="aaaa f f
ppg aaaaa"
+t002="aaaa fh f
fmmmmp aaaaa"
+t003="aaa f fh
pgppppfff aaaa"
+t004="aaa h h j
jpppppfff ff aaaaa"
+t005=" jh g jj
fjpdppppff f aaaa"
+t006=" jg g
fpjjpddpphpf aaa "
+t007=" hj f hj
fpjjpddddphp aa "
+t008=" jh jmh
pjjppdddddph a "
+t009=" gmm
gfjpgpddddppp "
+t010=" gjhmg
ffdppmppp "
+t011=" jjhhj
fpmmpmdpp "
+t012=" h f jhmg
jffpddddddpp "
+t013=" ff fh hmm
gpppdddddddpp "
+t014=" f g
jggpdddddddppg "
+t015=" j
jgjfpdddddddpfg "
+t016=" jg
jfgfpdddddp "
+t017=" j
fg pdddpp "
+t018=" g
ppp "
+t019=" ff g
h "
+t020=" hh
ph "
+t021=" f
ph "
+t022=" p pp
fh "
+t023="
h "
+t024=" fh
fh "
+t025=" f
fffff ff "
+t026="
hhhfh h "
+t027=" hh
hffff h "
+t028=" ff f
fff f "
+t029=" f f
f fh "
+t030=" h
fh "
+t031="
fh "
+t032=" f h j
h fh "
+t033=" f fgh gffjjj
hjj h fh "
+t034=" ff fhmm fgffhhj
jjj jh f "
+t035=" h g
gfgffjhjjhjjjj "
+t036=" fm hh
gfffffhhjhjj "
+t037=" m f hh
gffgfghjjjjjj "
+t038=" m ghhp
ghffffgfhjjjj "
+t039=" a
mmffhggmpphhfggfffpppj "
+t040=" aa
mmfhhpppdddhhmmmggjjj "
+t041=" a
tffhhppddddmmfmmpgggg "
+t042=" aaaaaa
ttffghppdddmfpfmgfjffjg fff "
+t043=" t aaa a aaa
tffmghppddmfpfmmffhjjfjjf ff "
+t044=" fmt aa
aattfmfhhmpddmmfpmffhhfffjjfj "
+t045=" fmmmaa a aa
aaattffffhhmpddmffmpfhhffjfhffj "
+t046=" fmfta a a
attfggffhhhpdmmpmpphpjjhhhjf "
+t047=" mmftaaa a aaa
aattffffffhhfddmmmpddppjjff "
+t048=" fmftta a a
aaaattffffgffgfpdmmpppddpp f f f "
+t049=" g ff fffmmttaa aa a
aattffgffffffppmmfpppddpj "
+t050=" phgpfffffffmftaaaa aa a a
atmmmmmmffggpphhfppppg "
+t051=" pphmmmmmmmmmmmttaa a aa aaatffmmgmmg
ghhhhhfpp "
+t052=" phmmmmmhhhhtmtaaaaa a a
aaaatffgfgfgfgddhppphhh "
+t053=" pghmmmhhhfghghttaaaa a a a a atffgggggf
gghpdpppp "
+t054=" ghmmmmmhhffffffhtttaaaa aaaatffgfgfgf
hppdddp "
+t055=" p mmmmhhgpgpfgfgtttta a aa aa tfffggggg
hpdppp "
+t056=" gmmmhhgpppgphhft aaaaaaaaaaaaa ffffffgffgfgm
hpppp "
+t057=" gdmmgggpgpgpgfht aaa maah hff
ffgggggmmghhmmmp pd "
+t058=" dhmmdghgpgffpppht aa mmmht mf ffgfg gmmmm
pdd "
+t059=" gdmmdpdgfpfpppp t ta hmht hmf ffg mmmmm
pdd "
+t060=" dhmdpppfppppppgf f th t thp h mhff ffg
gggggg ppppdd "
+t061=" hmmp fppppgf fg hhm ttp p mf g ffhg
ggggdddddddddd "
+t062=" hmdp pppppgfgf gtthmm p g ffmmh
gggggdddddddddh gd "
+t063=" jhj ppppffhg fg fght ffffggh gg
dddddhdhdh dgd "
+t064=" hjj jjghhhpfgfg g pf fffmmgggg g
pppppppdd ggd "
+t065=" h jjpgpg gfgf ff h h ghhmhhhhgh g
gg ggdg "
+t066=" hjfff jj g g gshgmgh g
gddd g gggd "
+t067=" jhj fgfg ghgg
ppdddddhgggdggg "
+t068=" hhjf pj mm h g
gppppdddhhgfgddd "
+t069=" jhjf ff ghpp h
gpdddppddhmhgdgfg "
+t070=" hf h gdg
pddddpppghmhfgdf "
+t071=" hj g m h pp
pdddddddpgghmggfg "
+t072=" hjm pjf
pppppppdpdddddddggfgghgdg "
+t073=" mggg p
fffpddddddddddddddddgfgg hgf j "
+t074=" mjjjj h
ffpppdddddddddddddddpgfgj gfg gh "
+t075=" jhhmmjjjjj p
fppdddddddddddddddppgfgjj hggj fj "
+t076=" jhmmffjjjjs
ffpdddddddddddddddppfgjjjjgghhgjj gfh "
+t077=" hmmffjjjjjjjj
ffpddddddddddddddpppfgjjjjjjgfghhjj fghj "
+t078=" jmmfjjjjhhmjjj
ppdddddddddddddphppfgjjjjjjjfgghhgjj fhj "
+t079=" hmhfjjjjjjhjjj
pdddddddddddddphhggfjfjjjjjgggffghjj fhj "
+t080=" jmmhfjjjjjjjhjj
ddddddddddppppghggfgjjjjjjjgfpppfghj gjj "
+t081=" hmmmfjjj sjjjjjj
dddddddddpppggfgffggjjjjjggppddgfgfj j "
+t082=" hm mffjjj jjjhjjj pddddddpppggfgfg
gfjjjggpdddddgggfgj "
+t083=" hm mfjjjjs sjjhjj pddddppppgggg
jjjjgpddddddddhfgf "
+t084=" mmmfjffjjj jjjjj pddpppppgggfj
gddddddddhgmhg "
+t085=" dmffffffjjj jjs pppppppggjgj
ddhddddddhmhf "
+t086=" ddmmffffhfjjjjs pppppgfj
ddddddhdhhhg "
+t087=" dmmmmgffffffjjjjjsj p ppgg
dddhdddpppf "
+t088=" fmmmmggffgghfffjjjjjj
ddppppppg "
+t089=" hmmmpgggggggffffjjjjjjj
gpfg "
+t090=" ffmpppggggggfghfffjjhjjj
gf "
+t091=" tmmfdppgggggggghhffhjhjjjj
"
+t092=" mmmmfpdpgggggggfgfggffhjhjjj
"
+t093=" mfffpppgggg ffhhffgfhhjjhjjj
"
+t094=" mtttp phgg gfhhghghhhgjjjjhj
"
+t095=" m t ggf ggghhhghgjjjhhj
"
+t096=" gt gg ggggggggjh
"
+t097=" gg gg
"
+t098=" t
a"
+t099="aaatt ht
a"
+l000="0000000000000000000000000000000000000000000000000000000001000000000000000010000000000000000010000000"
+l001="0000000001101100100000000000000000000000000000000000000000000000001001000000000000011000000000000000"
+l002="0000000010000000000000000000000000000000000000000000000000010000000000001000000010000000000000000000"
+l003="0000000000000010000000000000000000000000000000000000000000000000010000000000010000000000000000000000"
+l004="0000000000000000000000000000000000000000000000000000000000101010100000100001000000100100000001000000"
+l005="0000000001000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000"
+l006="0000000000000100100000000000000000000000000000000000000000000100000010000000000000000000000000000000"
+l007="0000000000000100000000000000000000000000000000000000000000010010000101001000000000000001000000000000"
+l008="0000000000001000000000000000000000000000000000000000000000000000000000000000000000000100000000000000"
+l009="0000001010000010110000000000000000000000000000000000000000000001000000010100000000100000000000000000"
+l010="0000000000000000000000000000000000000000000000000000000000000101010000000000000000000010000000001000"
+l011="0000010000000001000000000000000000000000000000000000000000000000000001000000000000000000000000000000"
+l012="0000000000000000000000000000000000000000000000000000000000000000000100010000000000000000000000000000"
+l013="0000001011011000000000000000000000000000000000000000000000000001000000000010000000000001010000000000"
+l014="0000000000000010100000000000000000000000000000000000000000000000000001000000000000000110000000000000"
+l015="0000000000000000000000000000000000000000000000000000000000000000010000000001000000000000000000000000"
+l016="0000000010010001000000000000000000000000000000000000000000000000100010010000000000000000000000000000"
+l017="0000000000000000000000000000000000000000000000000000000000000000000000000000001000000000001000000000"
+l018="0000000000000100100000000000000000000000000000000000000000000000000000000000000000100000000000000000"
+l019="0000000000010000000000000000000000000000000000000000000000000000010010000000000000010001000000000000"
+l020="0000000000000101000000000000000000000000000000000000000000000000000000000000001000000000000000000000"
+l021="0000000000000000010000000000000000000000000000000000000000000000000000000000010000001000000000000000"
+l022="0000000000000100000000000000000000000000000000000000000000000000011000100000100000000000000000000000"
+l023="0000000000000001000000000000000000000000000000000000000000000000000001001001000010100000000000000000"
+l024="0000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000"
+l025="0000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000"
+l026="0000000000000000001000000000000000000000000000000000000000000000000000000000001001000000000000000000"
+l027="0000000000000000000000000000000000000000000000000000000000000000000000100001000010010000000000000000"
+l028="0000000000000100100000000000000000000000000000000000000000000001000010000000000000000000000000000000"
+l029="0000000000000000001010000010000000000000000000000000000000010000001000000000000001000000000000000000"
+l030="0000000000000001000000000000000000000000000000000000000010000010000101000100000000010000000000000000"
+l031="0000000000000000000100000100000000000000000000000000100001010000000000000000001100000000000000000000"
+l032="0000000000000000010000000000000000000000000000000000010100100000000000000000000000000000000000000000"
+l033="0000000000000000000000001000100000000000000000000001000000000100000000100000000000010000000000000000"
+l034="0000000000000000000001000000000000000000000000000000000010000010000010000000000000000000000000000000"
+l035="0000000000000000000000001010000000000000000000000101000000000000000000000000000010000000000000000000"
+l036="0000000000000000000000010000010000000000000000000000010100010000000000000100010001000000000000000000"
+l037="0000000000000000000000000001000000000000000000000000000000000000001000000000000100000000000000000000"
+l038="0000000000000000000000000000000000000000000000000000000010100000000000000000001000000000000000000000"
+l039="0000000000000000000000000000000000000000000000000000000000000000000000000000000001001000000000000000"
+l040="0000000000000000000000000000000000000010010000000000000010000000000100000000100100000000000000000000"
+l041="0000000000000000000000000000000000000000000000000000000000000000001001000000000000001001000000000000"
+l042="0000000000000000000000000000000000000100000000000000000010000000000000000000000001000000000000000000"
+l043="0000000000000000000000000000000000000001000100000000000000010000000000000000100000000001000000000000"
+l044="0000000000000000000000000000000000000000000000000000000000000000000001000100001000000000000000000000"
+l045="0000000000000000000000000000000000000100010000000000000000000100001000000000000010000000100000000000"
+l046="0000000000000000000000000000100010100000000000000000000000000000000000000000000000000000000100000000"
+l047="0000000000000000000000000000000000000000000000000000000001000010000000100000000000000001001000000000"
+l048="0000000000000000000000000100100010101000100000000000000000000000000000000000000001000000000000000000"
+l049="0000000000000000000000000000000000001000000000000000000000000000000000000000100000001000000000000000"
+l050="0000000000000000000000100000000000000000000000000000000000000000000000000000000101010000010010000000"
+l051="0000000000000000000000001001000000100000000000000000000001000000000100010000000000000101001000000000"
+l052="0000000000000000000010000000000000000000000000000000000000001000000000000010000100000000000000000000"
+l053="0000000000000000000001000000000000000000000000000000000000000000000000000000100000000000000000000000"
+l054="0000000000000000000100000100000000000000000000000000000001000000000000000000001000000000000000000000"
+l055="0000000000000000000000000000001000000001000000000000000000000000000100000000000000000000000000000000"
+l056="0000000000000000001001000100000100000000000000000010000000001000000000000010000001000000000000000000"
+l057="0000000000000000000000000000000001000100100010000101000100000000000000001001000000000000000000000000"
+l058="0000000000000000000100000000000011000000001101000000100010000000000000000000000000000000000000000000"
+l059="0000000000000000010000000000000000000101000000000001000010000000010000101000100000010000000000000000"
+l060="0000000000000000000000100000000000000000000001000000010000000000100000000000000010000000000000000000"
+l061="0000000000000000000100000000000100000000000000000000000000010000000100000000000000001000000000000000"
+l062="0000000000000000010000000000001000000001000011000100000000000000000000000000000000000010000000000000"
+l063="0000000000000000000000000000000000000000000000001000100000000000000000000000000000000000000000000000"
+l064="0000000000000000000010001001000000000000000000000000001000000000000000000000000000000010000000000000"
+l065="0000000000000000001001000000001000000000000101010101000000000000000010010001000010010000000000000000"
+l066="0000000000000000000000000000000000001000000100000000000000000000000000000000000000000000100000000000"
+l067="0000000000000000001000010000000010000001000101000001100000000000010000000000000010000001000000000000"
+l068="0000000000000000000010100000000000100100000000000000000000000000000100000000000000000000000000000000"
+l069="0000000000000000001000000100110100000000010100000001010000000100000000000000000000000000000000000000"
+l070="0000000000000000000010100000000000000000000000000000000000000000000010001010000000000000100000000000"
+l071="0000000000000000000000100000010100000000000000000000100000000000000010000010000100010000000011001000"
+l072="0000000000000000001000000100000001000000000000000000000000000000000000010000001000000000000000000000"
+l073="0000000000000000100010100000010010000000000000000000010000000000000000000000000000000000011000001000"
+l074="0000000000000010000000001000100000000000000000000000000100000010000000001000000001100000000100101100"
+l075="0000000000000000100010000000000010000000000000000000100000001000000001000000000100000000100001000000"
+l076="0000000000000000010000000000000001100000000000000000000000000101000000000100000000001000000010010000"
+l077="0000000000000100000000001000000000000000000000000000000000100000000000000000010000000010000000000010"
+l078="0000000000000001000000000000000010000000000000000001000000000000000000000000000000000000000000000000"
+l079="0000000000000100000001000000100000000000000000000000000000001000000000000000000000000000000000100100"
+l080="0000000000000000010001000000000010000000000000000000000010000000001000010000100000000010000100000010"
+l081="0000000000001000000000010000000000000000000000000001000000000000000000000001100000100000000000001000"
+l082="0000000000000000010011000000000010000000000000000000000000000000001000000000000000000000100001010000"
+l083="0000000000001010000000000100100000100000000000000000110000000000000000000000000000000000000000000100"
+l084="0000000000010000000000010000000000000000000000000000000000000100000000100000000000000001000000010000"
+l085="0000000000000000000000000001000000000000000000000000000000000100000000001000100000000000000001000000"
+l086="0000000001000100010000000000001010100000000000000000100000100000001000100001000000000100000010000000"
+l087="0000000100000001000000000000000000000000000000000000001100000000000000000001000000000001000000000000"
+l088="0000000000000000000001000100000000000000000000000000001000100001000010000000010000000000100001000000"
+l089="0000000010001100000000000000000000010000000000000000000001000000000000000000000000000000000100000000"
+l090="0000000110000000100010000000011000000000000000000000000000010000001000000000000010100000000010000000"
+l091="0000000000000000010000000000000000100000000000000000000000000001000000000000000000010000100000000000"
+l092="0000010001000000000000000010000000001000000000000000000000000000000000000000000000000100001000000000"
+l093="0000000000010100000000000001001000000000000000000000000000000000000000000000000000000000100000000000"
+l094="0000000001000000000000001000001000000000000000000000000000000000000000000000000000000000000000000000"
+l095="0000100001000000000000000000010000000100000000000000000000000000000000000000000000000000000000000000"
+l096="0000000011011000010100000000000000010000000000000000000000000000000000000000000000000000000000000000"
+l097="0000100000001000000000000010000000001000000000000000000000000000000000000000000000000000000000000000"
+l098="0000000010100010010000000000000010000000000000000000000000000000000000000000000000000000000000000000"
+l099="0000001010010000000000001000100000100000000000000000000000000000000000000000000000000000000000000000"
+u000="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u001="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u002="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u003="0000000000000000000000000000000000000000000000000000000000000000000000000004000000040000000000000000"
+u004="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u005="0000000000000000000000000000000000000000000000000000000000000000000000000004000000000400000000000000"
+u006="0000000000000000000000000000000000000000000000000000000000000000000400004000000000000000000000000000"
+u007="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u008="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u009="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u010="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u011="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u012="0000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000"
+u013="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u014="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u015="0000000000000000000000000000000000000000000000000000000000000000000000000040000000000004000000000000"
+u016="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u017="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u018="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u019="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u020="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u021="0000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000"
+u022="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u023="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u024="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u025="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u026="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u027="0000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000"
+u028="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u029="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u030="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u031="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u032="0000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000"
+u033="0000000000000000000000000000000000000000000000000000000000000000400000000040000000000000000000000000"
+u034="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u035="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u036="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u037="0000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000"
+u038="0000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000"
+u039="0000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000"
+u040="0000000000000000000000000000000000000000000000000000000400000400000000000000000000000000000000000000"
+u041="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u042="0000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000"
+u043="0000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000"
+u044="0000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000"
+u045="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u046="0000000000000000000000000000000000000000400000000000000000040000040000400000000000000000000000000000"
+u047="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u048="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u049="0000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000"
+u050="0000000000000000000000000000000400000040000000000000000000000000000000000000000000000000000000000000"
+u051="0000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000"
+u052="0000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000"
+u053="0000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000"
+u054="0000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000"
+u055="0000000000000000000000000000400000040000000000000000000000000000000000000000000000000000000000000000"
+u056="0000000000000000000000040000000000000000000000000000000000000000000000000040000000000000000000000000"
+u057="0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000"
+u058="0000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000"
+u059="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u060="0000000000000000000000000000000000000000000000000000000400000000000000004000000000000000000000000000"
+u061="0000000000000000000000000000000000000400000000000040000000000000000000000000000000000000000000000000"
+u062="0000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000"
+u063="0000000000000000000000000000000400000000040000000000000000000040000000000000000000000000000000000000"
+u064="0000000000000000000000000000000000000000000000000000000000400000000000040000000000000000000000000000"
+u065="0000000000000000000000000000000000000000000000000000400000000000040000000000000000000000000000000000"
+u066="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u067="0000000000000000000000000000000000000000000000000000000400000040000000040000000000000000000000000000"
+u068="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u069="0000000000000000000000000000000000000000000000000000000000000000000000000000400000000400000000000000"
+u070="0000000000000000000000400000000000000000000000000000004000000000000000000000000000000000000000000000"
+u071="0000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000"
+u072="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u073="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u074="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u075="0000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u076="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u077="0000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000"
+u078="0000000000000000000000000000000000000000000000000000000400000000000000000000000400000000000000000000"
+u079="0000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u080="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040004000000"
+u081="0000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000"
+u082="0000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000"
+u083="0000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000"
+u084="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u085="0000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000"
+u086="0000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000"
+u087="0000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000"
+u088="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u089="0000000000000004000000000000000000000000000000000000000000000000000000000000000000000040000000000000"
+u090="0000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u091="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u092="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u093="0000000000400004000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u094="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u095="0000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u096="0000004000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000"
+u097="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u098="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+u099="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n000="0000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n001="0000000000000000000000000000000000000000000000000000000000000000000000000000000010100000000000000000"
+n002="0000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n003="0000000000000000000000000000000000000000000000000000000000000000000000000002220202000000000000000000"
+n004="0000000000000000000000000000000000000000000000000000000000000000000000000000021222000001000000000000"
+n005="0000000000000000000000000000000000000000000000000000000000000000000000000000022112200000000000000000"
+n006="0000000000000010000000000000000000000000000000000000000000000000000000002000002220200000000000000000"
+n007="0000000000000010000000000000000000000000000000000000000000000000000000002222000020200000000000000000"
+n008="0000000000010000000000000000000000000000000000000000000000000000000000000010000000000000000000000000"
+n009="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n010="0000000000010000000000000000000000000000000000000000000000000000000000000000001000100000000000000000"
+n011="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n012="0001100010000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000"
+n013="0000000000000000000000000000000000000000000000000000000000000000000000000000100000001000000000000000"
+n014="0000000000001000000000000000000000000000000000000000000000000000000000000000000000000000100000000000"
+n015="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n016="0000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n017="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n018="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n019="0000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n020="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n021="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n022="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n023="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n024="0000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n025="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n026="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n027="0000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000"
+n028="0000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000"
+n029="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n030="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n031="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n032="0000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n033="0000000000000000000000000000000000000000000000000000000000000002200000000220000000000000000000000000"
+n034="0000000000000000000000000100000000000000000000000000000000000000220000000200000000000000000000000000"
+n035="0000000000000000000000000000000000000000000000000000000000000000022200020200000000000000000000000000"
+n036="0000000000000000000000000000000000000000000000000000000000000000000230020000000000000000000000000000"
+n037="0000000000000000000000000000000000000000000000000001000000000000220022002232200000000000000000000000"
+n038="0000000000000000000000000000000000000000000000000000000000200000022202000000000000000000000000000000"
+n039="0000000000000000000000000000000000000000000000000000010000222000020200222200000000000000000000000000"
+n040="0000000000000000000000000000000000000000000000000000000000002200022002200220000000000000000000000000"
+n041="0000000000000000000000000000000000000000000000000000000222101001000000001220000000000000000000000000"
+n042="0000000000000000000000000000000000000000000000000000000000000000000000000200000000100000000000000000"
+n043="0000000000000000000000000000000000000000000000000000000010000220000000000200002000000000000000000000"
+n044="0000000000000000000000000000000000000000000000000000000000002200000000000220002022000000000000000000"
+n045="0000000000000000000000000000000000000000000000000000000001002000000000000200202020000000000000000000"
+n046="0000000000000000000000000000000000000000000000000000000022222000220000000000220000000000000000000000"
+n047="0000000000000000000000000000000000000000000100000000000000000002200110202001020000000000000000000000"
+n048="0000000000000000000000000000000000000000000000000000000022221222000000222000020000000001000000000000"
+n049="0000000000000000000000000000000000000000000000000000000001022201000000002200000000000000000000000000"
+n050="0000000000000000000000000000000000000000010000000000000000000000000000001222000000000000000000000000"
+n051="0000000000000000000000000000000000000000010000000000000000000120000000000002200000000000000000000000"
+n052="0000000000000000000000000000000100000000000000000000000000000020000010000000000000000000000000000000"
+n053="0000000000000000000000000000000000000000000000000000000001012232200000000000000000000000000000000000"
+n054="0000000000000000000000000000000000000000000000000000000000022000220000001000000000000000000000000000"
+n055="0000000000000000000000000001000000000000010000000000000000020022000000000000000000000000000000000000"
+n056="0000000000000000000000000000002000000000000000000000000000000002000000000000000000000000000000000000"
+n057="0000000000000000000000000002202000000000000000000000000001000002200001000000000000000000000000000000"
+n058="0000000000000000000000000000202000100000000000000000000000000220000000000000000000000000000000000000"
+n059="0000000000000000000000010000202022000000000100000000010000001020000020000000001000000000000000000000"
+n060="0000000000000000000000000000202230000000000000000001000000000000000022222000000000000000000000000000"
+n061="0000000000000000000000000000322000000000000001000000000000000000000020000000100000000000000000000000"
+n062="0000000000000000000000000000200000000000000000001000001000022000000000000000000000000000000000000000"
+n063="0000000000000000000000000000200000000000000000010000000000012000000000011000000000010000000000000000"
+n064="0000000000000000000000000000000000000000000010000000000000000222200000000000000000000000000000000000"
+n065="0000000000000000000000000000000000000000000000000000002000200000000000000000000000000000000000000000"
+n066="0000000000000000000000000000100000100000000000000000000220202000000000000000000000010000000000000000"
+n067="0000000000000000000000000000000000000010001000000000000000200000000000022100000000000000000000000000"
+n068="0000000000000000000000000000000000000000000000000000000000000000000000233230000000220000000000000000"
+n069="0000000000000000000000000000000000000000000000000000000022000000000000000022200010222200000000000000"
+n070="0000000000000000000000000000100000000000000000000000002200000000000000000000320000000000000000000000"
+n071="0000000000000000000000000000000000000000000000000000000000000010000000000000022000000000000000000000"
+n072="0000000000000000000000000000000000000000000000000000000000000000000000000000022200000000000000000000"
+n073="0000000000000000000000000000000000000000000000000000000000100000000000000000020220000000000000000000"
+n074="0000000000000000000000000100000000000000000000000000000000000000000000000000220200000000000000000000"
+n075="0000000000000000000000000000000000000000000000000000000001000000000000000000200220001000000000001000"
+n076="0000000000000000000000000002000000000000000000000000000000000000000000000000200022000000000000001000"
+n077="0000000000000000000002002220000000000000000000000000000000000000000000222200000012200200000000010000"
+n078="0000000000000000010002000000000000000000000000000000000000000000000000000220000000220222100001000000"
+n079="0000000000000000000022020000000000000000000000000000001000000000000000000000000000000002200000000000"
+n080="0000000000000000002220320200220000000000000000000000000000000000002222000000000000000002220000000000"
+n081="0000000000000000000000000202200000000000000000000000000000000000222002200000000000000022000000000000"
+n082="0000000000000000000002220200001000000000000000000000000000000022200010200000000000002220000000000000"
+n083="0000000000000000001222200000000000000000000000000000000000000020022200000000020000000000100000000000"
+n084="0000000000000000010000000000000000000000000000000000000100001020200200000000002200100000000000000000"
+n085="0000000000000000000022202320000000000000000000000000000001000020220000000000000200000000000000000000"
+n086="0000000000000000000020022000200000000000000000000000000000002200000000000000000220000000201000000000"
+n087="0000000000000000000220020000200000000000000000000000000000002000000000000000000020000002200010000000"
+n088="0000000000000010002200000003200000000000000000000000000000000000000000000000000000000022000000000000"
+n089="0000010000000000002000000022000000000000000000000000000000000000000000000000000000000021000000000000"
+n090="0000000000000010012000000220000000000000000000000000000000000000000000000000000000000000000000000000"
+n091="0000000001000201002000200000000000000000000000000000000000000000000000000000000000000010000000000000"
+n092="0001000000002200022222200000000000000000000000000000000000000000000000000000000000000000000000000000"
+n093="0000000000022000000010000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n094="1000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n095="0000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000"
+n096="0000000000100010000001000000000000000000000000000000000000000000000000000000000000000000011000001000"
+n097="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000110000001000"
+n098="0000001100000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000"
+n099="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100"
Les fichiers binaires freeciv-cvs-Jan-04/data/trident/.xvpics/tiles.png et
freeciv/data/trident/.xvpics/tiles.png sont différents.
Les fichiers binaires freeciv-cvs-Jan-04/data/trident/tiles.png et
freeciv/data/trident/tiles.png sont différents.
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/data/trident/tiles.spec
freeciv/data/trident/tiles.spec
--- freeciv-cvs-Jan-04/data/trident/tiles.spec 2003-11-21 07:05:57.000000000
+0100
+++ freeciv/data/trident/tiles.spec 2004-01-06 18:31:00.000000000 +0100
@@ -370,6 +370,7 @@
7, 18, "ts.silk"
7, 19, "ts.wine"
+ 12, 6, "tx.lfog"
; Terrain improvements and similar:
12, 7, "tx.farmland"
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/doc/HACKING freeciv/doc/HACKING
--- freeciv-cvs-Jan-04/doc/HACKING 2003-11-29 07:05:33.000000000 +0100
+++ freeciv/doc/HACKING 2004-01-06 18:31:50.000000000 +0100
@@ -384,47 +384,61 @@
be used.
=========================================================================
-Different types of map topology
+Different types of topologies
=========================================================================
+ Historically in FreeCiv the word Topologies was used for 2 different
+thinks, one is the way of the map is placed in memory and indexed; we call
+it Map Indexing (eventually Map Inedxing Topology)
+ The other is related to the way of tiles see the neighbor tiles and
+paths over the map, this is related to the wrapping of edges; We call it
+Wrapping Topology (or Topology as in math).
+
+see Map Indexing, Wrapping, Wrapping Topology
+ and Cartographicals Projections later
+=========================================================================
+Map Indexing
+=========================================================================
Originally Freeciv supports only a simple rectangular map. For instance
a 5x3 map would be conceptualized as
- <- XXXXX ->
- <- XXXXX ->
- <- XXXXX ->
+ - XXXXX -
+ - XXXXX -
+ - XXXXX -
and it looks just like that under "overhead" (non-isometric) view (the
-arrows represent an east-west wrapping). But under an isometric-view
-client, the same map will look like
+minus represent an east-west simplest wrapping). But under an
+isometric-view client, the same map will look like
- X
- X X
+ \
+ \ X
+ \ X X
X X X
X X X
X X X
- X X
- x
+ X X \
+ X \
+ \
where "north" is to the upper-right and "south" to the lower-left. This
-makes for a mediocre interface.
+makes for a mediocre interface in this calssic wraping topology.
An isometric-view client will behave better with an isometric map. This is
what Civ2, SMAC, Civ3, etc. all use. A rectangular isometric map can be
conceptualized as
- <- X X X X X ->
- <- X X X X X ->
- <- X X X X X ->
- <- X X X X X ->
+ - X X X X X -
+ - X X X X X -
+ - X X X X X -
+ - X X X X X -
(north is up) and it will look just like that under an isometric-view client.
Of course under an overhead-view client it will again turn out badly.
Both types of maps can easily wrap in either direction: north-south or
-east-west. Thus there are four types of wrapping: flat-earth, vertical
-cylinder, horizontal cylinder, and torus. Traditionally Freeciv only wraps
-in the east-west direction.
+east-west.
+
+see Wrapping, Wrapping Topology and Cartographicals Projections later
=========================================================================
Different coordinate systems
@@ -575,6 +589,283 @@
map_pos_to_native_x, and map_pos_to_native_y that are defined in map.h.
=========================================================================
+Wrapping (neighbor topologie at edges)
+=========================================================================
+No Wrap Wrapping:
+================
+ The tiles at edge the tiles are no neighbor, this is a topological
+singularity.
+
+sample map 6x4
+
+ ABCDEF
+ GHIJKL
+ MNOPQR
+ STUVWX
+
+the O tiles as 8 neighbor, the M only 5 and the S tile 3 neighbor.
+
+
+Simplest Wrapping:
+=================
+ The tiles at edge the tiles are as neighbor the tiles of
+the oposites edges. The edges are wrapped 2 at some time.
+
+map 6x4, E-W simplest Wrapping and N and S non wrapping
+(cylinder topology)
+
+f-ABCDEF-a
+l-GHIJKL-g
+r-MNOPQR-m
+x-STUVWX-s
+
+the O tiles as 8 neighbor. The M too: 5 normal neighbor ( G, H, N, T, S)
+and 3 wrapped images ( x, r, l).
+The S tile 5 neighbor: 3 normal (M, N, T) and 2 wrapped images (x, r)
+ ( this is a topological singularity related to the no wrap wrapping)
+
+
+Offset Wrapping:
+===============
+this is a variation of simplest wrapping: which a wrap in the X direction
+is accompanied by a shift in the Y direction:
+
+r-ABCDEF-m
+x-GHIJKL-s
+f-MNOPQR-a
+l-STUVWX-g
+
+The tile M as 8 neighors: 5 normal neighbor ( G, H, N, T, S)
+and 3 wrapped images ( l, f, x).
+The S tile 5 neighbor: 3 normal (M, N, T) and 2 wrapped images (l, f)
+ ( this is a topological singularity related to the no wrap wrapping)
+
+
+Reversed Wrapping:
+=================
+The tiles at edge the tiles are as neighbor one tiles of
+the some edges turned 180°. The edges can wrapped 1 at time.
+
+this map i am a reversed wrapping at South edge.
+
+ABCDEF The tile T as 8 neighors: 5 normal neighbor (S, M, N, O, U)
+GHIJKL and 3 wrapped images ( v, w, x)
+MNOPQR
+STUVWX The tile S as 5 neighors: 3 normal neighbor (M, N, T)
+|||||| and 3 wrapped images (w, x) ( this is a topological singularity
+xwvuts related to the no wrap wrapping)
+rqponm
+
+But: The tile U as neighors in 8 direction but only 6 different: 5 normal
+neighbor (T, N, O, P, V) and and 3 wrapped images (u, v, w), Were u a image
+of itself and v a image of a normal neighbor
+(this is a new topological singularity) we call it a Central Singularity
+ -------------------
+Rem: all images tiles are 180°
+
+this wrapping is complex but this is very intersting see Cartographicals
+Projections.
+
+see Wrapping Topologies and Cartographicals Projections
+
+=========================================================================
+Wrapping Topologies (Topologies make by choice of wrapping)
+=========================================================================
+combining wrapping edges we make different Topologie where neighors of
+a tiles but path over the map ave different bevaiator
+
+Some this topology is related to a Cartographical projection!
+ (we can make a more or less nice map of Earth)
+List of Cartographicals topologies:
+----------------------------------
+FLAT(only partial map), Cylinder(classic global maps), Conical (half Earth nice
+map), Quincuncial and Quincuncial_sq (nice gloabal maps)
+see Cartographicals Projections and Poles
+
+FLAT*:
+=====
+no wrap wrapping
+
+all edges are singularities
+
+Cylinder*:
+=========
+
+simplest Wrap E-W, no wrap N and S or
+simplest Wrap N-S, no wrap E and W
+
+See simplest Wrapping doc and ascii art
+
+the first form is the classic topologie of Civilization (c)
+the second form is a 90° rotated image of the first form
+topologicaly (math) there are the somme.
+
+no-wrap edges are singularities
+
+see cylindrical projections
+
+TORUS:
+=====
+simplest wrap E-W and S-N
+
+x-stuvwx-s
+| |||||| |
+f-ABCDEF-a
+l-GHIJKL-g
+r-MNOPQR-m
+x-STUVWX-s
+| |||||| |
+f-abcdef-a
+
+This is one of more simplest topologies, no singularities
+
+
+Mobius Strip:
+============
+combining a offset wrapping over N-S edge and a simplest wraping
+over E-W edge.
+
+c-defabc-d
+| |||||| |
+f-ABCDEF-a
+l-GHIJKL-g
+r-MNOPQR-m
+g-STUVWX-s
+| |||||| |
+u-vwxstu-v
+
+this is a interesting topology, no singularities
+
+CONICAL*:
+========
+one reversed wraping over the S edge, no wrap on N,E and W edge
+
+See the reversed wrapping doc and ascii art
+
+this topologie are not actually allowed, E and W use the some type of
+wraping and S and N too in actual freeciv.
+
+interesting to undestand the quincuncial topologie
+
+See the Conical projection doc
+
+QUINCUNCIAL*:
+============
+simplest wrappin over E-W edge reversed Wrappin in S and N edges
+
+a-fedcba-f
+| |||||| |
+f-ABCDEF-a
+l-GHIJKL-g
+r-MNOPQR-m
+g-STUVWX-s
+| |||||| |
+s-xwvuts-g
+
+in this topologie there are 4 central singularities in corners and in the
+midle of N and S edges
+
+best sphere like topologie if Xsize=2*Ysize
+See Pierce-Quincuncial Projection doc
+
+QUINCUNCIAL_SQ*:(the best)
+===============
+reversed wrapping on all edges
+
+x-fedcba-s
+| |||||| |
+s-ABCDEF-x
+m-GHIJKL-r
+g-MNOPQR-l
+a-STUVWX-f
+| |||||| |
+f-xwvuts-a
+
+in this topologie there are 4 central singularities in midle of all edges
+
+completly simetric is the best way to map the Earth on a flat square map
+best sphere like topologie if Xsize=Ysize
+See Pierce-Quincuncial Projection doc
+
+SPIN:
+====
+reversed wrapping on E, W edges
+
+s-ABCDEF-x
+m-GHIJKL-r
+g-MNOPQR-l
+a-STUVWX-f
+
+in this topologie there are 2 central singularities in midle of reversed
+wrapping edges
+
+=========================================================================
+Cartogrphicals Projections
+=========================================================================
+Cylindrical Projections
+=======================
+http://www.mapleapps.com/categories/data_analysis_stats/maplemaps/html/cylinder1.html
+
+Conical Projection
+==================
+http://www.mapleapps.com/categories/data_analysis_stats/maplemaps/html/images/maps/maps13.gif
+
+Pierce-Quincuncial Projection
+=============================
+http://www.mapleapps.com/categories/data_analysis_stats/maplemaps/html/pierce1.html
+
+see this page too:
+------------------
+http://www.mapleapps.com/categories/data_analysis_stats/maplemaps/html/distortion1.html
+
+=========================================================================
+Poles
+=========================================================================
+mapgen place poles this way
+
+/* ********************************************************************
+ * if clima_choice == 1 ( random choice! if -1)
+ *
+ * TOPO QUINCUNCIAL
+ * 2 half poles at North(the some) and 2 half poles at South
+ *
+ * 1 1
+ *
+ * 2 2
+ *
+ * TOPO QUINCUNCIAL_SQ
+ * One Pole at center North and one at center South
+ *
+ * if clima_choice != 1
+ * TOPO QUINCUNCIAL
+ * 1 poles at center North and 1 poles at corners South
+ * TOPO QUINCUNCIAL_SQ
+ * One Pole at center of map and pole one other in 4 corners
+ *
+ * others topologies not see clima_choice value
+ *
+ * TOPO FLAT
+ * one strip pole at north
+ *
+ * TOPO CLASSIC
+ * one strip pole at north and one other at south
+ *
+ * TOPO Torus
+ * One Pole at center of map and one other pole in 4 corners
+ *
+ * TOPO MOBIUS (1 pole ) or (2 poles)
+ * (1 pole) some strip poles at North and South ( not implemented )
+ * 2 half poles at North(the some) and 2 half poles at South
+ *
+ * 1 2
+ *
+ * 2 1
+ *
+ * TOPO ELECTRON (1 pole)
+ * strip pole at center of map
+ * **************************************************************/
+
+=========================================================================
Unknown tiles and Fog of War
=========================================================================
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/server/citytools.c
freeciv/server/citytools.c
--- freeciv-cvs-Jan-04/server/citytools.c 2003-12-07 07:08:47.000000000
+0100
+++ freeciv/server/citytools.c 2004-01-06 18:31:21.000000000 +0100
@@ -1917,7 +1917,8 @@
int map_x, map_y;
struct tile *ptile;
- if (!city_map_to_map(&map_x, &map_y, pcity, city_x, city_y)) {
+ if (!normal_city_map_to_map(&map_x, &map_y, pcity->x, pcity->y,
+ city_x, city_y)) {
return FALSE;
}
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/server/gotohand.c
freeciv/server/gotohand.c
--- freeciv-cvs-Jan-04/server/gotohand.c 2003-10-22 06:59:52.000000000
+0200
+++ freeciv/server/gotohand.c 2004-01-06 18:31:21.000000000 +0100
@@ -299,7 +299,7 @@
? WARMAP_SEACOST(x, y) : WARMAP_COST(x, y));
ptile = map_get_tile(x, y);
- adjc_dir_iterate(x, y, x1, y1, dir) {
+ adjc_dir_iterate_full(x, y, x1, y1, dir, dir1, rev_des) {
switch (move_type) {
case LAND_MOVING:
if (WARMAP_COST(x1, y1) <= cost)
@@ -321,7 +321,7 @@
/* else c = ptile->move_cost[k];
This led to a bad bug where a unit in a swamp was considered too far
away */
else { /* we have a city */
- int tmp = map_get_tile(x1, y1)->move_cost[DIR_REVERSE(dir)];
+ int tmp = map_get_tile(x1, y1)->move_cost[DIR_REVERSE(dir1)];
move_cost = (ptile->move_cost[dir] + tmp +
(ptile->move_cost[dir] > tmp ? 1 : 0))/2;
}
@@ -333,7 +333,6 @@
}
break;
-
case SEA_MOVING:
move_cost = SINGLE_MOVE;
move_cost += cost;
@@ -351,7 +350,7 @@
move_cost = 0; /* silence compiler warning */
die("Bad/unimplemented move_type in really_generate_warmap().");
}
- } adjc_dir_iterate_end;
+ } adjc_dir_iterate_full_end;
}
freelog(LOG_DEBUG, "Generated warmap for (%d,%d).",
@@ -485,7 +484,7 @@
adjc_dir_iterate(src_x, src_y, x, y, dir) {
/* if we didn't come from there */
- if (!BV_ISSET(came_from, dir)
+ if (!BV_ISSET(came_from, dir) /* no normalize dir */
&& !is_ocean(map_get_terrain(x, y))
/* and there is an enemy there */
&& is_enemy_unit_tile(map_get_tile(x, y), owner)) {
@@ -629,7 +628,7 @@
/* Try to move to all tiles adjacent to x,y. The coordinats of the tile we
try to move to are x1,y1 */
- adjc_dir_iterate(x, y, x1, y1, dir) {
+ adjc_dir_iterate_full(x, y, x1, y1, dir, dir1, rev_des) {
if ((restriction == GOTO_MOVE_CARDINAL_ONLY)
&& !DIR_IS_CARDINAL(dir)) continue;
@@ -788,12 +787,13 @@
warmap_cost[map_pos_to_index(x1, y1)] = total_cost;
add_to_mapqueue(total_cost, x1, y1);
BV_CLR_ALL(LOCAL_VECTOR(x1, y1));
- BV_SET(LOCAL_VECTOR(x1, y1), DIR_REVERSE(dir));
+ BV_SET(LOCAL_VECTOR(x1, y1),DIR_REVERSE(dir1));
+
freelog(LOG_DEBUG,
"Candidate: %s from (%d, %d) to (%d, %d), cost %d",
dir_get_name(dir), x, y, x1, y1, total_cost);
} else if (warmap_cost[map_pos_to_index(x1, y1)] == total_cost) {
- BV_SET(LOCAL_VECTOR(x1, y1), DIR_REVERSE(dir));
+ BV_SET(LOCAL_VECTOR(x1, y1), DIR_REVERSE(dir1));
freelog(LOG_DEBUG,
"Co-Candidate: %s from (%d, %d) to (%d, %d), cost %d",
dir_get_name(dir), x, y, x1, y1, total_cost);
@@ -805,7 +805,7 @@
/* Make sure we stop searching when we have no hope of finding a
shorter path */
maxcost = total_cost + 1;
}
- } adjc_dir_iterate_end;
+ } adjc_dir_iterate_full_end;
}
freelog(LOG_DEBUG, "GOTO: (%d, %d) -> (%d, %d), cost = %d",
@@ -826,7 +826,7 @@
if (!get_from_mapqueue(&x, &y))
break;
- adjc_dir_iterate(x, y, x1, y1, dir) {
+ adjc_dir_iterate_full(x, y, x1, y1, dir, dir1 ,rev_des) {
if ((restriction == GOTO_MOVE_CARDINAL_ONLY)
&& !DIR_IS_CARDINAL(dir)) continue;
@@ -837,12 +837,13 @@
add_to_mapqueue(MAXCOST-1 - move_cost, x1, y1);
/* Mark it on the warmap */
- WARMAP_VECTOR(x1, y1) |= 1 << DIR_REVERSE(dir);
+ WARMAP_VECTOR(x1, y1) |= 1 << DIR_REVERSE(dir1) ;
+
BV_CLR(LOCAL_VECTOR(x, y), dir); /* avoid repetition */
freelog(LOG_DEBUG, "PATH-SEGMENT: %s from (%d, %d) to (%d, %d)",
- dir_get_name(DIR_REVERSE(dir)), x1, y1, x, y);
+ dir_get_name( DIR_REVERSE(dir1)), x1, y1, x, y);
}
- } adjc_dir_iterate_end;
+ } adjc_dir_iterate_full_end;
}
return TRUE;
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/server/mapgen.c
freeciv/server/mapgen.c
--- freeciv-cvs-Jan-04/server/mapgen.c 2003-11-19 07:04:30.000000000 +0100
+++ freeciv/server/mapgen.c 2004-01-06 18:31:51.000000000 +0100
@@ -36,6 +36,7 @@
#define hmap(x, y) (height_map[map_pos_to_index(x, y)])
#define rmap(x, y) (river_map[map_pos_to_index(x, y)])
+int map_clima(int map_x, int map_y);
static void make_huts(int number);
static void add_specials(int prob);
static void mapgenerator1(void);
@@ -70,6 +71,119 @@
/* this is used for generator>1 */
#define MAP_NCONT 255
+/* **********************************************************************
+ * return 0 for the coolest map_x,map_y tile of the map
+ * and 100 for the hotest one, this is proportional to area climatic zones
+ * allow the 9 topology xwrap_type-ywrap_type with the WT_REVERSED,WT_SIMPLEST,
+ * WT_NONE and the 10th topology XRAP=WT_SIMPLEST , YWRAP=WT_OFFSET
+ * see doc/HACKING#Poles [mburda]
+ *************************************************************************/
+
+int clima_choice = -1;
+int map_clima(int map_x, int map_y)
+{
+ int nat_x, nat_y, x_2, y_2;
+ double x, y, m;
+
+ /* this determine the way for place the poles */
+ if (clima_choice == -1) {
+ if ( map.generator == 2 && XWRAP_TYPE_IS(WT_REVERSED)
+ && YWRAP_TYPE_IS(WT_REVERSED)) {
+ clima_choice = 1; /* best to place the big continent */
+ } else {
+ clima_choice = myrand(20)<10 ? 1 : 0;
+ }
+ }
+ normalize_map_pos(&map_x, &map_y);
+ map_to_native_pos(&nat_x, &nat_y, map_x, map_y);
+ assert(nat_x >= 0);
+ assert(nat_y >= 0);
+ assert(nat_x < map.xsize);
+ assert(nat_y < map.ysize);
+ /* is a partial map */
+
+ if (XWRAP_TYPE_IS(WT_NONE) && YWRAP_TYPE_IS(WT_NONE)) {
+ return 100 * nat_y / (map.ysize - 1);
+ }
+
+ /* is a global map, get symeties */
+ x_2 = map.xsize / 2 - 1 + map.xsize % 2;
+ y_2 = map.ysize / 2 - 1 + map.ysize % 2;
+
+ /* poles are not placed in some way in Quincuncial_H and quincunail_V */
+ /* the 2 ways are good ones Quincuncial_H */
+
+ if ((clima_choice == 1) &&
+ (XWRAP_TYPE_IS(WT_SIMPLEST) && YWRAP_TYPE_IS(WT_REVERSED))) {
+ y_2 = map.ysize - 1;
+ }
+
+ if ((clima_choice == 1) &&
+ (XWRAP_TYPE_IS(WT_REVERSED) && YWRAP_TYPE_IS(WT_REVERSED))) {
+ x_2 = map.xsize - 1;
+ }
+
+ /* poles are not placed in some way in Quincuncial_H and quincunail_V */
+ /* the 2 ways are good ones */
+ if (nat_x > x_2) {
+ nat_x = map.xsize - 1 - nat_x;
+ }
+ if (nat_y > y_2) {
+ nat_y = map.ysize - 1 - nat_y;
+ }
+ x = (double) nat_x / (double) x_2;
+ y = (double) nat_y / (double) y_2;
+ if ((XWRAP_TYPE_IS(WT_SIMPLEST) && YWRAP_TYPE_IS(WT_NONE))) {
+ return 100 * y;
+ }
+ if ((XWRAP_TYPE_IS(WT_REVERSED) && YWRAP_TYPE_IS(WT_NONE))) {
+ return 100 - 100 * y;
+ }
+ if (XWRAP_TYPE_IS(WT_NONE) && YWRAP_TYPE_IS(WT_SIMPLEST)) {
+ return 100 * x;
+ }
+ if (XWRAP_TYPE_IS(WT_NONE) && YWRAP_TYPE_IS(WT_REVERSED)) {
+ return 100 - 100 * x;
+ }
+
+ if ((XWRAP_TYPE_IS(WT_SIMPLEST) && YWRAP_TYPE_IS(WT_SIMPLEST))
+ || (XWRAP_TYPE_IS(WT_REVERSED) && YWRAP_TYPE_IS(WT_REVERSED)
+ && clima_choice != 1)
+ || (XWRAP_TYPE_IS(WT_SIMPLEST) && YWRAP_TYPE_IS(WT_REVERSED)
+ && clima_choice == 1)) {
+
+ if (x + y > 1) {
+ x = 1 - x;
+ y = 1 - y;
+ }
+ return 150 * (x * x * y + x * y * y) - 50 * (x * x * x + y * y * y) +
+ 150 * (x * x + y * y);
+
+ }
+ if (((XWRAP_TYPE_IS(WT_SIMPLEST) && YWRAP_TYPE_IS(WT_OFFSET))
+ || ((XWRAP_TYPE_IS(WT_REVERSED) && YWRAP_TYPE_IS(WT_REVERSED)
+ && clima_choice == 1))
+ || ((XWRAP_TYPE_IS(WT_SIMPLEST) && YWRAP_TYPE_IS(WT_REVERSED)
+ && clima_choice != 1)))) {
+ x = x > 0.5 ? 2 * x - 1 : 1 - 2 * x;
+ } else {
+ y = y > 0.5 ? 2 * y - 1 : 1 - 2 * y;
+ }
+ m = MAX(x, y);
+ return 75 * (x * x + y * y) * (1 - m) + 100 * m * m * m;
+}
+
+static void clean_singularities(void)
+{
+ whole_map_iterate(x, y) {
+ if (!is_ocean(map_get_terrain(x, y))
+ && map_get_terrain(x, y) != T_ARCTIC)
+ if (near_singularity(x, y)) {
+ map_set_terrain(x, y, T_OCEAN);
+ map_set_continent(x, y, 0);
+ }
+ } whole_map_iterate_end;
+}
/**************************************************************************
make_mountains() will convert all squares that are higher than thill to
mountains and hills. Notice that thill will be adjusted according to
@@ -105,48 +219,37 @@
/**************************************************************************
add arctic and tundra squares in the arctic zone.
- (that is the top 10%, and low 10% of the map)
+ (that is the coolest 10% of the map)
+ if make_polar(TRUE) we add some tundra
**************************************************************************/
-static void make_polar(void)
+static void make_polar(bool addtundra)
{
- int y,x;
+ int T;
+ struct tile *ptile;
- for (y=0;y<map.ysize/10;y++) {
- for (x=0;x<map.xsize;x++) {
- if ((hmap(x, y)+(map.ysize/10-y*25)>myrand(maxval) &&
- map_get_terrain(x,y)==T_GRASSLAND) || y==0) {
- if (y<2)
- map_set_terrain(x, y, T_ARCTIC);
- else
- map_set_terrain(x, y, T_TUNDRA);
-
- }
- }
- }
- for (y=map.ysize*9/10;y<map.ysize;y++) {
- for (x=0;x<map.xsize;x++) {
- if ((hmap(x, y)+(map.ysize/10-(map.ysize-y)*25)>myrand(maxval) &&
- map_get_terrain(x, y)==T_GRASSLAND) || y==map.ysize-1) {
- if (y>map.ysize-3)
- map_set_terrain(x, y, T_ARCTIC);
- else
- map_set_terrain(x, y, T_TUNDRA);
+ whole_map_iterate(map_x, map_y) {
+ T = map_clima(map_x, map_y); /* temperature parameter */
+ ptile = map_get_tile(map_x, map_y);
+ if (T < 5) { /* get the 10% coolest part of the map */
+ ptile->terrain = T_ARCTIC;
+ } else if (T <= 8) {
+ if (ptile->terrain == T_OCEAN) {
+ ptile->terrain = T_ARCTIC;
+ } else {
+ ptile->terrain = T_TUNDRA;
+ }
+ } else if (T <= 10) {
+ if (ptile->terrain == T_OCEAN) {
+ if (myrand(10) > 5) {
+ ptile->terrain = T_ARCTIC;
+ } else if (addtundra && myrand(10) > 4) {
+ ptile->terrain = T_TUNDRA;
+ }
+ } else if ( myrand(10) > 5) {
+ ptile->terrain = T_TUNDRA;
}
}
- }
-
- /* only arctic and tundra allowed at the poles (first and last two lines,
- as defined in make_passable() ), to be consistent with generator>1.
- turn every land tile on the second lines that is not arctic into tundra,
- since the first lines has already been set to all arctic above. */
- for (x=0;x<map.xsize;x++) {
- if (map_get_terrain(x, 1)!=T_ARCTIC &&
- !is_ocean(map_get_terrain(x, 1)))
- map_set_terrain(x, 1, T_TUNDRA);
- if (map_get_terrain(x, map.ysize-2)!=T_ARCTIC &&
- !is_ocean(map_get_terrain(x, map.ysize-2)))
- map_set_terrain(x, map.ysize-2, T_TUNDRA);
- }
+ } whole_map_iterate_end;
}
/**************************************************************************
@@ -540,7 +643,9 @@
/* Test if the river is done. */
if (adjacent_river_tiles4(x, y) != 0||
- adjacent_ocean_tiles4(x, y) != 0) {
+ adjacent_ocean_tiles4(x, y) != 0||
+ (map_get_terrain(x, y) == T_ARCTIC
+ && map_clima(x, y) < 8)) { /*rivers end at poles */
freelog(LOG_DEBUG,
"The river ended at (%d, %d).\n", x, y);
return TRUE;
@@ -655,11 +760,11 @@
* river code was written when map.riverlength had a maximum value of
* 1000 rather than the current 100 */
10 *
- /* The size of the map (poles don't count). */
- (map_num_tiles() - 2 * map.xsize) *
- /* Rivers need to be on land only. */
- map.landpercent /
- /* Adjustment value. Tested by me. Gives no rivers with 'set
+ /* The size of the map (poles don't count). */
+ (map_num_tiles() * 0.9 ) *
+ /* Rivers need to be on land only. */
+ map.landpercent /
+ /* Adjustment value. Tested by me. Gives no rivers with 'set
rivers 0', gives a reasonable amount of rivers with default
settings and as many rivers as possible with 'set rivers 100'. */
0xD000; /* (= 53248 in decimal) */
@@ -683,7 +788,7 @@
/* Don't start any rivers at the poles. */
do {
rand_map_pos(&x, &y);
- } while (y == 0 || y == map.ysize-1);
+ } while (map_clima(x, y) < 9);
/* Check if it is suitable to start a river on the current tile.
*/
@@ -855,16 +960,17 @@
tres*=9;
tres/=10;
} while (abs(total-count)> maxval/40);
- if (map.separatepoles && has_poles) {
- make_passable();
- }
+
make_mountains(maxval*8/10);
make_forests();
make_swamps();
make_deserts();
make_plains();
if (has_poles) {
- make_polar();
+ make_polar(FALSE);
+ }
+ if (map.separatepoles && has_poles) {
+ make_passable();
}
make_fair();
make_rivers();
@@ -924,6 +1030,88 @@
}
/**************************************************************************
+ Assign continent numbers to Poles in gen 2,3 or 4. and clean its!
+ (poles are separates island)
+ Numbers 1 and 2 are reserved for polar continents if
+ map.generator != 0; otherwise are not special.
+ Also sets map.num_continents (note 0 is ocean)
+ See the doc/HACKING#Poles
+**************************************************************************/
+void assign_poles_numbers(void)
+{
+ /* Default poles, cylinder topology */
+ int x1 = 0, y1 = 0,
+ x2 = map.ysize - 1, y2 = map.ysize - 1;
+
+ map.num_continents= 2;
+
+ /* FLAT TOPOLOGIE */
+ if(XWRAP_TYPE_IS(WT_NONE) && YWRAP_TYPE_IS(WT_NONE)) {
+ map.num_continents= 1;
+ }
+
+ if (XWRAP_TYPE_IS(WT_REVERSED) && YWRAP_TYPE_IS(WT_REVERSED)) {
+ /* QUINCUNCIAL_SQ TOPOLOGY */
+ if (clima_choice == 1) {
+ x1 = map.xsize / 2;
+ x2 = x1;
+ } else {
+ x2 = map.xsize / 2;
+ y2 = map.ysize / 2;
+ }
+ } else if (XWRAP_TYPE_IS(WT_REVERSED) || YWRAP_TYPE_IS(WT_REVERSED)) {
+ /* Spin topologies */
+ x1 = map.xsize / 2;
+ y1 = map.ysize / 2;
+ map.num_continents= 1;
+ }
+
+ if (XWRAP_TYPE_IS(WT_SIMPLEST) && YWRAP_TYPE_IS(WT_OFFSET)) {
+ /* Mobius Topology*/
+ x1 = map.xsize / 4;
+ y1 = 0;
+ x2 = x1;
+ y2 = map.ysize - 1;
+ }
+
+ /* QUINCUNCIAL (horizontal) topology */
+ if (XWRAP_TYPE_IS(WT_SIMPLEST) && YWRAP_TYPE_IS(WT_REVERSED)) {
+ if (clima_choice == 1) {
+ x1 = map.xsize / 4;
+ y1 = 0;
+ x2 = x1;
+ y2 = map.ysize - 1;
+ } else {
+ x1 = map.xsize / 2;
+ y1 = 0;
+ x2 = 0;
+ y2 = map.ysize - 1;
+ }
+ map.num_continents = 2;
+ }
+
+ if (XWRAP_TYPE_IS(WT_SIMPLEST) && YWRAP_TYPE_IS(WT_SIMPLEST)) {
+ /* TORUS TOPOLOGY */
+ x2 = map.xsize / 2;
+ y2 = map.ysize / 2;
+ }
+
+/* set the poles */
+ if (map.generator != 0 && has_poles) {
+ assign_continent_flood(x1, y1, 1);
+ if (map.num_continents == 2) {
+ assign_continent_flood(x2, y2, 2);
+ }
+ }
+
+/* clean no in poles continent island */
+ whole_map_iterate(x, y) {
+ if (map_get_continent(x, y) == 0 && !is_ocean(map_get_terrain(x, y))) {
+ map_set_terrain(x, y, T_OCEAN);
+ }
+ } whole_map_iterate_end;
+}
+/**************************************************************************
Assign continent numbers to all tiles.
Numbers 1 and 2 are reserved for polar continents if
map.generator != 0; otherwise are not special.
@@ -1163,7 +1351,8 @@
* needs to control the temperature gradient between "poles" and
* "equator"; e.g., if there are no poles desert and tundra should be
* equally likely at either end. */
- has_poles = !topo_has_flag(TF_WRAPY);
+ /* map_clima is a fix of it [mburda] */
+ has_poles = TRUE;
/* don't generate tiles with mapgen==0 as we've loaded them from file */
/* also, don't delete (the handcrafted!) tiny islands in a scenario */
@@ -1185,6 +1374,7 @@
if (!map.tinyisles) {
remove_tiny_islands();
}
+ clean_singularities();
}
if(!map.have_specials) /* some scenarios already provide specials */
@@ -1235,6 +1425,9 @@
static void adjust_map(int minval)
{
whole_map_iterate(x, y) {
+ if(near_singularity(x, y)) {
+ hmap(x, y) = 0;
+ }
hmap(x, y) -= minval;
} whole_map_iterate_end;
}
@@ -1245,6 +1438,7 @@
static void mapgenerator1(void)
{
int i;
+ int map_x, map_y;
int minval=5000000;
height_map=fc_malloc (sizeof(int)*map.xsize*map.ysize);
@@ -1256,12 +1450,16 @@
int x, y;
rand_map_pos(&x, &y);
- hmap(x, y) += myrand(5000);
+ native_to_map_pos(&map_x, &map_y, x, y);
+ if(near_singularity(map_x, map_y)) { /* avoid land in singularities */
+ hmap(x, y) -= myrand(5000);
+ } else if (map_clima(map_x, map_y) > 6) { /* avoid height land at poles */
+ hmap(x, y) += myrand(5000);
+ }
if ((i % 100) == 0) {
smooth_map();
}
}
-
smooth_map();
smooth_map();
smooth_map();
@@ -1273,7 +1471,7 @@
minval = hmap(x, y);
} whole_map_iterate_end;
- maxval-=minval;
+ maxval -= minval;
adjust_map(minval);
make_land();
@@ -1379,7 +1577,7 @@
};
static bool is_cold(int x, int y){
- return ( y * 5 < map.ysize || y * 5 > map.ysize * 4 );
+ return ( map_clima(x, y) <= 20 );
}
/**************************************************************************
@@ -1439,7 +1637,7 @@
while (i > 0 && (failsafe--) > 0) {
get_random_map_position_from_state(&x, &y, pstate);
-
+
if (map_get_continent(x, y) == pstate->isleindex &&
map_get_terrain(x, y) == T_GRASSLAND) {
@@ -1599,8 +1797,9 @@
i = islemass - 1;
while (i > 0 && tries-->0) {
get_random_map_position_from_state(&x, &y, pstate);
- if (hmap(x, y) == 0 && (hmap(x + 1, y) != 0 || hmap(x - 1, y) != 0 ||
- hmap(x, y + 1) != 0 || hmap(x, y - 1) != 0)) {
+ if ((!near_singularity(x, y) || myrand(50) < 25 ) && hmap(x, y) == 0
+ && (hmap(x + 1, y) != 0 || hmap(x - 1, y) != 0
+ || hmap(x, y + 1) != 0 || hmap(x, y - 1) != 0)) {
hmap(x, y) = 1;
i--;
if (y >= pstate->s - 1 && pstate->s < map.ysize - 2) pstate->s++;
@@ -1781,24 +1980,10 @@
map_clear_all_specials(x, y);
map_set_owner(x, y, NULL);
}
+
if (has_poles) {
- for (x = 0; x < map.xsize; x++) {
- map_set_terrain(x, 0, myrand(9) > 0 ? T_ARCTIC : T_TUNDRA);
- map_set_continent(x, 0, 1);
- if (myrand(9) == 0) {
- map_set_terrain(x, 1, myrand(9) > 0 ? T_TUNDRA : T_ARCTIC);
- map_set_continent(x, 1, 1);
- }
- map_set_terrain(x, map.ysize - 1,
- myrand(9) > 0 ? T_ARCTIC : T_TUNDRA);
- map_set_continent(x, map.ysize - 1, 2);
- if (myrand(9) == 0) {
- map_set_terrain(x, map.ysize - 2,
- myrand(9) > 0 ? T_TUNDRA : T_ARCTIC);
- map_set_continent(x, map.ysize - 2, 2);
- }
- }
- map.num_continents = 2;
+ make_polar(TRUE);
+ assign_poles_numbers();
} else {
map.num_continents = 0;
}
@@ -2076,26 +2261,29 @@
/* set midpoints of sides to avg of side's vertices plus a random factor */
/* unset points are zero, don't reset if set */
- if (hmap((x0 + x1)/2, y0) == 0) {
- hmap((x0 + x1)/2, y0) = (val[0][0] + val[1][0])/2 + myrand(step) - step/2;
- }
- if (hmap((x0 + x1)/2, y1wrap) == 0) {
- hmap((x0 + x1)/2, y1wrap) = (val[0][1] + val[1][1])/2
- + myrand(step)- step/2;
- }
- if (hmap(x0, (y0 + y1)/2) == 0) {
- hmap(x0, (y0 + y1)/2) = (val[0][0] + val[0][1])/2 + myrand(step) - step/2;
- }
- if (hmap(x1wrap, (y0 + y1)/2) == 0) {
- hmap(x1wrap, (y0 + y1)/2) = (val[1][0] + val[1][1])/2
- + myrand(step) - step/2;
- }
+#define set_midpoints(X,Y,V) \
+ { int map_x, map_y; \
+ native_to_map_pos(&map_x, &map_y, (X), (Y)); \
+ if( !near_singularity( map_x, map_y) && hmap((X), (Y)) == 0 ) { \
+ hmap((X), (Y)) = V; \
+ } }
+ set_midpoints((x0 + x1)/2, y0,
+ (val[0][0] + val[1][0])/2 + myrand(step) - step/2);
+
+ set_midpoints((x0 + x1)/2, y1wrap,
+ (val[0][1] + val[1][1])/2 + myrand(step) - step/2);
+
+ set_midpoints(x0, (y0 + y1)/2,
+ (val[0][0] + val[0][1])/2 + myrand(step) - step/2);
+
+ set_midpoints(x1wrap, (y0 + y1)/2,
+ (val[1][0] + val[1][1])/2 + myrand(step) - step/2);
+
/* set middle to average of midpoints plus a random factor, if not set */
- if (hmap((x0 + x1)/2, (y0 + y1)/2) == 0) {
- hmap((x0 + x1)/2, (y0 + y1)/2) = (val[0][0] + val[0][1] + val[1][0]
- + val[1][1])/4 + myrand(step) - step/2;
- }
+ set_midpoints((x0 + x1)/2, (y0 + y1)/2,
+ (val[0][0] + val[0][1] + val[1][0]
+ + val[1][1])/4 + myrand(step) - step/2);
/* now call recursively on the four subrectangles */
gen5rec(2 * step / 3, x0, y0, (x1 + x0) / 2, (y1 + y0) / 2);
@@ -2115,8 +2303,8 @@
**************************************************************************/
static void mapgenerator5(void)
{
- const bool xnowrap = !topo_has_flag(TF_WRAPX);
- const bool ynowrap = !topo_has_flag(TF_WRAPY);
+ const bool xnowrap = XWRAP_TYPE_IS(WT_NONE);
+ const bool ynowrap = YWRAP_TYPE_IS(WT_NONE);
/*
* How many blocks should the x and y directions be divided into
@@ -2131,6 +2319,9 @@
int xmax = map.xsize - (xnowrap ? 1 : 0);
int ymax = map.ysize - (ynowrap ? 1 : 0);
int x, y, minval;
+ int map_x, map_y;
+ int T=0;
+
/* just need something > log(max(xsize, ysize)) for the recursion */
int step = map.xsize + map.ysize;
/* edges are avoided more strongly as this increases */
@@ -2146,34 +2337,22 @@
/* set initial points */
for (x = 0; x < xdiv2; x++) {
for (y = 0; y < ydiv2; y++) {
- hmap(x * xmax / xdiv, y * ymax / ydiv) = myrand(2*step) - (2*step)/2;
- }
- }
-
- /* if we aren't wrapping stay away from edges to some extent, try
- even harder to avoid the edges naturally if separatepoles is true */
- if (xnowrap) {
- for (y = 0; y < ydiv2; y++) {
- hmap(0, y * ymax / ydiv) -= avoidedge;
- hmap(xmax, y * ymax / ydiv) -= avoidedge;
- if (map.separatepoles && has_poles) {
- hmap(2, y * ymax / ydiv) = hmap(0, y * ymax / ydiv)
- - myrand(3*avoidedge);
- hmap(xmax - 2, y * ymax / ydiv)
- = hmap(xmax, y * ymax / ydiv) - myrand(3*avoidedge);
- }
- }
- }
-
- if (ynowrap) {
- for (x = 0; x < xdiv2; x++) {
- hmap(x * xmax / xdiv, 0) -= avoidedge;
- hmap(x * xmax / xdiv, ymax) -= avoidedge;
- if (map.separatepoles && has_poles) {
- hmap(x * xmax / xdiv, 2) = hmap(x * xmax / xdiv, 0)
- - myrand(3*avoidedge);
- hmap(x * xmax / xdiv, ymax - 2)
- = hmap(x * xmax / xdiv, ymax) - myrand(3*avoidedge);
+ native_to_map_pos(&map_x, &map_y, (x * xmax / xdiv), (y * ymax / ydiv));
+
+ /* set initial points */
+ hmap(x * xmax / xdiv, y * ymax / ydiv) = myrand(2*step) - (2*step)/2;/*
set initial points */
+
+ /* avoid edges (simplest topologicals singularities), and central
simetries singularities */
+ if (near_singularity(map_x,map_y))
+ hmap(x * xmax / xdiv, y * ymax / ydiv) -= avoidedge;
+
+ if ( has_poles ) {
+ T = map_clima(map_x,map_y);
+ if (T <= 8) {
+ hmap(x * xmax / xdiv, y * ymax / ydiv) -= myrand(avoidedge); /*
avoid too higth poles */
+ } else if (map.separatepoles && T <= 11 ) {
+ hmap(x * xmax / xdiv, y * ymax / ydiv) -= myrand(3*avoidedge); /*
separate poles */
+ }
}
}
}
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/server/mapgen.h
freeciv/server/mapgen.h
--- freeciv-cvs-Jan-04/server/mapgen.h 2003-08-29 07:08:58.000000000 +0200
+++ freeciv/server/mapgen.h 2004-01-06 18:31:21.000000000 +0100
@@ -16,5 +16,6 @@
void assign_continent_numbers(void);
void map_fractal_generate(void);
void create_start_positions(void);
+void assign_poles_numbers(void);
#endif /* FC__MAPGEN_H */
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/server/sanitycheck.c
freeciv/server/sanitycheck.c
--- freeciv-cvs-Jan-04/server/sanitycheck.c 2003-11-20 07:02:30.000000000
+0100
+++ freeciv/server/sanitycheck.c 2004-01-06 18:31:21.000000000 +0100
@@ -153,7 +153,7 @@
city_map_iterate(x, y) {
int map_x, map_y;
- if (city_map_to_map(&map_x, &map_y, pcity, x, y)) {
+ if (normal_city_map_to_map(&map_x, &map_y, pcity->x, pcity->y, x, y)) {
struct tile *ptile = map_get_tile(map_x, map_y);
struct player *owner = map_get_owner(map_x, map_y);
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/server/savegame.c
freeciv/server/savegame.c
--- freeciv-cvs-Jan-04/server/savegame.c 2003-12-07 07:08:48.000000000
+0100
+++ freeciv/server/savegame.c 2004-01-06 18:31:21.000000000 +0100
@@ -322,8 +322,8 @@
***************************************************************/
static void map_tiles_load(struct section_file *file)
{
- map.topology_id = secfile_lookup_int_default(file, MAP_ORIGINAL_TOPO,
- "map.topology_id");
+ map_init_topology(secfile_lookup_int_default(file, MAP_ORIGINAL_TOPO,
+ "map.topology_id"));
map.is_earth=secfile_lookup_bool(file, "map.is_earth");
@@ -1531,7 +1531,7 @@
assert(len > 0);
secfile_insert_int(file, len, "player%d.u%d.goto_length", plrno, i);
/* assumption about the chars per map position */
- assert(MAP_MAX_HEIGHT < 1000 && MAP_MAX_WIDTH < 1000);
+ assert(MAP_MAX_WIDTHandHEIGHT < 1000);
{
char *goto_buf = fc_malloc(4 * len + 1);
char *goto_buf_ptr = goto_buf;
diff -ruN -Xdiff_ignore freeciv-cvs-Jan-04/server/stdinhand.c
freeciv/server/stdinhand.c
--- freeciv-cvs-Jan-04/server/stdinhand.c 2003-11-29 07:05:37.000000000
+0100
+++ freeciv/server/stdinhand.c 2004-01-06 18:31:21.000000000 +0100
@@ -221,28 +221,79 @@
static struct settings_s settings[] = {
/* These should be grouped by sclass */
-
-/* Map size parameters: adjustable if we don't yet have a map */
+ GEN_INT("size", map.size, SSET_MAP_SIZE, SSET_TO_CLIENT,
+ N_("Map size in (2,000 tiles) units"),
+ N_("This value is used to determine xsize and ysize if > 0 \n"
+ " size = 0 xsize and ysize can set by hand, never use it!\n"
+ " size = 2 is a litle map of 4,000 tiles (default)\n"
+ " size = 10 is a Huge map of 20,000 tiles"), NULL,
+ MAP_MIN_SIZE,MAP_MAX_SIZE , MAP_DEFAULT_SIZE)
+
+ GEN_INT("ratio", map.ratio, SSET_MAP_SIZE, SSET_TO_CLIENT,
+ N_("Map ratio in (xratio:yratio) form"),
+ N_("This value is used to determine xsize and ysize \n"
+ "use 100 all the time!\n"
+ " 11 is 1:1 ratio, 21 is a 2:1 ratio. \n"
+ " 100 is the default ratio determined by the topology"), NULL,
+ MAP_MIN_RATIO, MAP_MAX_RATIO , MAP_DEFAULT_RATIO)
+
+/*Map size parameters: adjustable if we don't yet have a map and map.size=-1*/
GEN_INT("xsize", map.xsize, SSET_MAP_SIZE, SSET_TO_CLIENT,
- N_("Map width in squares"), "", NULL,
- MAP_MIN_WIDTH, MAP_MAX_WIDTH, MAP_DEFAULT_WIDTH)
+ N_("Map width in squares"),
+ N_("This value is modified when setting topology_id,ratio or size\n"
+ "use size instead it!"), NULL,
+ MAP_MIN_WIDTHandHEIGHT,MAP_MAX_WIDTHandHEIGHT , MAP_DEFAULT_WIDTH)
GEN_INT("ysize", map.ysize, SSET_MAP_SIZE, SSET_TO_CLIENT,
- N_("Map height in squares"), "", NULL,
- MAP_MIN_HEIGHT, MAP_MAX_HEIGHT, MAP_DEFAULT_HEIGHT)
-
+ N_("Map height in squares"),
+ N_("This value is modified when setting topology_id, ratio or size\n"
+ "use size instead it!"), NULL,
+ MAP_MIN_WIDTHandHEIGHT, MAP_MAX_WIDTHandHEIGHT, MAP_DEFAULT_HEIGHT)
+
+/* map.topology_id determine map.xwrap_type and map.ywrap_type
+ the best way to set it is a call to map_init_topology(id) or
+ a call map_init_topology(map.topology_id) to actualize xwrap_type
+ and ywrap_type */
GEN_INT("topology", map.topology_id, SSET_MAP_SIZE, SSET_TO_CLIENT,
N_("The map topology index"),
N_("Two-dimensional maps can wrap at the north-south or \n"
- "east-west edges, and use a cartesian or isometric \n"
- "rectangular grid. See the manual for further explanation.\n"
- " 0 Flat Earth (unwrapped) 4 Flat Earth (isometric)\n"
- " 1 Earth (wraps E-W) 5 Earth (isometric)\n"
- " 2 Uranus (wraps N-S) 6 Uranus (isometric)\n"
- " 3 Donut World (wraps N-S, E-W) 7 Donut World (isometric)"
+ "east-west edges or can use a nice quincuncial topology\n"
+ " and use a cartesian or isometric rectangular grid. \n"
+ "See the manual for further explanation.\n"
+ " Index (+16=Isometric map) : Name ( Wraps ) Notes \n"
+ " Cartographic topologies:\n"
+ " 0 (16) : Flat Map (unwrapped) Partial map\n"
+ " 1 (17) : Cylindrical Earth(wraps E-W) "
+ "Classic Civ2 global map\n"
+ " 2 (18) : Spherical Earth (wraps E-E N-N W-W S-S)"
+ "Best global map\n"
+ " ScFi topologies:\n"
+ " 3 (19) : Donut World (wraps N-S, E-W)\n"
+ " 4 (20) : Mobius Strip (wrap E-W, offset wrap N-S)\n"
+ " 5 (21) : Cyl. electron (wraps E-E W-W)\n"
+ " Variants for developpers usage only \n"
+ " 6 : TF_QUINCUNCIAL "
), NULL,
MAP_MIN_TOPO, MAP_MAX_TOPO, MAP_DEFAULT_TOPO)
-
+ GEN_INT("xwrap_type", map.xwrap_type, SSET_MAP_SIZE, SSET_TO_CLIENT,
+ N_("The map xwrap type"),
+ N_("This index determine the wrapx mode \n"
+ "determined by topology index \n"
+ " 0 Flat on x (unwrapped) \n"
+ " 1 Wrap on x (E-W) \n"
+ " 2 Wrap on x and reversed (E-E W-W) "
+ ), NULL,
+ 0, 2, 1)
+ GEN_INT("ywrap_type", map.ywrap_type, SSET_MAP_SIZE, SSET_TO_CLIENT,
+ N_("The map ywrap type"),
+ N_("This index determine the wrapy mode \n"
+ "determined by topology index \n"
+ " 0 Flat on y (unwrapped) \n"
+ " 1 Wrap on y (N-S) \n"
+ " 2 Wrap on y and reversed (N-N S-S) \n"
+ " 3 Wrap on y and offset (offset N-S)\n"
+ ), NULL,
+ 0, 3, 0)
/* Map generation parameters: once we have a map these are of historical
* interest only, and cannot be changed.
*/
@@ -3167,6 +3218,8 @@
}
if (do_update) {
+ /* update the topology parameters */
+ map_init_topology(map.topology_id);
/*
* send any modified game parameters to the clients -- if sent
* before RUN_GAME_STATE, triggers a popdown_races_dialog() call
- [Freeciv-Dev] Re: (PR#6721) Quincuncial and Mobius topologies ready!, Jason Short, 2004/01/04
- [Freeciv-Dev] Re: (PR#6721) A Quincuncial topology/ speed impact ?, Marcelo Burda, 2004/01/04
- [Freeciv-Dev] (PR#6721) A Quincuncial topology, Marcelo Burda, 2004/01/06
- [Freeciv-Dev] (PR#6721) A Quincuncial topology, Jason Short, 2004/01/06
- [Freeciv-Dev] Re: (PR#6721) A Quincuncial topology,
Marcelo Burda <=
- [Freeciv-Dev] Re: (PR#6721) A Quincuncial topology, Jason Short, 2004/01/07
- [Freeciv-Dev] Re: (PR#6721) A Quincuncial topology, Marcelo Burda, 2004/01/08
- [Freeciv-Dev] (PR#6721) extended topologies base concept, Marcelo Burda, 2004/01/08
- [Freeciv-Dev] Re: (PR#6721) extended topologies base concept, imbaczek@xxxxxxxxxxxxxx, 2004/01/08
- [Freeciv-Dev] Re: (PR#6721) A Quincuncial topology, Jason Short, 2004/01/08
- [Freeciv-Dev] Re: (PR#6721) A Quincuncial topology, Marcelo Burda, 2004/01/08
- [Freeciv-Dev] Re: (PR#6721) A Quincuncial topology, Jason Short, 2004/01/08
- [Freeciv-Dev] Re: (PR#6721) A Quincuncial topology, Marcelo Burda, 2004/01/08
- [Freeciv-Dev] (PR#6721) A Quincuncial topology, Marcelo Burda, 2004/01/08
- [Freeciv-Dev] (PR#6721) First Goal, Marcelo Burda, 2004/01/08
|
|
