piece.cpp

// Piece (.Cpp)
// ------------

#include <ptk.h>
#include <vector>
#include <list>
#include "KPTK.h"

using namespace std;

#include "bridge.hpp"
#include "game.hpp"
#include "scene.hpp"
#include "piece.hpp"
#include "board.hpp"
#include "log.hpp"
#include "timer.hpp"
#include "config.hpp"
#include "wizard.hpp"
#include "effect.hpp"
#include "chat.hpp"
#include "options.hpp"
#include "sound.hpp"

struct piece_data piece[MAX_PIECES];

void load_all_pieces(void)
{
	int frames, gfx, piece_num;
	char file[MAX_STRING], text[MAX_STRING], name[MAX_STRING], section[MAX_STRING];

	sprintf(section, "GROOVE");

	piece_num = 0;
	gfx = 0;

	// First we look at the info file to find all the piece names to load..
	sprintf(text, "Pieces\\info.ini");
	sprintf(file, "%s", KMiscTools::makeFilePath(text));

	if (!set_config_file_new(CONFIG_TEMP, file, true)) return;

	// Find all piece names to load from info file
	for (piece_num = 0 ; piece_num < MAX_PIECES ; piece_num++)
	{
		sprintf(text, "PIECE_%d", piece_num);
		GetConfigString(CONFIG_TEMP, section, text, piece[piece_num].name, 40);
	}

	// Now we load each one individually (gfx & stats).
	for (piece_num = 0 ; piece_num < MAX_PIECES ; piece_num++)
	{
		if (strlen(piece[piece_num].name) < 2) return; // Reached end of list.

		sprintf(section, "GROOVE");

		sprintf(text, "Pieces\\%s\\%s\\", piece[piece_num].name, section );
		sprintf(file, "%s", KMiscTools::makeFilePath(text));
		frames = LoadAndAddBitmaps(&piece_gfx, file, "png");

		sprintf(text, "Pieces\\%s\\info.ini", piece[piece_num].name);
		sprintf(file, "%s", KMiscTools::makeFilePath(text));

		if (!set_config_file_new(CONFIG_TEMP, file, true)) return;

		// GROUP NAME
		GetConfigString(CONFIG_TEMP, section, "GROUP", piece[piece_num].group_name, 40);
		if (strlen(piece[piece_num].group_name) == 0) sprintf(piece[piece_num].group_name, "CREATURE_GROUP"); // Creature Group is default.

		piece[piece_num].adjacent_in_group = GetConfigYes(CONFIG_TEMP, section, "ADJACENT_IN_GROUP", true);

		// TIME BETWEEN FRAMES, keeping a updated and original copy here.
		piece[piece_num].time_between_frames = GetConfigInt(CONFIG_TEMP, section, "TIME_BETWEEN_FRAMES", 100);
		piece[piece_num].time_next_frame = GetConfigInt(CONFIG_TEMP, section, "TIME_BETWEEN_FRAMES", 100);

		// PING PONG ANIM, the default is a ping pong anim, but we can also use a plain loop.
		piece[piece_num].ping_pong_anim = GetConfigYes(CONFIG_TEMP, section, "PING_PONG_ANIM", true);
		piece[piece_num].ping_pong_anim_forward = true;

		piece[piece_num].start_gfx = gfx;
		piece[piece_num].gfx = gfx;
		gfx += frames;

		// BODY_GFX, default = last gfx frame is the body gfx. 0 = No Body gfx frame.
		piece[piece_num].body_gfx = -1;
		if (GetConfigInt(CONFIG_TEMP, section, "BODY_GFX", -1) != 0)
		{
			piece[piece_num].body_gfx = gfx - 1;
			frames--;
		}
		piece[piece_num].gfx_frames = frames;

		// ----- Special Stats -----
		piece[piece_num].chance_of_disappearing = GetConfigInt(CONFIG_TEMP, section, "CHANCE_OF_DISAPPEARING", 0);
		piece[piece_num].spells_when_disappeared = GetConfigInt(CONFIG_TEMP, section, "SPELLS_WHEN_DISAPPEARED", 0);
		piece[piece_num].only_disappear_when_ridden = GetConfigYes(CONFIG_TEMP, section, "ONLY_DISAPPEAR_WHEN_RIDDEN", false);

		piece[piece_num].any_wizard_can_ride = GetConfigYes(CONFIG_TEMP, section, "ANY_WIZARD_CAN_RIDE", false);

		// Growing
		piece[piece_num].grow_chance = GetConfigInt(CONFIG_TEMP, section, "GROW_CHANCE", 0);
		piece[piece_num].grow_attack = GetConfigInt(CONFIG_TEMP, section, "GROW_ATTACK", 0);
		piece[piece_num].grow_die_chance = GetConfigInt(CONFIG_TEMP, section, "GROW_DIE_CHANCE", 0);
		GetConfigString(CONFIG_TEMP, section, "GROW_PIECE", piece[piece_num].grow_piece_name, 40);
		piece[piece_num].grow_covers = GetConfigYes(CONFIG_TEMP, section, "GROW_COVERS", false);

		GetConfigString(CONFIG_TEMP, section, "DISAPPEAR_EFFECT", text, MAX_STRING);
		piece[piece_num].disappear_effect = find_effect_by_name(text, EFFECT_NONE);
		piece[piece_num].disappear_effect_var1 = GetConfigInt(CONFIG_TEMP, section, "DISAPPEAR_EFFECT_VAR1", 0);

		// Ranged combat effect..
		GetConfigString(CONFIG_TEMP, section, "RANGED_COMBAT_EFFECT", text, MAX_STRING);
		piece[piece_num].ranged_combat_effect = find_effect_by_name(text, EFFECT_ATTACK);
		piece[piece_num].ranged_combat_effect_var1 = GetConfigInt(CONFIG_TEMP, section, "RANGED_COMBAT_EFFECT_VAR1", 1);

		// ----- Normal Stats -----

		// COMBAT
		piece[piece_num].combat = GetConfigInt(CONFIG_TEMP, section, "COMBAT", 1);

		// DEFENCE
		piece[piece_num].defence = GetConfigInt(CONFIG_TEMP, section, "DEFENCE", 1);

		// RANGED_COMBAT
		piece[piece_num].ranged_combat_attack = GetConfigInt(CONFIG_TEMP, section, "RANGED_COMBAT", 0);

		// RANGE
		piece[piece_num].ranged_combat_range = GetConfigInt(CONFIG_TEMP, section, "RANGE", 0);

		// RANGED_COMBAT GFX
		piece[piece_num].ranged_combat_gfx = GetConfigInt(CONFIG_TEMP, section, "RANGED_COMBAT_GFX", 20);

		// MOVEMENT
		piece[piece_num].movement = GetConfigInt(CONFIG_TEMP, section, "MOVEMENT", 1);

		// FLEX, I use the word flex (short for flexability) as maneuverability is difficult
		// to spell and type!
		piece[piece_num].flex = GetConfigInt(CONFIG_TEMP, section, "FLEX", 1);  

		// MAGIC_RESISTANCE
		piece[piece_num].magic_resist = GetConfigInt(CONFIG_TEMP, section, "MAGIC_RESISTANCE", 1);  

		// CHANCE
		piece[piece_num].chance = GetConfigInt(CONFIG_TEMP, section, "CHANCE", 100);    

		// FLYING
		piece[piece_num].flying = GetConfigYes(CONFIG_TEMP, section, "FLYING", false);

		// RIDEABLE
		piece[piece_num].rideable = GetConfigYes(CONFIG_TEMP, section, "RIDEABLE", false);

		// UNDEAD
		piece[piece_num].undead = GetConfigYes(CONFIG_TEMP, section, "UNDEAD", false);
		piece[piece_num].can_attack_undead = GetConfigYes(CONFIG_TEMP, section, "CAN_ATTACK_UNDEAD", piece[piece_num].undead);    

		// CAN_RIDE
		piece[piece_num].can_ride = GetConfigYes(CONFIG_TEMP, section, "CAN_RIDE", false);

		// SHADOW_FORM
		piece[piece_num].shadow_form = GetConfigYes(CONFIG_TEMP, section, "SHADOW_FORM", false);

		// TRANSPARENT_TO_LINE_OF_SIGHT
		piece[piece_num].transparent_to_line_of_sight = GetConfigYes(CONFIG_TEMP, section, "TRANSPARENT_TO_LINE_OF_SIGHT", false);

		if (piece[piece_num].combat < 1) piece[piece_num].has_attacked = true;
		if (piece[piece_num].ranged_combat_attack < 1) piece[piece_num].has_shot = true;
		if (piece[piece_num].movement < 1) piece[piece_num].has_moved = true;

		piece[piece_num].engaged = false;
	}
}

