/*
 * Copyright (C) 2002-2007 The Warp Rogue Team
 * Part of the Warp Rogue Project
 *
 * This software is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License.
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY.
 *
 * See the license.txt file for more details.
 */

/*
 * Module Name: Actions
 * Description: -
 */

#define Uses_Ui
#define Uses_Util
#define Uses_Object
#define Uses_Movement
#define Uses_Combat
#define Uses_Perks
#define Uses_Round
#define Uses_Character
#define Uses_CharacterAdvancement
#define Uses_Stats
#define Uses_Psychic
#define Uses_Inventory
#define Uses_Random
#define Uses_Area
#define Uses_Sector
#define Uses_Equipment
#define Uses_Event
#define Uses_DynamicMessage
#define Uses_Perception
#define Uses_Drugs
#include "mheader.h"


#include "actions.h"



/*
 * action: do nothing
 */
void action_do_nothing(CHARACTER *character)
{

	character->action_spent = true;
}



/*
 * action: recover
 */
void action_recover(CHARACTER *character)
{

	character_recover(character);

	cancel_concentration(character);

	character->action_spent = true;
}



/*
 * action: move
 */
bool action_move(CHARACTER *character, const AREA_POINT *target_point)
{

	if (!move_character(character, target_point)) {

		return false;
	}

	cancel_concentration(character);

	character->action_spent = true;

	return true;
}



/*
 * action: push past
 */
void action_push_past(CHARACTER *character, CHARACTER *c2)
{

	push_past(character, c2);

	cancel_concentration(character);

	character->action_spent = true;
}



/*
 * action: run
 */
bool action_run(CHARACTER *character, const PATH_NODE *path, AREA_DISTANCE n_steps)
{

	if (!run(character, path, n_steps)) {

		return false;
	}

	cancel_concentration(character);

	character->action_spent = true;

	return true;
}



/*
 * action: jump
 */
void action_jump(CHARACTER *character, const AREA_POINT *target_point)
{

	move_character(character, target_point);

	cancel_concentration(character);

	character->action_spent = true;
}



/*
 * action: strike
 */
void action_strike(CHARACTER *character, OBJECT *weapon,
	const AREA_POINT *target_point
)
{

	strike(character, weapon, target_point);

	cancel_concentration(character);

	character->action_spent = true;
}



/*
 * action: shoot
 */
void action_shoot(CHARACTER *character, OBJECT *weapon,
	FIRING_DATA *firing_data, const AREA_POINT *target_point
)
{

	shoot(character, weapon, firing_data, target_point);

	cancel_concentration(character);

	character->action_spent = true;
}



/*
 * action: reload weapon
 */
void action_reload_weapon(CHARACTER *character)
{
	PHASE_TIME delay;
	N_ACTIONS n_actions_required;
	OBJECT *weapon;
	const OBJECT_DATA *weapon_data;
	EVENT *event;

	weapon = character->weapon;
	weapon_data = object_static_data(weapon);

	if (weapon_data->attribute[OA_PARTIAL_RELOAD]) {

		action_partial_reload(character);

		return;
	}

	n_actions_required = weapon_data->reload;

	if (character->perk[PK_QUICKLOAD] && n_actions_required >= 2) {

		n_actions_required /= 2;
	}

	delay = actions_to_time(character, n_actions_required);

	event = event_create(EVT_RELOAD_WEAPON, delay);
	event->character = character;
	event->object = weapon;
	event_set(event);

	character_set_flag(character, CF_BUSY);

	cancel_concentration(character);

	character->action_spent = true;
}



/*
 * action: reload weapon (partial reload)
 */
void action_partial_reload(CHARACTER *character)
{
	const OBJECT *weapon;
	const OBJECT_DATA *weapon_data;

	weapon = character->weapon;
	weapon_data = object_static_data(weapon);

	partial_reload(character);

	if (character->perk[PK_QUICKLOAD] &&
		weapon->charge < weapon_data->charge_max) {

		partial_reload(character);
	}

	cancel_concentration(character);

	character->action_spent = true;
}



/*
 * action: unjam weapon
 */
void action_unjam_weapon(CHARACTER *character)
{
	PHASE_TIME delay;
	EVENT *event;

	delay = actions_to_time(character, 2);

	event = event_create(EVT_UNJAM_WEAPON, delay);
	event->character = character;
	event->object = character->weapon;
	event_set(event);

	character_set_flag(character, CF_BUSY);

	cancel_concentration(character);

	character->action_spent = true;
}



/*
 * action: switch weapons
 */
