static int draw_city(game_t * game)
{
int i;
int x,y;
int num_item;
int size_pic;
llist_t * cur_list;
city_t * cur_city;
if( item_city != NULL ) {
free(item_city);
}
item_city = NULL;
num_item = 0;
for(i=0; i<game->opponent_num+1; i++) {
cur_list = game->wiz[i].city;
while(cur_list!=NULL ) {
cur_city = (city_t*)cur_list->data;
if(cur_city->side != cur_side) {
cur_list = cur_list->next;
continue;
}
item_city = (item_t*)realloc(item_city,sizeof(item_t)*(num_item+1));
x = get_tile_coord_x(cur_city->x, game);
y = get_tile_coord_y(cur_city->y, game);
/* City picture are larger than tiles picture */
x -= (back[CITY_NOWALL].w - TILE_SIZE_W)/2;
y -= (back[CITY_NOWALL].h - TILE_SIZE_H)/2;
item_init(&item_city[num_item]);
size_pic = cur_city->population/10000;
if(size_pic > 5 ) {
size_pic = 5;
}
item_set_frame(&item_city[num_item],x,y+1,
&back[CITY_NOWALL]);
item_set_frame_normal(&item_city[num_item],size_pic);
item_set_click_right(&item_city[num_item],cb_city_screen,cur_city);
num_item++;
cur_list = cur_list->next;
}
}
return num_item;
}
/**********************************
Set sdl_item item for mouse button callback
**********************************/
static void compose_map_button(context_t * ctx)
{
int x = 0;
int y = 0;
item_t * item;
anim_t * anim = NULL;
if ( option && option->cursor_over_tile ) {
anim = imageDB_get_anim(ctx,option->cursor_over_tile);
}
for( y=0 ; y < default_layer->map_h ; y++ ) {
for ( x=0 ; x < default_layer->map_w ; x++ ) {
item = item_list_add(&item_list);
item_set_anim_shape(item,map_t2p_x(x,y,default_layer),map_t2p_y(x,y,default_layer),default_layer->tile_width,default_layer->tile_height);
item_set_user(item,x,y);
item_set_click_left(item,cb_select_map,item,NULL);
item_set_click_right(item,cb_redo_map,item,NULL);
item_set_over(item,cb_over,item,NULL);
item_set_anim_over(item,anim,0);
}
}
}
static int draw_tile(game_t * game)
{
int tile_x,tile_y;
int index;
item_t * item_cur;
int num_tile_w = ORIGINAL_GAME_WIDTH/TILE_SIZE_W ;
int num_tile_h = ORIGINAL_GAME_HEIGHT/TILE_SIZE_H +2 ;
int x,y;
int count_w;
int count_h;
int tile_index;
if( item_tile == NULL ) {
item_tile = (item_t*)malloc(sizeof(item_t)*game->map->width*game->map->height);
}
index=0;
for( count_w = -num_tile_w/2; count_w < num_tile_w/2; count_w ++) {
for( count_h=(-num_tile_h/2); count_h<num_tile_h/2; count_h++) {
tile_y=cur_tile_y+count_h;
if(tile_y < 0 || tile_y >= game->map->height) {
continue;
}
tile_x=(cur_tile_x+game->map->width+count_w)%game->map->width;
item_cur = &item_tile[index];
item_init(item_cur);
x=orig_x+(count_w*TILE_SIZE_W);
y=orig_y+(count_h*TILE_SIZE_H);
tile_index=game->map->side[cur_side].tile[tile_x][tile_y];
item_set_anim(item_cur,x,y,&tile[tile_index]);
item_set_click_right(item_cur,cb_move_map,(void*)(((intptr_t)tile_x<<16)+(intptr_t)tile_y));
index++;
}
}
return index;
}
/**********************************
Draw a single sprite
if image_file_name is not NULL, this file is used as an image rather than the normal sprite image
**********************************/
static void set_up_sprite(context_t * ctx, const char * image_file_name)
{
anim_t ** sprite_list;
anim_t ** sprite_move_list;
item_t * item;
int px;
int py;
int opx;
int opy;
Uint32 current_time;
int angle;
int flip;
int force_flip;
int move_status;
char * zoom_str = NULL;
double zoom = 1.0;
int sprite_align = ALIGN_CENTER;
int sprite_offset_y = 0;
bool force_position = false;
context_t * player_context = context_get_player();
if( ctx->map == NULL ) {
return;
}
if( ctx->in_game == false ) {
return;
}
if( strcmp(ctx->map,player_context->map)) {
return;
}
item = item_list_add(&item_list);
current_time = sdl_get_global_time();
// Force position when the player has changed map
if( change_map == true ) {
ctx->move_start_tick = current_time;
ctx->animation_tick = current_time;
force_position = true;
}
// Force position when this context has changed map
if( ctx->change_map == true ) {
ctx->move_start_tick = current_time;
ctx->animation_tick = current_time;
ctx->change_map = false;
force_position = true;
}
if( ctx->animation_tick == 0 ) {
ctx->animation_tick = current_time;
}
if( ctx->cur_pos_px == INT_MAX || ctx->cur_pos_py == INT_MAX ) {
force_position = true;
}
// Detect sprite movement, initiate animation
if( ctx->pos_changed && force_position == false ) {
ctx->pos_changed = false;
ctx->move_start_tick = current_time;
ctx->start_pos_px = ctx->cur_pos_px;
ctx->start_pos_py = ctx->cur_pos_py;
/* flip need to remember previous direction to avoid resetting a
east -> west flip when a sprite goes to north for instance.
On the contrary rotation must not remember previous state, or
the rotation will be wrong.
Hence the distinction between orientation (no memory) and
direction (memory). */
ctx->orientation = 0;
// Compute direction
if( ctx->pos_tx > ctx->prev_pos_tx ) {
ctx->direction &= ~WEST;
ctx->direction |= EAST;
ctx->orientation |= EAST;
}
if( ctx->pos_tx < ctx->prev_pos_tx ) {
ctx->direction &= ~EAST;
ctx->direction |= WEST;
ctx->orientation |= WEST;
}
if( ctx->pos_ty > ctx->prev_pos_ty ) {
ctx->direction &= ~NORTH;
ctx->direction |= SOUTH;
ctx->orientation |= SOUTH;
}
if( ctx->pos_ty < ctx->prev_pos_ty ) {
ctx->direction &= ~SOUTH;
ctx->direction |= NORTH;
ctx->orientation |= NORTH;
}
}
// Select sprite to display
sprite_list = select_sprite(ctx,image_file_name);
if( sprite_list == NULL ) {
return;
}
if( sprite_list[0] == NULL ) {
free(sprite_list);
return;
}
sprite_move_list = select_sprite_move(ctx,image_file_name);
// Get position in pixel
px = map_t2p_x(ctx->pos_tx,ctx->pos_ty,default_layer);
py = map_t2p_y(ctx->pos_tx,ctx->pos_ty,default_layer);
// Get per sprite zoom
if(entry_read_string(CHARACTER_TABLE,ctx->id,&zoom_str,CHARACTER_KEY_ZOOM,NULL) == RET_OK ) {
zoom = atof(zoom_str);
free(zoom_str);
}
// Align sprite on tile
entry_read_int(CHARACTER_TABLE,ctx->id,&sprite_align,CHARACTER_KEY_ALIGN,NULL);
if( sprite_align == ALIGN_CENTER ) {
px -= ((sprite_list[0]->w*default_layer->map_zoom*zoom)-default_layer->tile_width)/2;
py -= ((sprite_list[0]->h*default_layer->map_zoom*zoom)-default_layer->tile_height)/2;
}
if( sprite_align == ALIGN_LOWER ) {
px -= ((sprite_list[0]->w*default_layer->map_zoom*zoom)-default_layer->tile_width)/2;
py -= (sprite_list[0]->h*default_layer->map_zoom*zoom)-default_layer->tile_height ;
}
// Add Y offset
entry_read_int(CHARACTER_TABLE,ctx->id,&sprite_offset_y,CHARACTER_KEY_OFFSET_Y,NULL);
py += sprite_offset_y;
// Set sprite to item
item_set_anim_start_tick(item,ctx->animation_tick);
if( force_position == true ) {
ctx->start_pos_px = px;
ctx->cur_pos_px = px;
ctx->start_pos_py = py;
ctx->cur_pos_py = py;
}
opx = ctx->start_pos_px;
opy = ctx->start_pos_py;
item_set_move(item,opx,opy,px,py,ctx->move_start_tick,VIRTUAL_ANIM_DURATION);
item_set_save_coordinate(item,&ctx->cur_pos_px,&ctx->cur_pos_py);
item_set_anim_array(item,sprite_list);
free(sprite_list);
item_set_anim_move_array(item,sprite_move_list);
free(sprite_move_list);
// Get rotation configuration
angle = 0;
if( ctx->orientation & NORTH && ctx->orientation & EAST ) {
entry_read_int(CHARACTER_TABLE,ctx->id,&angle,CHARACTER_KEY_DIR_NE_ROT,NULL);
item_set_angle(item,(double)angle);
} else if ( ctx->orientation & SOUTH && ctx->orientation & EAST ) {
entry_read_int(CHARACTER_TABLE,ctx->id,&angle,CHARACTER_KEY_DIR_SE_ROT,NULL);
item_set_angle(item,(double)angle);
} else if ( ctx->orientation & SOUTH && ctx->orientation & WEST ) {
entry_read_int(CHARACTER_TABLE,ctx->id,&angle,CHARACTER_KEY_DIR_SW_ROT,NULL);
item_set_angle(item,(double)angle);
} else if ( ctx->orientation & NORTH && ctx->orientation & WEST ) {
entry_read_int(CHARACTER_TABLE,ctx->id,&angle,CHARACTER_KEY_DIR_NW_ROT,NULL);
item_set_angle(item,(double)angle);
} else if ( ctx->orientation & NORTH ) {
entry_read_int(CHARACTER_TABLE,ctx->id,&angle,CHARACTER_KEY_DIR_N_ROT,NULL);
item_set_angle(item,(double)angle);
} else if ( ctx->orientation & SOUTH ) {
entry_read_int(CHARACTER_TABLE,ctx->id,&angle,CHARACTER_KEY_DIR_S_ROT,NULL);
item_set_angle(item,(double)angle);
} else if ( ctx->orientation & WEST ) {
entry_read_int(CHARACTER_TABLE,ctx->id,&angle,CHARACTER_KEY_DIR_W_ROT,NULL);
item_set_angle(item,(double)angle);
} else if ( ctx->orientation & EAST ) {
entry_read_int(CHARACTER_TABLE,ctx->id,&angle,CHARACTER_KEY_DIR_E_ROT,NULL);
item_set_angle(item,(double)angle);
}
// Get flip configuration
force_flip = 0;
entry_read_int(CHARACTER_TABLE,ctx->id,&force_flip,CHARACTER_KEY_FORCE_FLIP,NULL);
move_status = ctx->direction;
if( force_flip == true ) {
move_status = ctx->orientation;
}
flip = 0;
if( angle == 0 ) {
if( move_status & NORTH ) {
entry_read_int(CHARACTER_TABLE,ctx->id,&flip,CHARACTER_KEY_DIR_N_FLIP,NULL);
}
if( move_status & SOUTH ) {
entry_read_int(CHARACTER_TABLE,ctx->id,&flip,CHARACTER_KEY_DIR_S_FLIP,NULL);
}
if( move_status & WEST ) {
entry_read_int(CHARACTER_TABLE,ctx->id,&flip,CHARACTER_KEY_DIR_W_FLIP,NULL);
}
if( move_status & EAST ) {
entry_read_int(CHARACTER_TABLE,ctx->id,&flip,CHARACTER_KEY_DIR_E_FLIP,NULL);
}
switch(flip) {
case 1:
item_set_flip(item,SDL_FLIP_HORIZONTAL);
break;
case 2:
item_set_flip(item,SDL_FLIP_VERTICAL);
break;
case 3:
item_set_flip(item,SDL_FLIP_HORIZONTAL|SDL_FLIP_VERTICAL);
break;
default:
item_set_flip(item,SDL_FLIP_NONE);
}
}
item_set_click_left(item,cb_select_sprite,ctx->id,NULL);
item_set_click_right(item,cb_redo_sprite,item,NULL);
item_set_zoom_x(item,zoom * default_layer->map_zoom );
item_set_zoom_y(item,zoom * default_layer->map_zoom );
}