void do_pieces_animation_logic(void)
{
	// This goes through every piece on the board and updates animation details.
	// Decreasing timing values and moving to next animation frame if required.

	int x, y, end_frame, time_between_frames;

	for (y = 0 ; y < board_info.board_height ; y++)
	{
		for (x = 0 ; x < board_info.board_width ; x++)
		{
			// Skip BLANK pieces.
			if (board[x][y][PIECE].gfx == BLANK) continue;

			end_frame = board[x][y][PIECE].start_gfx + board[x][y][PIECE].gfx_frames;
			time_between_frames = board[x][y][PIECE].time_between_frames;

			// Does piece have shadow form? This alters our animation!
			if (board[x][y][PIECE].shadow_form)
			{
				end_frame = board[x][y][PIECE].start_gfx + 2; // 2 frames for shadow form.
				time_between_frames = 200; // One constant speed. 
			}

			board[x][y][PIECE].time_next_frame--;

			// Time to change frame.
			if (board[x][y][PIECE].time_next_frame < 1)
			{
				// Restore timer value to original copy.
				board[x][y][PIECE].time_next_frame = time_between_frames;

				if (board[x][y][PIECE].ping_pong_anim == false)
				{
					// Looping Animation
					board[x][y][PIECE].gfx++;

					// If we have just gone past the end gfx, then reset to the start.
					if (board[x][y][PIECE].gfx >= end_frame)
					{
						board[x][y][PIECE].gfx = board[x][y][PIECE].start_gfx;
					}
				}
				else
				{
					// Ping-Pong Animation
					if (board[x][y][PIECE].ping_pong_anim_forward == true)
					{
						// Animating Forward.
						board[x][y][PIECE].gfx++;

						// Gone past end, reverse animation direction.
						if (board[x][y][PIECE].gfx >= end_frame - 1)
						{
							board[x][y][PIECE].gfx = end_frame - 1;
							board[x][y][PIECE].ping_pong_anim_forward = false; // Reverse direction.
						}   
					}
					else
					{
						// Animating Backwards.
						board[x][y][PIECE].gfx--;

						// Gone past start, reverse animation direction.
						if (board[x][y][PIECE].gfx <= board[x][y][PIECE].start_gfx)
						{
							board[x][y][PIECE].gfx = board[x][y][PIECE].start_gfx;
							board[x][y][PIECE].ping_pong_anim_forward = true; // Reverse direction.
						}   
					}

				}

			}

		}
	}    
}


int find_piece_by_name(char *name)
{
	int s;

	for (s = 0 ; s < MAX_PIECES ; s++)
	{
		if (strcmp(name, piece[s].name) == 0) return s;
	}

	return -1;
}

void create_new_piece(char *name, int x, int y)
{
	// Creates a new piece and uses the name field to search for the corresponding
	// piece ID. This stops us using hardcoded varients (i.e. for magic sword, etc..)
	// and makes things more flexible.

	int p;
	p = find_piece_by_name(name);

	if (p == -1)
	{
		// Assume this doesn't matter, and is changed later. Pick Dire wolf as a default..
		p = find_piece_by_name("dire_wolf");
	}

	board[x][y][PIECE] = piece[p];
	board[x][y][PIECE].selected = false;
	board[x][y][PIECE].dead = false;
	board[x][y][PIECE].disbelieved = false;
	board[x][y][PIECE].illusion = wizard[game.current_wizard].spell_is_illusion;
	board[x][y][PIECE].owner = game.current_wizard; // Mark current wizard as owner. 
	board[x][y][PIECE].turn = 0; // New piece, so rest turn value.
}

