/**********************************  cities.c  ************************/
#include <stdio.h>
#include "sdi.h"
#include "sdi_color.h"

/*
 * Copyright 1987 by Mark Weiser.
 * Permission to reproduce and use in any manner whatsoever on Suns is granted
 * so long as this copyright and other identifying marks of authorship
 * in the code and the game remain intact and visible.  Use of this code
 * in other products is reserved to me--I'm working on Mac and IBM versions.
 */

/*
 * Code to do things to cities.  Much of the code here consists of
 * passing a routine into doto_cities, which then calls that routine
 * on each city.  See the comment for doto_cities (near the end of the file)
 * for more information.
 */

/* flags for doto_cities */
#define TYPE_CITY 0x1
#define TYPE_NONCITY 0x2

static short default_city_data_1[] = {
#include "default_city.h"
};
mpr_static(default_city_pr_1, 64, 64, 1, default_city_data_1);

struct pixrect *default_city_pr = &default_city_pr_1;

static short melted_city_data[] = {
#include "melt.h"
};
mpr_static(melted_city_pr, 64, 64, 1, melted_city_data);

#define MIN_SPACE 4
#define MAX_CITIES 40

static int city_space, excess, global_count;
static long bits_in_city;

static int do_update(), do_count(), do_placement(), do_kill(), 
	   do_update_all(), do_grow(), do_update_cities(), do_melt_all(); 

static int cities_inited = 0;
static short cities[MAX_CITIES];


static int growcount;	/* ugh, another weird global.
						 * set by do_update_cities, used only by 'do_grow'.
						 */

/*
 * Read a new city pixrect from a file.
 */
init_city_bits(filename)
char *filename;
{
	/* this routine is only called if there is non-default city. */
	if (filename != NULL) {
			char error_msg[256];
			struct pixrect *tmp,*icon_load_mpr();
			if ((tmp = icon_load_mpr(filename, error_msg)) == NULL) {
				printf("Could not get pr '%s'.\n", filename);
				printf("%s",error_msg);
				printf("Using default cities.\n");
			} else {
			    city_pw = xv_create(NULL, SERVER_IMAGE, 
						XV_HEIGHT, 64,
						XV_WIDTH, 64,
						SERVER_IMAGE_DEPTH, SDI_COLOR_DEPTH,
						NULL);
			    if (use_color) xv_set(city_pw,
						  SERVER_IMAGE_COLORMAP, sdi_colormap_name,
						  NULL);
			    xv_rop(city_pw, 0, 0, 64, 64, PIX_SRC, tmp, 0, 0);
			}
	}
}

/*
 * Compute the positions of all the cities based on current screen size,
 * and declare all the cities to be unmelted.
 */
init_cities()
{
	int i, old_num_cities = num_cities;
	
	city_pw = xv_create(NULL, SERVER_IMAGE, 
			    XV_HEIGHT, 64,
			    XV_WIDTH, 64,
			    SERVER_IMAGE_DEPTH, SDI_COLOR_DEPTH,
			    NULL);
	if (use_color) xv_set(city_pw,
			      SERVER_IMAGE_COLORMAP, sdi_colormap_name,
			      NULL);
	xv_rop(city_pw, 0, 0, 64, 64, PIX_SRC | PIX_COLOR(CITY_BASE), &default_city_pr_1, 0, 0);
	bits_in_city = xv_count_pixels(city_pw, CITY_BASE);
	melted_city_pw = xv_create(NULL, SERVER_IMAGE, 
				   XV_HEIGHT, 64,
				   XV_WIDTH, 64,
				   SERVER_IMAGE_DEPTH, SDI_COLOR_DEPTH,
				   NULL);
	if (use_color) xv_set(melted_city_pw,
			      SERVER_IMAGE_COLORMAP, sdi_colormap_name,
			      NULL);
	xv_rop(melted_city_pw, 0, 0, 64, 64, PIX_SRC | PIX_COLOR(CITY_MELTED), &melted_city_pr, 0, 0);
	tmpcity_pw = xv_create(NULL, SERVER_IMAGE, 
				XV_HEIGHT, 64,
				XV_WIDTH, 64,
				SERVER_IMAGE_DEPTH, SDI_COLOR_DEPTH,
				NULL);
	if (use_color) xv_set(tmpcity_pw,
			      SERVER_IMAGE_COLORMAP, sdi_colormap_name,
			      NULL);
	num_cities = ((max_x - MARGIN)/64) + 1;	/* bigger than possible */
	city_space = 0;

	while (city_space < MIN_SPACE) {
		num_cities -= 1;
		city_space = ((max_x - MARGIN) - (num_cities * 64))/(num_cities-1);
	};
	
	excess = max_x - (MARGIN + 64*num_cities + city_space*(num_cities-1));
	for (i=old_num_cities; i<num_cities; i++) {
		cities[i] = TYPE_CITY;
	}	
	cities_inited = 1;
}

/*
 * display the cities, melted or otherwise.
 */
place_cities(pw)
Pixwin *pw;
{
	pw_writebackground(pw, 0, max_y-8, max_x, max_y, PIX_SRC | PIX_COLOR(BACKGROUND));
	doto_cities(pw, do_placement, city_pw, TYPE_CITY);
	doto_cities(pw, do_placement, melted_city_pw, TYPE_NONCITY);
}

