00001 #include "callable_objects.hpp"
00002 #include "pathutils.hpp"
00003
00004 variant location_callable::get_value(const std::string& key) const
00005 {
00006 if(key == "x") {
00007 return variant(loc_.x+1);
00008 } else if(key == "y") {
00009 return variant(loc_.y+1);
00010 } else if(key == "adjacent_locs") {
00011 gamemap::location adj[6];
00012 get_adjacent_tiles(loc_, adj);
00013
00014 std::vector<variant> v;
00015 v.reserve(6);
00016 for(int n = 0; n != 6; ++n) {
00017 v.push_back(variant(new location_callable(adj[n])));
00018 }
00019
00020 return variant(&v);
00021 } else {
00022 return variant();
00023 }
00024 }
00025
00026 void location_callable::get_inputs(std::vector<game_logic::formula_input>* inputs) const
00027 {
00028 using game_logic::FORMULA_READ_ONLY;
00029 inputs->push_back(game_logic::formula_input("x", FORMULA_READ_ONLY));
00030 inputs->push_back(game_logic::formula_input("y", FORMULA_READ_ONLY));
00031 }
00032
00033 int location_callable::do_compare(const game_logic::formula_callable* callable) const
00034 {
00035 const location_callable* loc_callable = dynamic_cast<const location_callable*>(callable);
00036 if(loc_callable == NULL) {
00037 return formula_callable::do_compare(callable);
00038 }
00039
00040 const gamemap::location& other_loc = loc_callable->loc();
00041 if(other_loc.x != loc_.x) {
00042 return loc_.x - other_loc.x;
00043 }
00044
00045 return loc_.y - other_loc.y;
00046 }
00047
00048 void location_callable::serialize_to_string(std::string& str) const
00049 {
00050 std::ostringstream s;
00051 s << "loc(" << loc_.x << "," << loc_.y << ")";
00052 str = s.str();
00053 }
00054
00055 variant move_map_callable::get_value(const std::string& key) const
00056 {
00057 using namespace game_logic;
00058 if(key == "moves") {
00059 std::vector<variant> vars;
00060 for(move_map::const_iterator i = srcdst_.begin(); i != srcdst_.end(); ++i) {
00061 move_callable* item = new move_callable(i->first, i->second);
00062 vars.push_back(variant(item));
00063 }
00064
00065 return variant(&vars);
00066 } else if(key == "has_moves") {
00067 return variant(!srcdst_.empty());
00068 } else {
00069 return variant();
00070 }
00071 }
00072
00073 void move_map_callable::get_inputs(std::vector<game_logic::formula_input>* inputs) const
00074 {
00075 using game_logic::FORMULA_READ_ONLY;
00076 inputs->push_back(game_logic::formula_input("moves", FORMULA_READ_ONLY));
00077 }
00078
00079 variant unit_callable::get_value(const std::string& key) const
00080 {
00081 if(key == "x") {
00082 return variant(loc_.x+1);
00083 } else if(key == "y") {
00084 return variant(loc_.y+1);
00085 } else if(key == "loc") {
00086 return variant(new location_callable(loc_));
00087 } else if(key == "id") {
00088 return variant(u_.id());
00089 } else if(key == "type") {
00090 return variant(u_.type_id());
00091 } else if(key == "leader") {
00092 return variant(u_.can_recruit());
00093 } else if(key == "hitpoints") {
00094 return variant(u_.hitpoints());
00095 } else if(key == "max_hitpoints") {
00096 return variant(u_.max_hitpoints());
00097 } else if(key == "experience") {
00098 return variant(u_.experience());
00099 } else if(key == "max_experience") {
00100 return variant(u_.max_experience());
00101 } else if(key == "level") {
00102 return variant(u_.level());
00103 } else if(key == "total_movement") {
00104 return variant(u_.total_movement());
00105 } else if(key == "movement_left") {
00106 return variant(u_.movement_left());
00107 } else if(key == "side") {
00108 return variant(u_.side());
00109 } else if(key == "value") {
00110 return variant(u_.cost());
00111 } else if(key == "vars") {
00112 if(u_.formula_vars()) {
00113 return variant(u_.formula_vars().get());
00114 } else {
00115 return variant();
00116 }
00117 } else {
00118 return variant();
00119 }
00120 }
00121
00122 void unit_callable::get_inputs(std::vector<game_logic::formula_input>* inputs) const
00123 {
00124 using game_logic::FORMULA_READ_ONLY;
00125 inputs->push_back(game_logic::formula_input("x", FORMULA_READ_ONLY));
00126 inputs->push_back(game_logic::formula_input("y", FORMULA_READ_ONLY));
00127 inputs->push_back(game_logic::formula_input("loc", FORMULA_READ_ONLY));
00128 inputs->push_back(game_logic::formula_input("id", FORMULA_READ_ONLY));
00129 inputs->push_back(game_logic::formula_input("leader", FORMULA_READ_ONLY));
00130 inputs->push_back(game_logic::formula_input("hitpoints", FORMULA_READ_ONLY));
00131 inputs->push_back(game_logic::formula_input("max_hitpoints", FORMULA_READ_ONLY));
00132 inputs->push_back(game_logic::formula_input("experience", FORMULA_READ_ONLY));
00133 inputs->push_back(game_logic::formula_input("max_experience", FORMULA_READ_ONLY));
00134 inputs->push_back(game_logic::formula_input("level", FORMULA_READ_ONLY));
00135 inputs->push_back(game_logic::formula_input("total_movement", FORMULA_READ_ONLY));
00136 inputs->push_back(game_logic::formula_input("movement_left", FORMULA_READ_ONLY));
00137 inputs->push_back(game_logic::formula_input("side", FORMULA_READ_ONLY));
00138 }
00139
00140 variant terrain_callable::get_value(const std::string& key) const
00141 {
00142 if(key == "x") {
00143 return variant(loc_.x+1);
00144 } else if(key == "y") {
00145 return variant(loc_.y+1);
00146 } else if(key == "loc") {
00147 return variant(new location_callable(loc_));
00148 } else if(key == "id") {
00149 return variant(std::string(t_.id()));
00150 } else
00151 return variant();
00152 }
00153
00154 void terrain_callable::get_inputs(std::vector<game_logic::formula_input>* inputs) const
00155 {
00156 using game_logic::FORMULA_READ_ONLY;
00157 inputs->push_back(game_logic::formula_input("x", FORMULA_READ_ONLY));
00158 inputs->push_back(game_logic::formula_input("y", FORMULA_READ_ONLY));
00159 inputs->push_back(game_logic::formula_input("loc", FORMULA_READ_ONLY));
00160 inputs->push_back(game_logic::formula_input("id", FORMULA_READ_ONLY));
00161 }
00162