void kill_piece(int x, int y, int by, bool sound)
{
	int p;

	// Have we just killed a wizard?
	if (board[x][y][MOUNTED].gfx == BLANK)
	{
		// No rider. Check if we have just killed a wizard..
		if (wizard_here(x, y) != -1)
		{
			kill_wizard(wizard_here(x, y), by);
		}
		else
		{
			if (sound) request_sound_effect(board[x][y][PIECE].name, "CREATURE", "DIES", false);
		}
	}
	else
	{
		if (sound) request_sound_effect(board[x][y][MOUNTED].name, "CREATURE", "DIES", false);
	}

	// If creature has a body gfx then deal with that now.
	if (board[x][y][PIECE].body_gfx != -1 && !board[x][y][PIECE].illusion)
	{
		// Move piece to body layer.
		board[x][y][BODY] = board[x][y][PIECE];

		// Now change gfx to body gfx and stop animation.
		board[x][y][BODY].gfx = board[x][y][BODY].body_gfx;

		board[x][y][BODY].start_gfx = board[x][y][BODY].body_gfx;
		board[x][y][BODY].dead = true;
		board[x][y][BODY].gfx_frames = 1;
	}

	// Turn old piece data on piece layer to BLANK
	board[x][y][PIECE].gfx = BLANK;
	board[x][y][PIECE].selected = false;

	// Did we have a rider on this piece?
	if (board[x][y][MOUNTED].gfx != BLANK)
	{
		if (game.debug_to_chat) log("PIECE : %s at x: %d, y: %d killed to make the rider : %s unmount", 
			board[x][y][PIECE].name, x, y, board[x][y][MOUNTED].name);

		// Yes, so make rider available and visible by putting back on PIECE layer.
		board[x][y][PIECE] = board[x][y][MOUNTED];
		board[x][y][MOUNTED].gfx = BLANK;
	}

	// Finally check to see if this piece was a growth covering another piece.
	if (board[x][y][PIECE_COVERED].gfx != -1)
	{
		// Uncover creature
		board[x][y][PIECE] = board[x][y][PIECE_COVERED];
		board[x][y][MOUNTED] = board[x][y][MOUNTED_COVERED];

		if (game.debug_to_chat) log("Growth killed to uncover piece : %s", board[x][y][PIECE].name);

		// Mark covered layer as free.
		board[x][y][PIECE_COVERED].gfx = -1;

		// Restore movement & other status flags to uncovered piece(s)
		// PIECE layer
		p = board[x][y][PIECE].gfx;

		if (p != BLANK)
		{
			// Reset piece states.
			board[x][y][PIECE].has_moved = true;
			board[x][y][PIECE].has_attacked = true;
			board[x][y][PIECE].has_shot = true;

			if (board[x][y][PIECE].movement > 0 || board[x][y][PIECE].grow_chance > 0) board[x][y][PIECE].has_moved = false;
			if (board[x][y][PIECE].combat > 0) board[x][y][PIECE].has_attacked = false;
			if (board[x][y][PIECE].ranged_combat_attack > 0) board[x][y][PIECE].has_shot = false;
		}

		// MOUNTED layer
		p = board[x][y][MOUNTED].gfx;

		if (p != BLANK)
		{
			// Reset piece states.
			board[x][y][MOUNTED].has_moved = true;
			board[x][y][MOUNTED].has_attacked = true;
			board[x][y][MOUNTED].has_shot = true;

			if (board[x][y][MOUNTED].movement > 0) board[x][y][MOUNTED].has_moved = false;
			if (board[x][y][MOUNTED].combat > 0) board[x][y][MOUNTED].has_attacked = false;
			if (board[x][y][MOUNTED].ranged_combat_attack > 0) board[x][y][MOUNTED].has_shot = false;     
		}
	}
}

bool try_to_select_piece(int x, int y, bool real)
{
	bool engaged;
	int total;

	// Reset highlight first.
	board_info.highlight_alpha.target = 0.0;

	// Abort if trying to select BLANK piece.
	if (board[x][y][PIECE].gfx == BLANK) return false;

	// Abort if this is NOT one of the current wizard's pieces.
	if (!is_piece_friendly(x, y, PIECE)) return false;

	engaged = any_enemies_around_piece(x, y);

	//log("name: %s, x: %d, y: %d, moved: %d, attacked: %d, shot: %d", board[x][y][PIECE].name, x, y, board[x][y][PIECE].has_moved, board[x][y][PIECE].has_attacked, board[x][y][PIECE].has_shot);

	// Abort if this piece has already moved.    
	if ((board[x][y][PIECE].has_moved || board[x][y][PIECE].movement == 0) && board[x][y][PIECE].has_attacked && board[x][y][PIECE].has_shot)
	{
		if (board[x][y][MOUNTED].gfx != -1 && !board[x][y][MOUNTED].has_moved) goto skip;

		board_info.highlight_type = HIGHLIGHT_NO_MOVES_LEFT;
		board_info.highlight_alpha.target = 1.0;
		board_info.highlight_x = x;
		board_info.highlight_y = y;   
		return false; 
	}

skip:

	// We can only do close combat, but there are no enemies directly adjacent?
	if (board[x][y][PIECE].has_moved && board[x][y][PIECE].combat > 0 && !engaged && board[x][y][PIECE].has_shot)
	{
		board_info.highlight_type = HIGHLIGHT_NO_MOVES_LEFT;
		board_info.highlight_alpha.target = 1.0;
		board_info.highlight_x = x;
		board_info.highlight_y = y;   
		return false; 
	}

	// But can our selected piece also shoot?
	if (board[x][y][PIECE].has_moved && board[x][y][PIECE].has_attacked && !board[x][y][PIECE].has_shot)
	{
		// Yes, so highlight enemy pieces that can be shot..
		total = set_highlight_board(x, y, board[x][y][PIECE].ranged_combat_range, PIECE, false, false, true, true, true, "");

		// Any targets?
		if (total == 0)
		{
			board_info.highlight_type = HIGHLIGHT_NO_MOVES_LEFT;
			board_info.highlight_alpha.target = 1.0;
			board_info.highlight_x = x;
			board_info.highlight_y = y;   
			return false; 
		}
	}

	// Ok, we could select piece, but we don't really want to yet, so highlight it first to show it can be selected.
	if (!real)
	{
		board_info.highlight_type = HIGHLIGHT_CAN_MOVE;
		board_info.highlight_alpha.target = 1.0;

		highlight_wizard_pieces(game.current_wizard);

		board_info.highlight_x = x;
		board_info.highlight_y = y;
	}
	else
	{
		// Really select piece.
		board_info.selected_x = x;
		board_info.selected_y = y;
		board_info.highlight_type = HIGHLIGHT_NONE;
		board_info.selected_state = true;
		board[x][y][PIECE].selected = true; 
		board_info.selected_layer = PIECE;
		board_info.selected_alpha.target = 1.0;
		board_info.selected_alpha.current = 1.0;

		request_sound_effect(board[x][y][PIECE].name, "CREATURE", "SELECTED", false);

		// Are we riding a piece that can't move or attack? If so switch to rider.
		if (board[x][y][PIECE].has_moved && board[x][y][PIECE].has_attacked && board[x][y][PIECE].has_shot)
		{
			board_info.selected_layer = MOUNTED;
		}

		if (!board[x][y][board_info.selected_layer].has_moved || !board[x][y][PIECE].has_attacked)
		{
			if (board[x][y][board_info.selected_layer].flying)
			{
				// Show flying creatures possible moves..
				if (board_info.selected_layer == PIECE && board[x][y][PIECE].engaged)
				{
					// Engaged, so show enemies directly around us.
					set_highlight_board(x, y, 1.0, PIECE, false, false, true, false, true, "");
				}
				else
				{
					// Not engaged, so show full range.
					set_highlight_board(x, y, board[x][y][board_info.selected_layer].movement, PIECE, 
						board[x][y][board_info.selected_layer].can_ride, true, true, false, true, "");
				}
			}
			else
			{
				// Show land based creatures possible moves. The engaged check code is done within this function..
				highlight_land_movement_options(x, y);
			}
		}
		else
		{
			if (board[x][y][PIECE].has_attacked && !board[x][y][PIECE].has_shot)
			{
				set_highlight_board(x, y, board[x][y][PIECE].ranged_combat_range, PIECE, false, false, true, true, true, "");
			}
		}
	}

	return true;
}

