callable_objects.cpp

Go to the documentation of this file.
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     

Generated by doxygen 1.5.5 on 23 May 2008 for The Battle for Wesnoth
Gna! | Forum | Wiki | CIA | devdocs