/* helper for 'place_cities', passed into 'doto_cities' */
static int
do_placement(pr, city_pr)
struct pixrect *pr, *city_pr;
{
    xv_rop(pr, 0, 0, 64, 64, PIX_SRC, city_pr, 0, 0);
    return 1;	/* this forces the new city back into the pixwin */
}

/*
 * Pop a new city onto the display at a random empty position.
 */
new_city(pw)
Pixwin *pw;
{
	int pick, num_gone = 0, i;
	for (i=0; i < num_cities; i += 1) {
		if (cities[i] & TYPE_NONCITY)
			num_gone += 1;
	}
	if (num_gone == 0)
		return;
	pick = (random() % num_gone) + 1;
	for (i=0; i < num_cities; i += 1) {
		if ((cities[i] & TYPE_NONCITY) && !--pick)
			break;
	}
	/* restore a random melted city */
	cities[i] = TYPE_CITY;
	do_update_cities(pw, city_grow_speed, do_grow);
}

/* helper for do_update_cites, grow a city. */
static int
do_grow(pr, speed)
struct pixrect *pr;
{
	grow(pr, city_pw, growcount+16);
	return 1;
}

/* return how many died */
static int global_citycount;
compute_cities(pw)
Pixwin *pw;
{
	global_citycount = 0;
	doto_cities(pw, do_count, 0, TYPE_CITY);
	return global_citycount;
}

/* helper for 'compute_cities', passed into 'doto_cities' */
static int
do_count(pr, client)
struct pixrect *pr;
int *client;
{
	if (city_dead(pr)) {
		global_citycount += 1;
	}
	return 0;	/* avoids pw_write in doto_cities */
}

/*
 * Melt or grow each city, as appropriate.
 */
update_cities(pw, speed)
{
	doto_cities(pw, do_kill, 0, TYPE_CITY);
	do_update_cities(pw, speed, do_update);
}

/*
 * Call function 'helper' numerous times on each city, thus causing
 * growing or melting (or both), depending upon 'helper'.
 */
static int
do_update_cities(pw, speed, helper)
int (*helper)();
{
	int count = 64;
	for (growcount = 1; growcount < count; growcount += speed) {
		/* we might plausibly batch here, but the melt looks better without */
		doto_cities(pw, helper, speed, TYPE_CITY | TYPE_NONCITY);
	}
}

/* helper for 'update_cities', passed to 'do_update_cities', grows or melts. */
static int
do_update(pr, speed)
struct pixrect *pr;
int speed;
{
    if (cities[global_count] & TYPE_NONCITY) {
	melt(pr, melted_city_pw, growcount);
	return 1;	
    } else {
	grow(pr, city_pw, growcount+16);
	return 1;   
    }
}

/* Helper for 'update_cities', passed into doto_cities, computes dead cities. */
static int
do_kill(pr, tmp)
struct pixrect *pr;
{
	if (city_dead(pr))
		cities[global_count] = TYPE_NONCITY;
	return 0;
}

/* Do what it says. */
melt_all_cities(pw, speed)
{
	do_update_cities(pw, speed, do_melt_all);
}


/* helper for 'melt_all_cities', passed into 'do_update_cities' */
static int
do_melt_all(pr, speed)
struct pixrect *pr;
int speed;
{
	melt(pr, melted_city_pw, speed);
	return 1;	/* forces writing out the melted city in doto_cities */
}

/*
   To do something to all
   cities, pass a function and a piece of client data to 'doto_cities',
   and the function will be called once for each city still matching
   the 'which_cities' flags.
   The calling sequence for the passed in
   function will be:
		func(pr, client_data);
   where 'pr' is a 64x64 pixrect of a city.  If 'func' returns 0 then
   'pr' is assumed to be unchanged, otherwise 'pr' is written back into
   the pixwin so the change is visible. Global_count is set before the
   call to the ordinal number of the city currently being operated on.

   Init_cities must be called before any city operations.
 */


doto_cities(pw, func, client_data, which_cities)
Pixwin *pw;
int (*func)();
int *client_data;
{
	int x = MARGIN/2 + excess/2, stop_x = max_x - MARGIN/2 - 64;
	int y = max_y - 64;
	if (! cities_inited) {
		/* no return from here */
		printf("'doto_cities called before 'init_cities'.\n"); fflush(stdout);
		abort();
	}
	global_count = 0;
	while (x <= stop_x) {
	    if (which_cities & cities[global_count]) {
		xv_rop(tmpcity_pw, 0, 0, 64, 64, PIX_SRC, pw, x, y);
		if (func(tmpcity_pw, client_data))
		    xv_rop(pw, x, y, 64, 64, PIX_SRC, tmpcity_pw, 0, 0);
	    }
	    global_count += 1;
	    x += 64 + city_space;
	}
}

/*
 * See if a city is dead.  It is if 2/3's of its pixels are clobbered.
 */
city_dead(pw)
Xv_Window pw;
{
	long bitcount = xv_count_pixels(pw, CITY_BASE);
	if (bitcount < 2*bits_in_city/3)
		return 1;
	else return 0;
}