void unselect_piece(void)
{
	board_info.selected_state = false;
	board_info.selected_engaged = false;
	board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].selected = false;
	board_info.selected_layer = PIECE;
	board_info.selected_alpha.target = 0.0;

	// If we have no pieces left we can move then end turn.
	if (!any_pieces_we_can_move())
	{
		game.end_turn = true;
		request_sound_effect("CREATURE", "CREATURE", "END TURN", false);
		wait_time(50);
	}
}

void try_to_move_piece(int x, int y, bool real)
{
	int total;
	char name[80];

	//sprintf(name, "x: %d, y: %d, selected_x: %d, selected_y: %d", x, y, board_info.selected_x, board_info.selected_y);

	// Reset highlight in case we can't move.
	board_info.highlight_alpha.target = 0.0;
	//add_chat_line(name, wizard[game.current_wizard].col);

	if (x == board_info.selected_x && y == board_info.selected_y)
	{
		// Let computer player cancel movement by trying to move onto existing position.
		// Human players can't do this!
		if (real && !wizard[game.current_wizard].human)
		{
			board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_moved = true;
			board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_attacked = true;
			board_info.selected_engaged = false;
		}
		return; // Can't move piece over itself!
	}

	if (highlight_board[x][y].type == HIGHLIGHT_NONE)
	{
		clear_land_movement_route(); // Clear any old arrows to avoid misleading info being shown to player.
		return; // Can't move here!
	}

	// Set cursor highlight..  
	board_info.highlight_type = highlight_board[x][y].type;
	board_info.highlight_alpha.target = 1.0;
	board_info.highlight_x = x;
	board_info.highlight_y = y;

	// Land based movement?
	if (board_info.selected_state && !board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].flying &&
		!board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_moved)
	{
		draw_land_movement_route(x, y);
	}

	if (!real) return; // Done highlighting, so if not really moving then return.

	hide_highlight_board(false);

	// Ok, move.
	if (!board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].flying &&
		!board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_moved)
	{
		move_piece_along_route(x, y);
	}
	else
	{
		move_piece(x, y);
	}

	board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_moved = true;

	// Check if we have become engaged to an enemy piece. If we have not just mounted.
	if (board_info.selected_layer == PIECE &&
		!board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_attacked)
	{
		board_info.selected_engaged = engaged_around_piece(board_info.selected_x, board_info.selected_y);
	}

	// If we are engaged, then now show possible attacks.
	if (board_info.selected_engaged && 
		!board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_attacked)
	{
		request_sound_effect(board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].name, 
			"CREATURE", "ENGAGED", false);

		set_highlight_board(board_info.selected_x, board_info.selected_y, 1.0, PIECE, 
			false, false, true, false, true, "");
	}
	else
	{
		// Not engaged, so no close combat possible..
		board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_attacked = true;

		// But can our selected piece also shoot?
		if (!board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_shot)
		{
			// Yes, so highlight enemy pieces that can be shot..
			total = set_highlight_board(board_info.selected_x, board_info.selected_y, 
				board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].ranged_combat_range, PIECE, 
				false, false, true, true, true, "");

			// Any targets?
			if (total == 0)
			{
				clear_highlight_board();
				board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_shot = true;
			}
			else
			{
				request_sound_effect(board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].name, 
					"CREATURE", "SHOOTING PHASE", true);
			}
		}
	}

	if (board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_attacked &&
		board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_shot)
	{
		unselect_piece();
	}
}

