bool MenuPowers::canUpgrade(short power_cell_index) {
return (nextLevel(power_cell_index) != -1 &&
requirementsMet(power_cell[power_cell_index].id) &&
powerUnlockable(power_cell_upgrade[nextLevel(power_cell_index)].id) &&
points_left > 0 &&
power_cell_upgrade[nextLevel(power_cell_index)].requires_point);
}
/**
* Show mouseover descriptions of disciplines and powers
*/
TooltipData MenuPowers::checkTooltip(Point mouse) {
TooltipData tip;
for (unsigned i=0; i<power_cell.size(); i++) {
if (tab_control && (tab_control->getActiveTab() != power_cell[i].tab)) continue;
if (!powerIsVisible(power_cell[i].id)) continue;
if (slots[i] && isWithin(slots[i]->pos, mouse)) {
bool base_unlocked = requirementsMet(power_cell[i].id) || std::find(stats->powers_list.begin(), stats->powers_list.end(), power_cell[i].id) != stats->powers_list.end();
generatePowerDescription(&tip, i, power_cell, !base_unlocked);
if (!power_cell[i].upgrades.empty()) {
short next_level = nextLevel(static_cast<short>(i));
if (next_level != -1) {
tip.addText("\n" + msg->get("Next Level:"));
generatePowerDescription(&tip, next_level, power_cell_upgrade, base_unlocked);
}
}
return tip;
}
}
return tip;
}
/**
* Click-to-drag a power (to the action bar)
*/
int MenuPowers::click(Point mouse) {
int active_tab = (tab_control) ? tab_control->getActiveTab() : 0;
for (unsigned i=0; i<power_cell.size(); i++) {
if (slots[i] && isWithin(slots[i]->pos, mouse) && (power_cell[i].tab == active_tab)) {
if (TOUCHSCREEN) {
if (!slots[i]->in_focus) {
slots[i]->in_focus = true;
tablist.setCurrent(slots[i]);
return 0;
}
}
if (powerUnlockable(power_cell[i].id) && points_left > 0 && power_cell[i].requires_point) {
// unlock power
stats->powers_list.push_back(power_cell[i].id);
stats->check_title = true;
setUnlockedPowers();
action_bar->addPower(power_cell[i].id, 0);
return 0;
}
else if (requirementsMet(power_cell[i].id) && !powers->powers[power_cell[i].id].passive) {
// pick up and drag power
slots[i]->in_focus = false;
return power_cell[i].id;
}
else
return 0;
}
}
return 0;
}
/**
* Click-to-drag a power (to the action bar)
*/
int MenuPowers::click(Point mouse) {
for (int i=0; i<20; i++) {
if (isWithin(slots[i], mouse)) {
if (requirementsMet(i)) return i;
else return -1;
}
}
return -1;
}
/**
* Right-clicking on a usable item in the inventory causes it to activate.
* e.g. drink a potion
* e.g. equip an item
*/
void MenuInventory::activate(InputState * input) {
int slot;
int equip_slot;
ItemStack stack;
Point nullpt;
nullpt.x = nullpt.y = 0;
// clicked a carried item
slot = inventory[CARRIED].slotOver(input->mouse);
// use a consumable item
if (items->items[inventory[CARRIED][slot].item].type == ITEM_TYPE_CONSUMABLE) {
powers->activate(items->items[inventory[CARRIED][slot].item].power, stats, nullpt);
// intercept used_item flag. We will destroy the item here.
powers->used_item = -1;
inventory[CARRIED].substract(slot);
}
// equip an item
else {
equip_slot = items->items[inventory[CARRIED][slot].item].type;
if (equip_slot == ITEM_TYPE_MAIN ||
equip_slot == ITEM_TYPE_BODY ||
equip_slot == ITEM_TYPE_OFF ||
equip_slot == ITEM_TYPE_ARTIFACT) {
if (requirementsMet(inventory[CARRIED][slot].item)) {
stack = click( input);
if( inventory[EQUIPMENT][equip_slot].item == stack.item) {
// Merge the stacks
add( stack, EQUIPMENT, equip_slot);
}
else if( inventory[EQUIPMENT][equip_slot].item == 0) {
// Drop the stack
inventory[EQUIPMENT][equip_slot] = stack;
}
else {
if( inventory[CARRIED][slot].item == 0) { // Don't forget this slot may have been emptied by the click()
// Swap the two stacks
itemReturn( inventory[EQUIPMENT][equip_slot]);
}
else {
// Drop the equipped item anywhere
add( inventory[EQUIPMENT][equip_slot]);
}
inventory[EQUIPMENT][equip_slot] = stack;
}
updateEquipment( equip_slot);
items->playSound(inventory[EQUIPMENT][equip_slot].item);
}
}
}
}
/**
* Check if we can unlock power.
*/
bool MenuPowers::powerUnlockable(int power_index) {
// power_index can be 0 during recursive call if requires_power is not defined.
// Power with index 0 doesn't exist and is always enabled
if (power_index == 0) return true;
// Find cell with our power
int id = id_by_powerIndex(static_cast<short>(power_index), power_cell_all);
// If we didn't find power in power_menu, than it has no requirements
if (id == -1) return true;
if (!powerIsVisible(static_cast<short>(power_index))) return false;
// If we already have a power, don't try to unlock it
if (requirementsMet(power_index)) return false;
// Check requirements
if (baseRequirementsMet(power_index)) return true;
return false;
}
bool MenuPowers::baseRequirementsMet(int power_index) {
int id = id_by_powerIndex(static_cast<short>(power_index), power_cell_all);
if (id == -1)
return false;
for (unsigned i = 0; i < power_cell_all[id].requires_power.size(); ++i)
if (!requirementsMet(power_cell_all[id].requires_power[i]))
return false;
if ((stats->physoff() >= power_cell_all[id].requires_physoff) &&
(stats->physdef() >= power_cell_all[id].requires_physdef) &&
(stats->mentoff() >= power_cell_all[id].requires_mentoff) &&
(stats->mentdef() >= power_cell_all[id].requires_mentdef) &&
(stats->get_defense() >= power_cell_all[id].requires_defense) &&
(stats->get_offense() >= power_cell_all[id].requires_offense) &&
(stats->get_physical() >= power_cell_all[id].requires_physical) &&
(stats->get_mental() >= power_cell_all[id].requires_mental) &&
(stats->level >= power_cell_all[id].requires_level)) return true;
return false;
}
void MenuPowers::renderPowers(int tab_num) {
Rect disabled_src;
disabled_src.x = disabled_src.y = 0;
disabled_src.w = disabled_src.h = ICON_SIZE;
for (unsigned i=0; i<power_cell.size(); i++) {
bool power_in_vector = false;
// Continue if slot is not filled with data
if (power_cell[i].tab != tab_num) continue;
if (!powerIsVisible(power_cell[i].id)) continue;
if (std::find(stats->powers_list.begin(), stats->powers_list.end(), power_cell[i].id) != stats->powers_list.end()) power_in_vector = true;
if (slots[i])
slots[i]->render();
// highlighting
if (power_in_vector || requirementsMet(power_cell[i].id)) {
displayBuild(power_cell[i].id);
}
else {
if (overlay_disabled && slots[i]) {
overlay_disabled->setClip(disabled_src);
overlay_disabled->setDest(slots[i]->pos);
render_device->render(overlay_disabled);
}
}
if (slots[i])
slots[i]->renderSelection();
// upgrade buttons
if (upgradeButtons[i])
upgradeButtons[i]->render();
}
}
/**
* Show mouseover descriptions of disciplines and powers
*/
TooltipData MenuPowers::checkTooltip(Point mouse) {
TooltipData tip;
int offset_x = (VIEW_W - 320);
int offset_y = (VIEW_H - 416)/2;
if (mouse.y >= offset_y+32 && mouse.y <= offset_y+80) {
if (mouse.x >= offset_x+48 && mouse.x <= offset_x+80) {
tip.lines[tip.num_lines++] = "Physical + Offense grants melee and ranged attacks";
return tip;
}
if (mouse.x >= offset_x+112 && mouse.x <= offset_x+144) {
tip.lines[tip.num_lines++] = "Physical + Defense grants melee protection";
return tip;
}
if (mouse.x >= offset_x+176 && mouse.x <= offset_x+208) {
tip.lines[tip.num_lines++] = "Mental + Offense grants elemental spell attacks";
return tip;
}
if (mouse.x >= offset_x+240 && mouse.x <= offset_x+272) {
tip.lines[tip.num_lines++] = "Mental + Defense grants healing and magical protection";
return tip;
}
}
else {
for (int i=0; i<20; i++) {
if (isWithin(slots[i], mouse)) {
tip.lines[tip.num_lines++] = powers->powers[i].name;
tip.lines[tip.num_lines++] = powers->powers[i].description;
if (powers->powers[i].requires_physical_weapon)
tip.lines[tip.num_lines++] = "Requires a physical weapon";
else if (powers->powers[i].requires_mental_weapon)
tip.lines[tip.num_lines++] = "Requires a mental weapon";
else if (powers->powers[i].requires_offense_weapon)
tip.lines[tip.num_lines++] = "Requires an offense weapon";
// add requirement
int required_val = (i / 4) * 2 + 1;
int required_stat = i % 4;
stringstream ss;
ss.str("");
ss << "Requires ";
if (required_val > 1) {
if (required_stat == 0) ss << "Physical Offense ";
else if (required_stat == 1) ss << "Physical Defense ";
else if (required_stat == 2) ss << "Mental Offense ";
else ss << "Mental Defense ";
ss << required_val;
if (!requirementsMet(i))
tip.colors[tip.num_lines] = FONT_RED;
tip.lines[tip.num_lines++] = ss.str();
}
// add mana cost
if (powers->powers[i].requires_mp > 0) {
int mp_cost = powers->powers[i].requires_mp;
stringstream ss;
ss.str("");
ss << "Costs ";
ss << mp_cost;
ss << " MP";
tip.lines[tip.num_lines++] = ss.str();
}
return tip;
}
}
}
return tip;
}
/**
* Given the equipped items, calculate the hero's stats
*/
void MenuInventory::applyEquipment(StatBlock *stats, ItemStack *equipped) {
int bonus_counter;
// note: these are also defined in MenuInventory.h
int SLOT_MAIN = 0;
int SLOT_BODY = 1;
int SLOT_OFF = 2;
//int SLOT_ARTIFACT = 3;
int prev_hp = stats->hp;
int prev_mp = stats->mp;
Item *items = this->items->items;
// calculate bonuses to basic stats and check that each equipped item fit requirements
bool checkRequired = true;
while(checkRequired)
{
checkRequired = false;
stats->offense_additional = stats->defense_additional = stats->physical_additional = stats->mental_additional = 0;
for (int i = 0; i < 4; i++) {
int item_id = equipped[i].item;
bonus_counter = 0;
while (items[item_id].bonus_stat[bonus_counter] != "") {
if (items[item_id].bonus_stat[bonus_counter] == "offense")
stats->offense_additional += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "defense")
stats->defense_additional += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "physical")
stats->physical_additional += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "mental")
stats->mental_additional += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "all basic stats") {
stats->offense_additional += items[item_id].bonus_val[bonus_counter];
stats->defense_additional += items[item_id].bonus_val[bonus_counter];
stats->physical_additional += items[item_id].bonus_val[bonus_counter];
stats->mental_additional += items[item_id].bonus_val[bonus_counter];
}
bonus_counter++;
if (bonus_counter == ITEM_MAX_BONUSES) break;
}
}
for (int i = 0; i < 4; i++) {
if (!requirementsMet(equipped[i].item)) {
add(equipped[i]);
equipped[i].item = 0;
equipped[i].quantity = 0;
checkRequired = true;
}
}
}
// defaults
stats->recalc();
stats->offense_additional = stats->defense_additional = stats->physical_additional = stats->mental_additional = 0;
stats->dmg_melee_min = stats->dmg_ment_min = 1;
stats->dmg_melee_max = stats->dmg_ment_max = 4;
stats->dmg_ranged_min = stats->dmg_ranged_max = 0;
stats->absorb_min = stats->absorb_max = 0;
stats->speed = 14;
stats->dspeed = 10;
stats->attunement_fire = 100;
stats->attunement_ice = 100;
// reset wielding vars
stats->wielding_physical = false;
stats->wielding_mental = false;
stats->wielding_offense = false;
// main hand weapon
int item_id = equipped[SLOT_MAIN].item;
if (item_id > 0) {
if (items[item_id].req_stat == REQUIRES_PHYS) {
stats->dmg_melee_min = items[item_id].dmg_min;
stats->dmg_melee_max = items[item_id].dmg_max;
stats->melee_weapon_power = items[item_id].power_mod;
stats->wielding_physical = true;
}
else if (items[item_id].req_stat == REQUIRES_MENT) {
stats->dmg_ment_min = items[item_id].dmg_min;
stats->dmg_ment_max = items[item_id].dmg_max;
stats->mental_weapon_power = items[item_id].power_mod;
stats->wielding_mental = true;
}
}
// off hand item
item_id = equipped[SLOT_OFF].item;
if (item_id > 0) {
if (items[item_id].req_stat == REQUIRES_OFF) {
stats->dmg_ranged_min = items[item_id].dmg_min;
stats->dmg_ranged_max = items[item_id].dmg_max;
stats->ranged_weapon_power = items[item_id].power_mod;
stats->wielding_offense = true;
}
else if (items[item_id].req_stat == REQUIRES_DEF) {
stats->absorb_min += items[item_id].abs_min;
stats->absorb_max += items[item_id].abs_max;
}
}
// body item
item_id = equipped[SLOT_BODY].item;
if (item_id > 0) {
stats->absorb_min += items[item_id].abs_min;
stats->absorb_max += items[item_id].abs_max;
}
// apply bonuses from all items
for (int i=0; i<4; i++) {
item_id = equipped[i].item;
bonus_counter = 0;
while (items[item_id].bonus_stat[bonus_counter] != "") {
if (items[item_id].bonus_stat[bonus_counter] == "HP")
stats->maxhp += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "HP regen")
stats->hp_per_minute += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "MP")
stats->maxmp += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "MP regen")
stats->mp_per_minute += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "accuracy")
stats->accuracy += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "avoidance")
stats->avoidance += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "crit")
stats->crit += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "speed") {
stats->speed += items[item_id].bonus_val[bonus_counter];
// speed bonuses are in multiples of 3
// 3 ordinal, 2 diagonal is rounding pythagorus
stats->dspeed += ((items[item_id].bonus_val[bonus_counter]) * 2) /3;
}
else if (items[item_id].bonus_stat[bonus_counter] == "fire resist")
stats->attunement_fire -= items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "ice resist")
stats->attunement_ice -= items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "offense")
stats->offense_additional += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "defense")
stats->defense_additional += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "physical")
stats->physical_additional += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "mental")
stats->mental_additional += items[item_id].bonus_val[bonus_counter];
else if (items[item_id].bonus_stat[bonus_counter] == "all basic stats") {
stats->offense_additional += items[item_id].bonus_val[bonus_counter];
stats->defense_additional += items[item_id].bonus_val[bonus_counter];
stats->physical_additional += items[item_id].bonus_val[bonus_counter];
stats->mental_additional += items[item_id].bonus_val[bonus_counter];
}
bonus_counter++;
if (bonus_counter == ITEM_MAX_BONUSES) break;
}
}
// apply previous hp/mp
if (prev_hp < stats->maxhp)
stats->hp = prev_hp;
else
stats->hp = stats->maxhp;
if (prev_mp < stats->maxmp)
stats->mp = prev_mp;
else
stats->mp = stats->maxmp;
}
/**
* Dragging and dropping an item can be used to rearrange the inventory
* and equip items
*/
void MenuInventory::drop(Point mouse, ItemStack stack) {
int area;
int slot;
int drag_prev_slot;
items->playSound(stack.item);
area = areaOver( mouse);
slot = inventory[area].slotOver(mouse);
drag_prev_slot = inventory[drag_prev_src].drag_prev_slot;
if (area == EQUIPMENT) { // dropped onto equipped item
// make sure the item is going to the correct slot
// note: equipment slots 0-3 correspond with item types 0-3
// also check to see if the hero meets the requirements
if (drag_prev_src == CARRIED && slot == items->items[stack.item].type && requirementsMet(stack.item)) {
if( inventory[area][slot].item == stack.item) {
// Merge the stacks
add( stack, area, slot);
}
else if( inventory[drag_prev_src][drag_prev_slot].item == 0) {
// Swap the two stacks
itemReturn( inventory[area][slot]);
inventory[area][slot] = stack;
updateEquipment( slot);
} else {
itemReturn( stack);
}
}
else {
// equippable items only belong to one slot, for the moment
itemReturn( stack); // cancel
}
}
else if (area == CARRIED) {
// dropped onto carried item
if (drag_prev_src == CARRIED) {
if (slot != drag_prev_slot) {
if( inventory[area][slot].item == stack.item) {
// Merge the stacks
add( stack, area, slot);
}
else if( inventory[area][slot].item == 0) {
// Drop the stack
inventory[area][slot] = stack;
}
else if( inventory[drag_prev_src][drag_prev_slot].item == 0) { // Check if the previous slot is free (could still be used if SHIFT was used).
// Swap the two stacks
itemReturn( inventory[area][slot]);
inventory[area][slot] = stack;
} else {
itemReturn( stack);
}
}
else {
itemReturn( stack); // cancel
}
}
else {
// note: equipment slots 0-3 correspond with item types 0-3
// also check to see if the hero meets the requirements
if (inventory[area][slot].item == stack.item) {
// Merge the stacks
add( stack, area, slot);
}
else if( inventory[area][slot].item == 0) {
// Drop the stack
inventory[area][slot] = stack;
}
else if(
inventory[EQUIPMENT][drag_prev_slot].item == 0
&& inventory[CARRIED][slot].item != stack.item
&& items->items[inventory[CARRIED][slot].item].type == drag_prev_slot
&& requirementsMet(inventory[CARRIED][slot].item)
) { // The whole equipped stack is dropped on an empty carried slot or on a wearable item
// Swap the two stacks
itemReturn( inventory[area][slot]);
inventory[area][slot] = stack;
}
else {
itemReturn( stack); // cancel
}
}
}
else {
itemReturn( stack); // not dropped into a slot. Just return it to the previous slot.
}
drag_prev_src = -1;
}
void MenuPowers::generatePowerDescription(TooltipData* tip, int slot_num, const std::vector<Power_Menu_Cell>& power_cells, bool show_unlock_prompt) {
if (power_cells[slot_num].upgrade_level > 0)
tip->addText(powers->powers[power_cells[slot_num].id].name + " (" + msg->get("Level %d", power_cells[slot_num].upgrade_level) + ")");
else
tip->addText(powers->powers[power_cells[slot_num].id].name);
if (powers->powers[power_cells[slot_num].id].passive) tip->addText("Passive");
tip->addText(powers->powers[power_cells[slot_num].id].description);
// add mana cost
if (powers->powers[power_cells[slot_num].id].requires_mp > 0) {
tip->addText(msg->get("Costs %d MP", powers->powers[power_cells[slot_num].id].requires_mp));
}
// add health cost
if (powers->powers[power_cells[slot_num].id].requires_hp > 0) {
tip->addText(msg->get("Costs %d HP", powers->powers[power_cells[slot_num].id].requires_hp));
}
// add cooldown time
if (powers->powers[power_cells[slot_num].id].cooldown > 0) {
std::stringstream ss;
ss << std::setprecision(3) << static_cast<float>(powers->powers[power_cells[slot_num].id].cooldown) / MAX_FRAMES_PER_SEC;
tip->addText(msg->get("Cooldown: %s seconds", ss.str().c_str()));
}
std::set<std::string>::iterator it;
for (it = powers->powers[power_cells[slot_num].id].requires_flags.begin(); it != powers->powers[power_cells[slot_num].id].requires_flags.end(); ++it) {
for (unsigned i=0; i<EQUIP_FLAGS.size(); ++i) {
if ((*it) == EQUIP_FLAGS[i].id) {
tip->addText(msg->get("Requires a %s", msg->get(EQUIP_FLAGS[i].name)));
}
}
}
// add requirement
if ((power_cells[slot_num].requires_physoff > 0) && (stats->physoff() < power_cells[slot_num].requires_physoff)) {
tip->addText(msg->get("Requires Physical Offense %d", power_cells[slot_num].requires_physoff), color_penalty);
}
else if((power_cells[slot_num].requires_physoff > 0) && (stats->physoff() >= power_cells[slot_num].requires_physoff)) {
tip->addText(msg->get("Requires Physical Offense %d", power_cells[slot_num].requires_physoff));
}
if ((power_cells[slot_num].requires_physdef > 0) && (stats->physdef() < power_cells[slot_num].requires_physdef)) {
tip->addText(msg->get("Requires Physical Defense %d", power_cells[slot_num].requires_physdef), color_penalty);
}
else if ((power_cells[slot_num].requires_physdef > 0) && (stats->physdef() >= power_cells[slot_num].requires_physdef)) {
tip->addText(msg->get("Requires Physical Defense %d", power_cells[slot_num].requires_physdef));
}
if ((power_cells[slot_num].requires_mentoff > 0) && (stats->mentoff() < power_cells[slot_num].requires_mentoff)) {
tip->addText(msg->get("Requires Mental Offense %d", power_cells[slot_num].requires_mentoff), color_penalty);
}
else if ((power_cells[slot_num].requires_mentoff > 0) && (stats->mentoff() >= power_cells[slot_num].requires_mentoff)) {
tip->addText(msg->get("Requires Mental Offense %d", power_cells[slot_num].requires_mentoff));
}
if ((power_cells[slot_num].requires_mentdef > 0) && (stats->mentdef() < power_cells[slot_num].requires_mentdef)) {
tip->addText(msg->get("Requires Mental Defense %d", power_cells[slot_num].requires_mentdef), color_penalty);
}
else if ((power_cells[slot_num].requires_mentdef > 0) && (stats->mentdef() >= power_cells[slot_num].requires_mentdef)) {
tip->addText(msg->get("Requires Mental Defense %d", power_cells[slot_num].requires_mentdef));
}
if ((power_cells[slot_num].requires_offense > 0) && (stats->get_offense() < power_cells[slot_num].requires_offense)) {
tip->addText(msg->get("Requires Offense %d", power_cells[slot_num].requires_offense), color_penalty);
}
else if ((power_cells[slot_num].requires_offense > 0) && (stats->get_offense() >= power_cells[slot_num].requires_offense)) {
tip->addText(msg->get("Requires Offense %d", power_cells[slot_num].requires_offense));
}
if ((power_cells[slot_num].requires_defense > 0) && (stats->get_defense() < power_cells[slot_num].requires_defense)) {
tip->addText(msg->get("Requires Defense %d", power_cells[slot_num].requires_defense), color_penalty);
}
else if ((power_cells[slot_num].requires_defense > 0) && (stats->get_defense() >= power_cells[slot_num].requires_defense)) {
tip->addText(msg->get("Requires Defense %d", power_cells[slot_num].requires_defense));
}
if ((power_cells[slot_num].requires_physical > 0) && (stats->get_physical() < power_cells[slot_num].requires_physical)) {
tip->addText(msg->get("Requires Physical %d", power_cells[slot_num].requires_physical), color_penalty);
}
else if ((power_cells[slot_num].requires_physical > 0) && (stats->get_physical() >= power_cells[slot_num].requires_physical)) {
tip->addText(msg->get("Requires Physical %d", power_cells[slot_num].requires_physical));
}
if ((power_cells[slot_num].requires_mental > 0) && (stats->get_mental() < power_cells[slot_num].requires_mental)) {
tip->addText(msg->get("Requires Mental %d", power_cells[slot_num].requires_mental), color_penalty);
}
else if ((power_cells[slot_num].requires_mental > 0) && (stats->get_mental() >= power_cells[slot_num].requires_mental)) {
tip->addText(msg->get("Requires Mental %d", power_cells[slot_num].requires_mental));
}
// Draw required Level Tooltip
if ((power_cells[slot_num].requires_level > 0) && stats->level < power_cells[slot_num].requires_level) {
tip->addText(msg->get("Requires Level %d", power_cells[slot_num].requires_level), color_penalty);
}
else if ((power_cells[slot_num].requires_level > 0) && stats->level >= power_cells[slot_num].requires_level) {
tip->addText(msg->get("Requires Level %d", power_cells[slot_num].requires_level));
}
for (unsigned j = 0; j < power_cells[slot_num].requires_power.size(); ++j) {
if (power_cells[slot_num].requires_power[j] == 0) continue;
short req_index = id_by_powerIndex(power_cells[slot_num].requires_power[j], power_cell_all);
if (req_index == -1) continue;
std::string req_power_name;
if (power_cell_all[req_index].upgrade_level > 0)
req_power_name = powers->powers[power_cell_all[req_index].id].name + " (" + msg->get("Level %d", power_cell_all[req_index].upgrade_level) + ")";
else
req_power_name = powers->powers[power_cell_all[req_index].id].name;
// Required Power Tooltip
if (!(requirementsMet(power_cells[slot_num].requires_power[j]))) {
tip->addText(msg->get("Requires Power: %s", req_power_name), color_penalty);
}
else {
tip->addText(msg->get("Requires Power: %s", req_power_name));
}
}
// Draw unlock power Tooltip
if (power_cells[slot_num].requires_point && !(std::find(stats->powers_list.begin(), stats->powers_list.end(), power_cells[slot_num].id) != stats->powers_list.end())) {
if (show_unlock_prompt && points_left > 0 && powerUnlockable(power_cells[slot_num].id)) {
tip->addText(msg->get("Click to Unlock (uses 1 Skill Point)"), color_bonus);
}
else {
if (power_cells[slot_num].requires_point && points_left < 1)
tip->addText(msg->get("Requires 1 Skill Point"), color_penalty);
else
tip->addText(msg->get("Requires 1 Skill Point"));
}
}
}
bool Equipment::use(Actor *owner, Actor *wearer) {
if (!equipped) {
switch(slot) {
case HEAD:
if(requirementsMet(owner,wearer)){
if (wearer->container->head) {
engine.gui->message(TCODColor::orange,"You swap out your head item.");
wearer->container->head->pickable->use(wearer->container->head,wearer);
}
wearer->container->head = owner;
}else{
}
break;
case CHEST:
if(requirementsMet(owner,wearer)){
if (wearer->container->chest) {
engine.gui->message(TCODColor::orange,"You swap out your chest item.");
wearer->container->chest->pickable->use(wearer->container->chest,wearer);
}
wearer->container->chest = owner;
}else{
}
break;
case LEGS:
if(requirementsMet(owner,wearer)){
if (wearer->container->legs) {
engine.gui->message(TCODColor::orange,"You swap out your leg item.");
wearer->container->legs->pickable->use(wearer->container->legs,wearer);
}
wearer->container->legs = owner;
}else{
}
break;
case FEET:
if(requirementsMet(owner,wearer)){
if (wearer->container->feet) {
engine.gui->message(TCODColor::orange,"You swap out your feet item.");
wearer->container->feet->pickable->use(wearer->container->feet,wearer);
}
wearer->container->feet = owner;
}else{
}
break;
case HAND1:
if(requirementsMet(owner,wearer)){
if (wearer->container->hand1) {
engine.gui->message(TCODColor::orange,"You swap out your main hand item.");
wearer->container->hand1->pickable->use(wearer->container->hand1,wearer);
}
if((((Weapon*)owner->pickable)->wType == Weapon::HEAVY) && (wearer->container->hand2 != NULL)){
engine.gui->message(TCODColor::orange,"You swap out your off hand item and heft this heavy weapon.");
wearer->container->hand2->pickable->use(wearer->container->hand2,wearer);
}
wearer->container->hand1 = owner;
}else{
}
break;
case HAND2:
if(requirementsMet(owner,wearer)){
if (wearer->container->hand2) {
engine.gui->message(TCODColor::orange,"You swap out your off hand item.");
wearer->container->hand2->pickable->use(wearer->container->hand2,wearer);
}
if((wearer->container->hand1) && ((Weapon*)wearer->container->hand1->pickable)->wType == Weapon::HEAVY){
engine.gui->message(TCODColor::orange,"You swap out your heavy main hand item.");
wearer->container->hand1->pickable->use(wearer->container->hand1,wearer);
}
wearer->container->hand2 = owner;
}else{
}
break;
case RANGED:
if(requirementsMet(owner,wearer)){
if (wearer->container->ranged) {
engine.gui->message(TCODColor::orange,"You swap out your ranged item.");
wearer->container->ranged->pickable->use(wearer->container->ranged,wearer);
}
wearer->container->ranged = owner;
}else{
}
break;
case NOSLOT: break;
default: break;
}
equipped = true;
for(int i = 0; i < bonus.size(); i++){
ItemBonus *thisBonus = bonus.get(i);
switch(thisBonus->type) {
case ItemBonus::NOBONUS: break;
case ItemBonus::HEALTH: wearer->destructible->maxHp += thisBonus->bonus; break;
case ItemBonus::DODGE: wearer->destructible->totalDodge += thisBonus->bonus; break;
case ItemBonus::DR: wearer->destructible->totalDR += thisBonus->bonus; break;
case ItemBonus::STRENGTH: wearer->attacker->totalStr += thisBonus->bonus; break;
case ItemBonus::DEXTERITY: wearer->attacker->totalDex += thisBonus->bonus; break;
//case ItemBonus::INTELLIGENCE: wearer->totalIntel += thisBonus->bonus; break;
case ItemBonus::LIGHT: engine.fovRadius += thisBonus->bonus; break;
default: break;
}
}
wearer->container->sendToBegin(owner);
return true;
} else {
equipped = false;
switch(slot) {
case HEAD: wearer->container->head = NULL; break;
case CHEST: wearer->container->chest = NULL; break;
case LEGS: wearer->container->legs = NULL; break;
case FEET: wearer->container->feet = NULL; break;
case HAND1: wearer->container->hand1 = NULL; break;
case HAND2: wearer->container->hand2 = NULL; break;
case RANGED: wearer->container->ranged = NULL; break;
case NOSLOT: break;
default: break;
}
for(int i = 0; i < bonus.size(); i++){///////
ItemBonus *thisBonus = bonus.get(i);
switch(thisBonus->type) {
case ItemBonus::NOBONUS: break;
case ItemBonus::HEALTH:
wearer->destructible->maxHp -= thisBonus->bonus;
if (wearer->destructible->hp > wearer->destructible->maxHp) {
wearer->destructible->hp = wearer->destructible->maxHp;
}
break;
case ItemBonus::DODGE: wearer->destructible->totalDodge -= thisBonus->bonus; break;
case ItemBonus::DR: wearer->destructible->totalDR -= thisBonus->bonus; break;
case ItemBonus::STRENGTH: wearer->attacker->totalStr -= thisBonus->bonus; break;
case ItemBonus::DEXTERITY: wearer->attacker->totalDex -= thisBonus->bonus; break;
//case ItemBonus::INTELLIGENCE: wearer->totalIntel -= thisBonus->bonus; break;
case ItemBonus::LIGHT: engine.fovRadius -= thisBonus->bonus; break;
default: break;
}
}
wearer->container->inventory.remove(owner);
wearer->container->inventory.push(owner);
return true;
}
return false;
}