void action_switch_weapons(CHARACTER *character)
{

	switch_weapons(character);

	cancel_concentration(character);

	if (!character->perk[PK_FAST_DRAW]) {

		character->action_spent = true;
	}
}



/*
 * action: disarm
 */
void action_disarm(CHARACTER *character, CHARACTER *target)
{

	disarm_use(character, target);

	if (character_unnoticed(character)) {

		notice_check(character, false, true);
	}

	cancel_concentration(character);

	character->action_spent = true;
}



/*
 * action: doctor
 */
void action_doctor(CHARACTER *character, CHARACTER *target)
{

	doctor_use(character, target);

	if (character_unnoticed(character)) {

		notice_check(character, false, true);
	}

	cancel_concentration(character);

	character->action_spent = true;
}



/*
 * action: concentrate
 */
void action_concentrate(CHARACTER *character)
{

	concentrate(character);

	character->action_spent = true;
}



/*
 * action: evoke psychic power
 */
bool action_evoke_psy_power(CHARACTER *character, PSY_POWER power,
	const AREA_POINT *target_point
)
{
	bool silent;
	bool power_evoked;

	if (character->perk[PK_SILENT_EVOCATION]) {

		silent = true;

	} else {

		silent = false;
	}

	power_evoked = evoke_psy_power(character, power, target_point);

	cancel_concentration(character);

	if (character_unnoticed(character)) {

		notice_check(character, silent, true);
	}

	character->action_spent = true;

	return power_evoked;
}



/*
 * action: pick up object
 */
void action_pick_up_object(CHARACTER *character, const AREA_POINT *location)
{
	OBJECT *object;
	SECTOR *sector;

	sector = sector_at(location);

	object = sector->object;

	dynamic_message(MSG_PICK_UP, character, object,
		MOT_OBJECT
	);

	inventory_add(character, object);

	sector->object = NULL;

	cancel_concentration(character);

	character->action_spent = true;
}



/*
 * action: equip object
 */
bool action_equip_object(CHARACTER *character, OBJECT *object, OBJECT **slot)
{

	if (!equip_object(character, object, slot)) {

		return false;
	}

	cancel_concentration(character);

	character->action_spent = true;

	return true;
}



/*
 * action: unequip object
 */
bool action_unequip_object(CHARACTER *character, OBJECT *object)
{
	bool unequip_weapon;

	if (object == character->weapon) {

		unequip_weapon = true;

	} else {

		unequip_weapon = false;
	}

	if (!unequip_object(character, object)) {

		return false;
	}

	if (unequip_weapon &&
		!is_player_controlled_character(character)) {

		dynamic_message(MSG_FIGHTS_UNARMED, character,
			NULL, MOT_NIL
		);
	}

	cancel_concentration(character);

	character->action_spent = true;

	return true;
}



/*
 * action: drop object
 */
void action_drop_object(CHARACTER *character, OBJECT *object, bool passive)
{
	AREA_POINT target_point;

	if (!passive) {

		cancel_concentration(character);

		character->action_spent = true;
	}

	inventory_remove(character, object);

	target_point = character->location;

	if (sector_is_class(&target_point, SC_FREE_OBJECT_LOCATION)) {

		place_object(object, &target_point);

		return;
	}

	if (sector_adjacent(&target_point, SC_FREE_OBJECT_LOCATION)
		== NULL) {

		object_destroy(object);

		return;
	}

	place_object(object, &target_point);

	return;
}



/*
 * action: use drug
 */
bool action_use_drug(CHARACTER *character, OBJECT *object)
{

	if (!use_drug(character, object)) {

		return false;
	}

	cancel_concentration(character);

	character->action_spent = true;

	return true;
}



/*
 * action: read tome
 */
bool action_read_tome(CHARACTER *character, OBJECT *object)
{
	const OBJECT_DATA *object_data;

	object_data = object_static_data(object);

	if (object_data->subtype == OSTYPE_ANCIENT_TOME) {

		if (!new_perk(character, true)) {

			return false;
		}

	} else if (object_data->subtype == OSTYPE_WARP_TOME) {

		if (!learn_psy_power(character, true)) {

			return false;
		}
	}

	inventory_remove(character, object);

	object_destroy(object);

	cancel_concentration(character);

	character->action_spent = true;

	return true;
}



/*
 * action: stealth
 */
bool action_stealth(CHARACTER *character)
{

	if (stealth_use(character)) {

		cancel_concentration(character);

		character->action_spent = true;

		return true;
	}

	return false;
}