void move_piece(int x, int y)
{
	int total;
	char name[512];

	// Can we attack this new piece?
	if (highlight_board[x][y].type == HIGHLIGHT_CAN_ATTACK)
	{
		if (!board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_attacked)
		{
			attack_piece(x, y);

			// Can our selected piece also shoot?
			if (!board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_shot)
			{
				// Yes, so highlight enemy pieces that can be shot..
				total = set_highlight_board(board_info.selected_x, board_info.selected_y, 
					board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].ranged_combat_range, PIECE, 
					false, false, true, true, true, "");

				if (total == 0)
				{
					clear_highlight_board();
					board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_shot = true;
				}
			}
		}
		else
		{
			shoot_piece(x, y);
		}
		return;
	}

	// Can we 'mount' this piece?
	if (highlight_board[x][y].type == HIGHLIGHT_CAN_RIDE)
	{
		ride_piece(x, y);
		return;
	}

	// Must be able to move to this new position on the board then..
	if (game.debug_to_chat)
	{
		sprintf(name, "%s moved from %d, %d to %d, %d", board[board_info.selected_x][board_info.selected_y][PIECE].name, 
			board_info.selected_x, board_info.selected_y, x, y);
		add_chat_line(name, wizard[game.current_wizard].col);
	}

	// Move piece data.
	board[x][y][PIECE] =
		board[board_info.selected_x][board_info.selected_y][board_info.selected_layer];

	if (board_info.selected_layer == PIECE)
	{
		// Move any riders too..
		board[x][y][MOUNTED] =
			board[board_info.selected_x][board_info.selected_y][MOUNTED];

		// Turn old riding piece data to BLANK
		board[board_info.selected_x][board_info.selected_y][MOUNTED].gfx = BLANK;

		board[x][y][MOUNTED].has_moved = true;
		board[x][y][MOUNTED].has_attacked = true;
		board[x][y][MOUNTED].has_shot = true;
	}

	// Turn old piece data to BLANK
	board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].gfx = BLANK;

	// Are we moving our wizard? If so, keep track of new postion.
	if (wizard[game.current_wizard].x == board_info.selected_x && wizard[game.current_wizard].y == board_info.selected_y)
	{
		wizard[game.current_wizard].x = x;
		wizard[game.current_wizard].y = y;  
	}

	// Update selected x and y.
	board_info.selected_x = x;
	board_info.selected_y = y;
	board_info.selected_layer = PIECE; // Now back on ground if we were riding..

	request_sound_effect(board[x][y][PIECE].name, "CREATURE", "MOVES", false);
}

void move_piece_along_route(int x, int y)
{
	int t, x2, y2, ox, oy;

	ox = x;
	oy = y;

start:

	x = ox;
	y = oy;

	// Work backwards from target until we find square connecting to our creature..
	for (t = 0 ; t < 40 ; t++)
	{
		x2 = highlight_board[x][y].from_x;
		y2 = highlight_board[x][y].from_y;

		//log("x: %d, y: %d, x2: %d, y2: %d", x, y, x2, y2);

		// Have we found connecting square to our piece?
		if (x2 == board_info.selected_x && y2 == board_info.selected_y)
		{
			//log("moving from x2: %d, y2: %d to x: %d, y: %d", board_info.selected_x, board_info.selected_y, x, y);
			move_piece(x, y);
			wait_time(35);

			// Have we reached target?
			if (t == 0 || (board_info.selected_engaged)) return;

			goto start;
		}

		x = x2;
		y = y2;

	}
}

void ride_piece(int x, int y)
{
	if (game.debug_to_chat)
	{
		log("%s at x: %d, y: %d rides %s at x: %d, y: %d", 
			board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].name, board_info.selected_x,
			board_info.selected_y, board[x][y][PIECE].name, x, y);
	}

	// Move piece data.
	board[x][y][MOUNTED] =
		board[board_info.selected_x][board_info.selected_y][board_info.selected_layer];

	// Turn old piece data to BLANK
	board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].gfx = BLANK;

	// Are we moving our wizard? If so, keep track of new postion.
	if (wizard[game.current_wizard].x == board_info.selected_x && wizard[game.current_wizard].y == board_info.selected_y)
	{
		wizard[game.current_wizard].x = x;
		wizard[game.current_wizard].y = y;  
	}

	// Sound effect.
	request_sound_effect(board[x][y][PIECE].name, "CREATURE", "MOUNTED", true);

	// Remove rider's movement status.
	board[x][y][MOUNTED].has_moved = true;
	board[x][y][MOUNTED].has_attacked = true;

	board[x][y][PIECE].has_moved = true;
	board[x][y][PIECE].has_attacked = true;
	board[x][y][PIECE].has_shot = true;

	// Update selected x and y.
	board_info.selected_x = x;
	board_info.selected_y = y;
	board_info.selected_layer = MOUNTED;

	clear_highlight_board();
}

bool do_attack_calculation(int att, int def)
{
	// Add random chance values.
	att = att + ((Rand() % 10) + 1);
	def = def + ((Rand() % 10) + 1);

	log("Final att/def values: %i, %i", att, def);

	return (att > def);
}

