lua_sticky_candidate_action_wrapper( rca_context &context, const config &cfg, lua_ai_context &lua_ai_ctx)
: lua_candidate_action_wrapper(context, cfg, lua_ai_ctx)
, bound_unit_()
{
map_location loc(cfg["unit_x"], cfg["unit_y"], wml_loc()); // lua and c++ coords differ by one
bound_unit_ = unit_ptr(new unit(*resources::units->find(loc)));
}
void for_each_loc(const F& f) const
{
for (int x = 0; x < total_width(); ++x) {
for (int y = 0; y < total_height(); ++y) {
f({ x, y , wml_loc()});
}
}
}
move_action(const config & cfg, const config & unit_cfg,
int sm, const map_location::DIRECTION dir)
: undo_action(cfg)
, shroud_clearing_action(cfg)
, starting_moves(sm)
, starting_dir(dir)
, goto_hex(unit_cfg["goto_x"].to_int(-999),
unit_cfg["goto_y"].to_int(-999), wml_loc())
{
}
recruit::recruit(const config& cfg, bool hidden)
: action(cfg,hidden)
, unit_name_(cfg["unit_name_"])
, recruit_hex_(cfg.child("recruit_hex_")["x"],cfg.child("recruit_hex_")["y"], wml_loc())
, temp_unit_()
, fake_unit_()
, cost_(0)
{
// Validate unit_name_
if(!unit_types.find(unit_name_))
throw action::ctor_err("recruit: Invalid recruit unit type");
// Construct temp_unit_ and fake_unit_
temp_unit_ = create_corresponding_unit(); //auto-ptr ownership transfer
fake_unit_.reset(unit_ptr (new unit(*temp_unit_))), //temp_unit_ copied into new fake_unit
this->init();
}
attack::attack(config const& cfg, bool hidden)
: move(cfg,hidden)
, target_hex_(cfg.child("target_hex_")["x"],cfg.child("target_hex_")["y"], wml_loc())
, weapon_choice_(cfg["weapon_choice_"].to_int(-1)) //default value: -1
, attack_movement_cost_()
, temp_movement_subtracted_(0)
{
// Validate target_hex
if(!tiles_adjacent(target_hex_,get_dest_hex()))
throw action::ctor_err("attack: Invalid target_hex_");
// Validate weapon_choice_
if(weapon_choice_ < 0 || weapon_choice_ >= static_cast<int>(get_unit()->attacks().size()))
throw action::ctor_err("attack: Invalid weapon_choice_");
// Construct attack_movement_cost_
attack_movement_cost_ = get_unit()->attacks()[weapon_choice_].movement_used();
this->init();
}
recall::recall(config const& cfg, bool hidden)
: action(cfg,hidden)
, temp_unit_()
, recall_hex_(cfg.child("recall_hex_")["x"],cfg.child("recall_hex_")["y"], wml_loc())
, fake_unit_()
{
// Construct and validate temp_unit_
size_t underlying_id = cfg["temp_unit_"];
for(const unit_const_ptr & recall_unit : resources::gameboard->teams().at(team_index()).recall_list())
{
if(recall_unit->underlying_id()==underlying_id)
{
temp_unit_.reset(new class unit(*recall_unit)); //TODO: is it necessary to make a copy?
break;
}
}
if(!temp_unit_.get()) {
throw action::ctor_err("recall: Invalid underlying_id");
}
fake_unit_.reset(unit_ptr(new class unit(*temp_unit_))); //makes copy of temp_unit_
this->init();
}
void gamemap::overlay_impl(
// const but changed via set_terrain
const t_translation::ter_map& m1,
starting_positions& m1_st,
const t_translation::ter_map& m2,
const starting_positions& m2_st,
std::function<void (const map_location&, const t_translation::terrain_code&, terrain_type_data::merge_mode, bool)> set_terrain,
map_location loc,
const std::vector<overlay_rule>& rules,
bool m_is_odd,
bool ignore_special_locations)
{
int xpos = loc.wml_x();
int ypos = loc.wml_y();
const int xstart = std::max<int>(0, -xpos);
const int xend = std::min<int>(m2.w, m1.w -xpos);
const int xoffset = xpos;
const int ystart_even = std::max<int>(0, -ypos);
const int yend_even = std::min<int>(m2.h, m1.h - ypos);
const int yoffset_even = ypos;
const int ystart_odd = std::max<int>(0, -ypos +(xpos & 1) -(m_is_odd ? 1 : 0));
const int yend_odd = std::min<int>(m2.h, m1.h - ypos +(xpos & 1) -(m_is_odd ? 1 : 0));
const int yoffset_odd = ypos -(xpos & 1) + (m_is_odd ? 1 : 0);
for(int x1 = xstart; x1 != xend; ++x1) {
int ystart, yend, yoffset;
if(x1 & 1) {
ystart = ystart_odd , yend = yend_odd , yoffset = yoffset_odd;
}
else {
ystart = ystart_even, yend = yend_even, yoffset = yoffset_even;
}
for(int y1 = ystart; y1 != yend; ++y1) {
const int x2 = x1 + xoffset;
const int y2 = y1 + yoffset;
const t_translation::terrain_code t = m2.get(x1,y1);
const t_translation::terrain_code current = m1.get(x2, y2);
if(t == t_translation::FOGGED || t == t_translation::VOID_TERRAIN) {
continue;
}
// See if there is a matching rule
const overlay_rule* rule = nullptr;
for(const overlay_rule& current_rule : rules)
{
if(!current_rule.old_.empty() && !t_translation::terrain_matches(current, current_rule.old_)) {
continue;
}
if(!current_rule.new_.empty() && !t_translation::terrain_matches(t, current_rule.new_)) {
continue;
}
rule = ¤t_rule;
break;
}
if (!rule) {
set_terrain(map_location(x2, y2, wml_loc()), t, terrain_type_data::BOTH, false);
}
else if(!rule->use_old_) {
set_terrain(map_location(x2, y2, wml_loc()), rule->terrain_ ? *rule->terrain_ : t , rule->mode_, rule->replace_if_failed_);
}
}
}
if (!ignore_special_locations) {
for(auto& pair : m2_st.left) {
int x = pair.second.wml_x();
int y = pair.second.wml_y();
if(x & 1) {
if(x < xstart || x >= xend || y < ystart_odd || y >= yend_odd) {
continue;
}
}
else {
if(x < xstart || x >= xend || y < ystart_even || y >= yend_even) {
continue;
}
}
int x_new = x + xoffset;
int y_new = y + ((x & 1 ) ? yoffset_odd : yoffset_even);
map_location pos_new = map_location(x_new, y_new, wml_loc());
m1_st.left.erase(pair.first);
m1_st.insert(starting_positions::value_type(pair.first, t_translation::coordinate(pos_new.x, pos_new.y)));
}
}
}