void attack_piece(int x, int y)
{
	int p, add;
	char name[MAX_STRING];

	request_sound_effect(board[board_info.selected_x][board_info.selected_y][PIECE].name, "CREATURE", "ATTACKS", false);

	// Find attack value of current selected piece, and defence value of piece we are
	// trying to attack.
	int att = board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].combat;
	int def = MID(1, board[x][y][PIECE].defence + (board[x][y][PIECE].shadow_form * 3), 9);

	log("Initial values: att: %s=%i, def: %s=%i", board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].name, att, board[x][y][PIECE].name, def);

	// Deal with Undeads.
	if (board[x][y][PIECE].undead)
	{
		find_option_choice_variables(CONFIG_OPTIONS, "GAME", "NORMAL CREATURE ATTACKS UNDEADS", &add, NULL, NULL, NULL);
		if (add != -1) def = MID(1, def + add, 9);
	}

	board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_attacked = true;
	clear_highlight_board();

	board_info.highlight_type = HIGHLIGHT_CAN_ATTACK;
	board_info.highlight_alpha.target = 0.0;
	board_info.highlight_x = x;
	board_info.highlight_y = y;

	if (board_info.selected_layer == PIECE)
	{
		// Attacking with piece, so rider can't now move or attack as well.
		board[board_info.selected_x][board_info.selected_y][MOUNTED].has_moved = true;
		board[board_info.selected_x][board_info.selected_y][MOUNTED].has_attacked = true;
		board[board_info.selected_x][board_info.selected_y][MOUNTED].has_shot = true;
	}

	do_attack_effect(x, y, 3); // Do attack effect 3 times for hand-hand combat.
	wait_time(225);

	// We've killed enemy piece!
	if (do_attack_calculation(att, def))
	{
		sprintf(name, "%s", board[x][y][PIECE].name);

		kill_piece(x, y, game.current_wizard, true);

		p = find_piece_by_name(board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].name);

		// If there is a wizard now here, we must have just killed a mount!
		if (wizard_here(x, y) != -1 && board[x][y][PIECE].gfx != BLANK)
		{
			request_sound_effect(name, "CREATURE", "MOUNT IS KILLED WHILE RIDDEN", true);
		}

		// Can piece normally move?
		bool should_we_move = piece[p].movement > 0;

		wait_time(100); // Wait a second to let body appear.

		// If this place is now BLANK then move into it with our piece.
		if (board[x][y][PIECE].gfx == BLANK && should_we_move)
		{
			move_piece(x, y);

			if (wizard_here(x, y) == game.current_wizard)
			{
				// We've just killed an enemy with our wizard and moved into it's square..
				request_sound_effect("WIZARD", "WIZARD", "KILLS ENEMY", true);
			}
		}  
	}
	else
	{
		// Did we fail to kill a wizard?
		if (wizard_here(x, y) != -1 && board[x][y][MOUNTED].gfx == BLANK)
		{
			request_sound_effect("WIZARD", "WIZARD", "HIT BUT SURVIVES", true);
		}
	}

	// Remove engaged status now we have attacked something!
	board_info.selected_engaged = false;

	// Did we have shadow form?
	if (board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].shadow_form)
	{
		// Remove it, and reset gfx frame..
		board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].shadow_form = false;
		board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].gfx =
			board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].start_gfx;
	}

	// Remove any movement points from our piece, whether we won the attack or not.
	if (board_info.selected_state && 
		board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_shot) end_move_piece();

	//board_info.highlight_type = HIGHLIGHT_NONE;
	board_info.highlight_alpha.target = 0.0;
}

void shoot_piece(int x, int y)
{
	int def, att, add;
	char name[MAX_STRING];

	// Find attack value of current selected piece, and defence value of piece we are
	// trying to attack.
	att = board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].ranged_combat_attack;
	def = MID(1, board[x][y][PIECE].defence + (board[x][y][PIECE].shadow_form * 3), 9);

	// Deal with Undeads.
	if (board[x][y][PIECE].undead)
	{
		find_option_choice_variables(CONFIG_OPTIONS, "GAME", "NORMAL CREATURE ATTACKS UNDEADS", &add, NULL, NULL, NULL);
		if (add != -1) def = MID(1, def + add, 9);
	}

	board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_shot = true;
	clear_highlight_board();

	board_info.highlight_type = HIGHLIGHT_CAN_ATTACK;
	board_info.highlight_alpha.target = 0.0;
	board_info.highlight_x = x;
	board_info.highlight_y = y;

	request_sound_effect(board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].name, 
		"CREATURE", "SHOOTS", false);

	// Do ranged attack effect.
	do_missile_effect(board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].ranged_combat_gfx, 
		4.0, board_info.selected_x, board_info.selected_y, x, y);

	do_effect(board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].ranged_combat_effect, x, y,
		board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].ranged_combat_effect_var1, 1);

	request_sound_effect(board[x][y][PIECE].name, "CREATURE", "SHOT", true);

	wait_time(75);
	wait_time(board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].ranged_combat_effect_var1 * 4);

	// Did we have shadow form?
	if (board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].shadow_form)
	{
		// Remove it, and reset gfx frame..
		board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].shadow_form = false;
		board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].gfx =
			board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].start_gfx;
	}

	sprintf(name, "%s", board[x][y][PIECE].name);

	// We've killed enemy piece!
	if (do_attack_calculation(att, def))
	{
		if (wizard_here(x, y) == -1 && board[x][y][MOUNTED].gfx == BLANK)
		{
			request_sound_effect(name, "CREATURE", "SHOT AND KILLED", false);
		}
		kill_piece(x, y, game.current_wizard, true);
		wait_time(100); // Wait a second to let body appear. 

		if (wizard_here(x, y) != -1) request_sound_effect(name, "CREATURE", "MOUNT IS KILLED WHILE RIDDEN", true);
	}
	else
	{
		request_sound_effect(name, "CREATURE", "SHOT BUT ALIVE", true);
	}
}

void end_move_piece(void)
{
	// Set status flags, and then unselect_piece.
	board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_moved = true;
	board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_attacked = true;
	board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].has_shot = true;
	unselect_piece(); 
}

void grow_piece(int x, int y)
{
	int new_x, new_y, p, rnd, att, def, add;
	char name[MAX_STRING];

	// Select random new adjacent square within map boundary.
	for ( ; ; )
	{
		rnd = IRand(0, 8);
		new_x = x;
		new_y = y;

		if (rnd == 0 || rnd == 3 || rnd == 5) new_x = x - 1;
		if (rnd == 2 || rnd == 4 || rnd == 6) new_x = x + 1;
		if (rnd == 0 || rnd == 1 || rnd == 2) new_y = y - 1;
		if (rnd == 5 || rnd == 6 || rnd == 7) new_y = y + 1;

		if (new_x >= 0 && new_y >= 0 && new_x < board_info.board_width && new_y < board_info.board_height) break;  
	}

	att = board[x][y][PIECE].grow_attack + IRand(0, 9);

	// Piece already here at new grow target.
	if (board[new_x][new_y][PIECE].gfx != -1)
	{
		if (board[new_x][new_y][PIECE].owner == board[x][y][PIECE].owner) return; // Can't grow over own pieces..

		if (board[new_x][new_y][PIECE].defence == 0)
		{
			// Nothing can destroy these pieces normally! Does piece trying to grow now die?
			rnd = IRand(0, 99);
			if (rnd < board[x][y][PIECE].grow_die_chance) kill_piece(x, y, -1, false);
			return;
		}

		if (att < 10) // 10 means always grow regardless of enemy defence..
		{
			// Try to beat enemy's defence to grow..
			def = MID(1, board[new_x][new_y][PIECE].defence + (board[new_x][new_y][PIECE].shadow_form * 3), 9) + IRand(0, 9);

			// Deal with Undeads.
			if (board[new_x][new_y][PIECE].undead)
			{
				find_option_choice_variables(CONFIG_OPTIONS, "GAME", "NORMAL CREATURE ATTACKS UNDEADS", &add, NULL, NULL, NULL);
				if (add != -1) def = MID(1, def + add, 9);
			}

			if (att <= def) return; // Failed!
		}

		// Does growth cover a piece, or kill it?
		if (board[x][y][PIECE].grow_covers)
		{
			if (wizard_here(new_x, new_y) != -1)
			{
				// Wizard here! So kill instead..
				kill_piece(new_x, new_y, board[x][y][PIECE].owner, false);
				if (board[new_x][new_y][PIECE].gfx != -1) kill_piece(new_x, new_y, board[x][y][PIECE].owner, false); // Must have been on a mount
			}
			else
			{
				if (board[new_x][new_y][PIECE_COVERED].gfx == -1)
				{
					if (board[new_x][new_y][PIECE].grow_chance == 0)
					{
						// Not a creature already covered here, and this target is not also capable of growing.. So move to cover layers!
						board[new_x][new_y][PIECE_COVERED] = board[new_x][new_y][PIECE];
						board[new_x][new_y][MOUNTED_COVERED] = board[new_x][new_y][MOUNTED];

						request_sound_effect(board[x][y][PIECE].name, "GROWTH", "COVERS", true);
					}
				}
			}
		}
		else
		{
			// Kill enemy piece(s)
			request_sound_effect(board[x][y][PIECE].name, "GROWTH", "KILLS", true);
			kill_piece(new_x, new_y, board[x][y][PIECE].owner, false);
			if (board[new_x][new_y][PIECE].gfx != -1) kill_piece(new_x, new_y, board[x][y][PIECE].owner, false); // Must have been a rider here..

			do_effect(EFFECT_EXPLODE, new_x, new_y, 64, 1);
		}
	}

	// Ok. Now we grow..
	p = find_piece_by_name(board[x][y][PIECE].grow_piece_name);
	sprintf(name, "%s", piece[p].name);

	// Can't find piece.. Is this a reference to a group?
	if (p == -1)
	{
		p = pick_random_piece_by_group_name(board[x][y][PIECE].grow_piece_name);
		sprintf(name, "%s", piece[p].name);
	}

	if (p == -1) return; // We couldn't find any piece to grow!

	create_new_piece(name, new_x, new_y);
	board[new_x][new_y][PIECE].just_grown = true; // This new piece shouldn't grow this turn.
	board[new_x][new_y][PIECE].owner = board[x][y][PIECE].owner; // This piece belongs to old piece's owner.
	request_sound_effect(name, "GROWTH", "GROWS", false);

	// See if piece dies after growing!
	rnd = IRand(0, 99);
	if (rnd < board[x][y][PIECE].grow_die_chance) kill_piece(x, y, -1, false);

	wait_time(50);
}

void increase_all_pieces_turn_number(void)
{
	int x, y, p;

	for (y = 0 ; y < board_info.board_height ; y++)
	{
		for (x = 0 ; x < board_info.board_width ; x++)
		{
			// PIECE layer
			p = board[x][y][PIECE].gfx; 

			// Increase turn value for piece.
			if (p != BLANK) board[x][y][PIECE].turn++;

			// MOUNTED layer
			p = board[x][y][MOUNTED].gfx; 

			// Increase turn value for piece.
			if (p != BLANK) board[x][y][MOUNTED].turn++;
		}
	}
}

void restore_all_pieces_status_flags(void)
{
	int x, y, p;

	for (y = 0 ; y < board_info.board_height ; y++)
	{
		for (x = 0 ; x < board_info.board_width ; x++)
		{
			// PIECE layer
			p = board[x][y][PIECE].gfx;

			if (p != BLANK)
			{
				// Reset piece states.
				board[x][y][PIECE].has_moved = true;
				board[x][y][PIECE].has_attacked = true;
				board[x][y][PIECE].has_shot = true;
				board[x][y][PIECE].just_grown = false;

				if (board[x][y][PIECE].movement > 0 || board[x][y][PIECE].grow_chance > 0) board[x][y][PIECE].has_moved = false;
				if (board[x][y][PIECE].combat > 0) board[x][y][PIECE].has_attacked = false;
				if (board[x][y][PIECE].ranged_combat_attack > 0) board[x][y][PIECE].has_shot = false;
			}

			// MOUNTED layer
			p = board[x][y][MOUNTED].gfx;

			if (p != BLANK)
			{
				// Reset piece states.
				board[x][y][MOUNTED].has_moved = true;
				board[x][y][MOUNTED].has_attacked = true;
				board[x][y][MOUNTED].has_shot = true;

				if (board[x][y][MOUNTED].movement > 0) board[x][y][MOUNTED].has_moved = false;
				if (board[x][y][MOUNTED].combat > 0) board[x][y][MOUNTED].has_attacked = false;
				if (board[x][y][MOUNTED].ranged_combat_attack > 0) board[x][y][MOUNTED].has_shot = false;     

			}
		}
	}
}

bool any_enemies_around_piece(int tx, int ty)
{
	int x1, y1, x2, y2, x, y;

	// Clip search so we don't go outside map.
	x1 = MAX(0, tx - 1);
	y1 = MAX(0, ty - 1);
	x2 = MIN(MAX_BOARD_WIDTH, tx + 1);
	y2 = MIN(MAX_BOARD_HEIGHT, ty + 1);

	for (y = y1 ; y <= y2 ; y++)
	{
		for (x = x1 ; x <= x2 ; x++)
		{
			if (board[x][y][PIECE].gfx == BLANK) continue;

			// Does this piece belong to another wizard? And can this piece attack or grow?
			if (!is_piece_friendly(x, y, PIECE) && (board[x][y][PIECE].combat > 0 ||
				(board[x][y][PIECE].grow_chance > 0 && board[x][y][PIECE].defence > 0))) return true; 
		}    
	}

	return false;
}

bool engaged_around_piece(int tx, int ty)
{
	int x1, y1, x2, y2, x, y, add;

	// Clip search so we don't go outside map.
	x1 = MAX(0, tx - 1);
	y1 = MAX(0, ty - 1);
	x2 = MIN(MAX_BOARD_WIDTH, tx + 1);
	y2 = MIN(MAX_BOARD_HEIGHT, ty + 1);

	for (y = y1 ; y <= y2 ; y++)
	{
		for (x = x1 ; x <= x2 ; x++)
		{
			if (board[x][y][PIECE].gfx == BLANK) continue;
			if (tx == x && ty == y) continue;

			// Does this piece belong to another wizard? And can this piece attack?
			if (board[x][y][PIECE].owner != game.current_wizard && (board[x][y][PIECE].combat > 0 || board[x][y][PIECE].ranged_combat_attack > 0))
			{
				if (board[x][y][PIECE].undead)
				{
					if (board[board_info.selected_x][board_info.selected_y][board_info.selected_layer].can_attack_undead) return true;

					find_option_choice_variables(CONFIG_OPTIONS, "GAME", "NORMAL CREATURE ATTACKS UNDEADS", &add, NULL, NULL, NULL);
					if (add == -1) continue; // Can't attack undeads!
				}
				//log("x: %d, y: %d, owner: %d, tx: %d, ty: %d, owner: %d, combat: %d", x, y, board[x][y][PIECE].owner,
				//tx, ty, game.current_wizard, board[x][y][PIECE].combat);
				return true; 
			}
		}    
	}

	return false;
}

bool adjacent_in_hostile_group(int tx, int ty, char *group)
{
	int x1, y1, x2, y2, x, y;

	// Clip search so we don't go outside map.
	x1 = MAX(0, tx - 1);
	y1 = MAX(0, ty - 1);
	x2 = MIN(MAX_BOARD_WIDTH, tx + 1);
	y2 = MIN(MAX_BOARD_HEIGHT, ty + 1);

	for (y = y1 ; y <= y2 ; y++)
	{
		for (x = x1 ; x <= x2 ; x++)
		{
			if (x == tx && y == ty) continue;
			if (board[x][y][PIECE].gfx == BLANK) continue;

			// Does this piece belong to another wizard?
			if (strcmp(group, board[x][y][PIECE].group_name) == 0 && 
				!board[x][y][PIECE].adjacent_in_group) return true;
		}    
	}

	return false;
}

bool any_pieces_we_can_move(void)
{
	int x, y, p, shoot;
	bool engaged;

	for (y = 0 ; y < board_info.board_height ; y++)
	{
		for (x = 0 ; x < board_info.board_width ; x++)
		{
			// PIECE layer
			p = board[x][y][PIECE].gfx;
			if (p == BLANK) continue;

			engaged = any_enemies_around_piece(x, y);
			shoot = 0;

			if (board[x][y][PIECE].owner == game.current_wizard)
			{
				if (!board[x][y][PIECE].has_shot)
				{
					shoot = set_highlight_board(x, y, board[x][y][PIECE].ranged_combat_range, PIECE, false, false, true, true, true, "");
					clear_highlight_board();
				}

				// Can this piece move?
				if (!(board[x][y][PIECE].has_moved || board[x][y][PIECE].movement == 0) || 
					(!board[x][y][PIECE].has_attacked && engaged) || (!board[x][y][PIECE].has_shot && shoot > 0)) return true;
			}

			// MOUNTED layer
			p = board[x][y][MOUNTED].gfx;
			if (p == BLANK) continue;

			if (board[x][y][MOUNTED].owner == game.current_wizard)
			{   
				// Can this piece move?
				if (!board[x][y][PIECE].rideable) continue; // This piece cannot normally be ridden! So, rider must be imprisoned.
				if (!board[x][y][MOUNTED].has_moved || (!board[x][y][MOUNTED].has_attacked && engaged)) return true;      
			}

		}
	}

	// No pieces left we can move.
	return false;
}

int pick_random_piece_by_group_name(char *name)
{
	int r, p, found;
	int new_piece[MAX_PIECES];
	found = 0;

	// Make a list of all creatures with this name.
	for (p = 0 ; p < MAX_PIECES ; p++)
	{
		//log("name: %s, piece group name: %s, spell group name: %s", piece[p].name, piece[p].group_name, name);
		if (strcmp(piece[p].group_name, name) == 0)
		{
			new_piece[found] = p;
			found++;
			//log("found: %d", found);
		}
	}

	if (found == 0) return -1; // No pieces with this group name.

	// Now pick a piece randomly from our list.
	r = IRand(0, found - 1);

	return new_piece[r];
}

void swap_pieces(int x1, int y1, int x2, int y2)
{
	int a, w1, w2;
	struct piece_data p[MAX_BOARD_LAYERS];

	w1 = wizard_here(x1, y1);
	w2 = wizard_here(x2, y2);

	//log("x1: %d, y1: %d, w1: %d", x1, y1, w1);
	//log("x2: %d, y2: %d, w2: %d", x2, y2, w2);

	for (a = 0 ; a < MAX_BOARD_LAYERS ; a++)
	{
		p[a] = board[x1][y1][a];
		board[x1][y1][a] = board[x2][y2][a];
		board[x2][y2][a] = p[a];

		if (w1 != -1)
		{
			wizard[w1].x = x2;
			wizard[w1].y = y2;
		}
		if (w2 != -1)
		{
			wizard[w2].x = x1;
			wizard[w2].y = y1;
		}
	}

}

bool is_piece_friendly(int x, int y, int layer)
{
	if (board[x][y][layer].owner != game.current_wizard)
	{
		//log("name: %s, mounted gfx: %d, can_ride: %d", board[x][y][layer].name, board[x][y][MOUNTED].gfx, board[x][y][layer].any_wizard_can_ride);
		if (layer == PIECE && board[x][y][MOUNTED].gfx == -1 && board[x][y][layer].any_wizard_can_ride) return true;
		if (layer == PIECE && board[x][y][MOUNTED].gfx != -1 && board[x][y][layer].any_wizard_can_ride &&
			board[x][y][MOUNTED].owner == game.current_wizard) return true;

		return false;
	}

	if (board[x][y][layer].owner == game.current_wizard) return true;

	return false;
}