variant variant::operator*(const variant& v) const
{
if(type_ == TYPE_DECIMAL || v.type_ == TYPE_DECIMAL) {
return variant(as_decimal() * v.as_decimal());
}
if(type_ == TYPE_LIST) {
int ncopies = v.as_int();
if(ncopies < 0) {
ncopies *= -1;
}
const std::vector<variant>& items = list_->elements;
std::vector<variant> res;
res.reserve(items.size()*ncopies);
for(int n = 0; n != ncopies; ++n) {
for(int m = 0; m != items.size(); ++m) {
res.push_back(items[m]);
}
}
return variant(&res);
}
return variant(as_int() * v.as_int());
}
void arrow_primitive::set_value(const std::string& key, const variant& value)
{
if(key == "points") {
set_points(value);
} else if(key == "color") {
color_ = graphics::color(value);
} else if(key == "granularity") {
granularity_ = value.as_decimal().as_float();
} else if(key == "arrow_head_length") {
arrow_head_length_ = value.as_int();
} else if(key == "arrow_head_width") {
arrow_head_width_ = value.as_decimal().as_float();
} else if(key == "fade_in_length") {
fade_in_length_ = value.as_int();
} else if(key == "width_base") {
width_base_ = value.as_decimal().as_float();
} else if(key == "width_head") {
width_head_ = value.as_decimal().as_float();
} else {
ASSERT_LOG(false, "ILLEGAL KEY IN ARROW: " << key);
}
varray_.clear();
carray_.clear();
}
void scrollable_widget::set_value(const std::string& key, const variant& v)
{
if(key == "yscroll") {
set_yscroll(v.as_int());
} else if(key == "virtual_height") {
set_virtual_height(v.as_int());
} else if(key == "step") {
set_scroll_step(v.as_int());
}
widget::set_value(key, v);
}
void set_value(const std::string& key, const variant& value) {
if(key == "generation_rate") {
generation_rate_millis_ = value.as_int();
} else if (key == "pos_x") {
pos_x_ = value.as_int()*1024;
} else if (key == "pos_x_rand") {
pos_x_rand_ = value.as_int()*1024;
} else if (key == "pos_y") {
pos_y_ = value.as_int()*1024;
} else if (key == "pos_y_rand") {
pos_y_rand_ = value.as_int()*1024;
}
}
int from_variant(variant node)
{
if(node.is_string()) {
return from_string(node.as_string());
}
return node.as_int(-1);
}
void dropdown_widget::set_value(const std::string& key, const variant& v)
{
if(key == "on_change") {
on_change_ = boost::bind(&dropdown_widget::change_delegate, this, _1);
change_handler_ = get_environment()->create_formula(v);
} else if(key == "on_select") {
on_select_ = boost::bind(&dropdown_widget::select_delegate, this, _1, _2);
select_handler_ = get_environment()->create_formula(v);
} else if(key == "item_list") {
list_ = v.as_list_string();
current_selection_ = 0;
} else if(key == "selection") {
current_selection_ = v.as_int();
} else if(key == "type") {
std::string s = v.as_string();
if(s == "combo" || s == "combobox") {
type_ = DROPDOWN_COMBOBOX;
} else if(s == "list" || s == "listbox") {
type_ = DROPDOWN_LIST;
} else {
ASSERT_LOG(false, "Unreognised type: " << s);
}
}
widget::set_value(key, v);
}
void dialog_label::set_value(const std::string& key, const variant& v)
{
if(key == "progress") {
set_progress(v.as_int());
}
label::set_value(key, v);
}
variant variant::operator/(const variant& v) const
{
if(type_ == TYPE_DECIMAL || v.type_ == TYPE_DECIMAL) {
int denominator = v.as_decimal();
if(denominator == 0) {
throw type_error((formatter() << "divide by zero error").str());
}
long long long_int = as_decimal();
long_int *= 10000;
long_int /= denominator;
if( long_int%10 >= 5) {
long_int /= 10;
++long_int;
} else
long_int/=10;
return variant( static_cast<int>(long_int) , variant::DECIMAL_VARIANT);
}
const int numerator = as_int();
const int denominator = v.as_int();
if(denominator == 0) {
throw type_error((formatter() << "divide by zero error").str());;
}
return variant(numerator/denominator);
}
void scrollbar_widget::set_value(const std::string& key, const variant& v)
{
if(key == "on_scroll") {
ffl_handler_ = get_environment()->create_formula(v["on_scroll"]);
} else if(key == "up_arrow") {
up_arrow_ = widget_factory::create(v, get_environment());
} else if(key == "down_arrow") {
down_arrow_ = widget_factory::create(v, get_environment());
} else if(key == "handle") {
handle_ = widget_factory::create(v, get_environment());
} else if(key == "handle_bottom") {
handle_bot_ = widget_factory::create(v, get_environment());
} else if(key == "handle_top") {
handle_top_ = widget_factory::create(v, get_environment());
} else if(key == "background") {
background_ = widget_factory::create(v, get_environment());
} else if(key == "range") {
std::vector<int> range = v.as_list_int();
ASSERT_EQ(range.size(), 2);
set_range(range[0], range[1]);
} else if(key == "position") {
window_pos_ = v.as_int();
clip_window_position();
}
widget::set_value(key, v);
}
void bar_widget::set_value(const std::string& key, const variant& value)
{
if(key == "segments") {
segments_ = value.as_int();
ASSERT_GE(segments_, 0);
init();
} else if(key == "segment_length") {
segment_length_ = value.as_int();
ASSERT_GT(segment_length_, 0);
init();
} else if(key == "tick_width") {
tick_width_ = value.as_int();
ASSERT_GT(tick_width_, 0);
init();
} else if(key == "scale") {
scale_ = value.as_decimal().as_float();
ASSERT_GT(scale_, 0.0f);
init();
} else if(key == "drain_rate") {
drain_rate_ = value.as_decimal().as_float();
ASSERT_GE(drain_rate_, 0.0);
} else if(key == "drained") {
int drain = value.as_int();
if(drain == drained_segments_) {
return;
}
int animation_start_position = segments_-drained_segments_;
animation_current_position_ = 0;
drained_segments_after_anim_ = drain;
if(drained_segments_after_anim_ < 0) {
drained_segments_after_anim_ = 0;
}
if(drained_segments_after_anim_ > segments_) {
drained_segments_after_anim_ = segments_;
}
int animation_end_position = segments_-drained_segments_after_anim_;
animation_end_point_unscaled_ = animation_end_position - animation_start_position;
animating_ = true;
init();
} else if(key == "max_width") {
bar_max_width_ = value.as_int();
init();
} else if(key == "animation_position") {
animation_current_position_ = value.as_decimal().as_float();
}
widget::set_value(key, value);
}
variant variant::operator-(const variant& v) const
{
if(type_ == TYPE_DECIMAL || v.type_ == TYPE_DECIMAL) {
return variant( as_decimal() - v.as_decimal() , DECIMAL_VARIANT);
}
return variant(as_int() - v.as_int());
}
void playable_custom_object::set_player_value_by_slot(int slot, const variant& value)
{
switch(slot) {
case CUSTOM_OBJECT_PLAYER_DIFFICULTY:
difficulty_ = value.as_int();
break;
case CUSTOM_OBJECT_PLAYER_CAN_INTERACT:
can_interact_ = value.as_int();
break;
case CUSTOM_OBJECT_PLAYER_UNDERWATER_CONTROLS:
underwater_controls_ = value.as_bool();
break;
case CUSTOM_OBJECT_PLAYER_VERTICAL_LOOK:
vertical_look_ = value.as_int();
break;
case CUSTOM_OBJECT_PLAYER_CONTROL_LOCK:
if(value.is_null()) {
control_lock_.reset();
} else if(value.is_list()) {
unsigned char state = 0;
for(int n = 0; n != value.num_elements(); ++n) {
ASSERT_LOG(value[n].is_string(), "MEMBER OF control_lock LIST NOT A STRING");
const std::string& str = value[n].as_string();
int control_key = -1;
for(int m = 0; m != sizeof(ctrl)/sizeof(*ctrl); ++m) {
if(ctrl[m] == str) {
control_key = m;
break;
}
}
ASSERT_LOG(control_key != -1, "ILLEGAL STRING SET FOR control_lock: '" << str << "' LEGAL KEYS ARE ctrl_(up|down|left|right|attack|jump)");
state |= 1 << control_key;
}
//destroy the old one before creating a new control_lock,
//since control_lock objects must be constructed and destroyed
//in FIFO order.
control_lock_.reset();
control_lock_.reset(new controls::local_controls_lock(state));
} else {
ASSERT_LOG(false, "BAD VALUE WHEN SETTING control_lock KEY. A LIST OR NULL IS REQUIRED: " << value.to_debug_string());
}
break;
}
}
void radial_distortion::set_value(const std::string& key, const variant& value)
{
if(key == "radius") {
radius_ = value.as_int()/1000.0;
std::cerr << "set radius: " << radius_ << "\n";
set_area(rect(x_ - radius_, y_ - radius_, radius_*2, radius_*2));
}
}
variant variant::operator%(const variant& v) const
{
const int numerator = as_int();
const int denominator = v.as_int();
if(denominator == 0) {
throw type_error((formatter() << "divide by zero error").str());
}
return variant(numerator%denominator);
}
void luaW_pushfaivariant(lua_State* L, variant val) {
if(val.is_int()) {
lua_pushinteger(L, val.as_int());
} else if(val.is_decimal()) {
lua_pushnumber(L, val.as_decimal() / 1000.0);
} else if(val.is_string()) {
const std::string result_string = val.as_string();
lua_pushlstring(L, result_string.c_str(), result_string.size());
} else if(val.is_list()) {
lua_newtable(L);
for(const variant& v : val.as_list()) {
lua_pushinteger(L, lua_rawlen(L, -1) + 1);
luaW_pushfaivariant(L, v);
lua_settable(L, -3);
}
} else if(val.is_map()) {
typedef std::map<variant,variant>::value_type kv_type;
lua_newtable(L);
for(const kv_type& v : val.as_map()) {
luaW_pushfaivariant(L, v.first);
luaW_pushfaivariant(L, v.second);
lua_settable(L, -3);
}
} else if(val.is_callable()) {
// First try a few special cases
if(unit_callable* u_ref = val.try_convert<unit_callable>()) {
const unit& u = u_ref->get_unit();
unit_map::iterator un_it = resources::gameboard->units().find(u.get_location());
if(&*un_it == &u) {
luaW_pushunit(L, u.underlying_id());
} else {
luaW_pushunit(L, u.side(), u.underlying_id());
}
} else if(location_callable* loc_ref = val.try_convert<location_callable>()) {
luaW_pushlocation(L, loc_ref->loc());
} else {
// If those fail, convert generically to a map
const formula_callable* obj = val.as_callable();
std::vector<formula_input> inputs;
obj->get_inputs(&inputs);
lua_newtable(L);
for(const formula_input& attr : inputs) {
if(attr.access == FORMULA_WRITE_ONLY) {
continue;
}
lua_pushstring(L, attr.name.c_str());
luaW_pushfaivariant(L, obj->query_value(attr.name));
lua_settable(L, -3);
}
}
} else if(val.is_null()) {
lua_pushnil(L);
}
}
void graphical_font_label::set_value(const std::string& key, const variant& v)
{
if(key == "text") {
set_text(v.as_string());
} else if(key == "font") {
font_ = graphical_font::get(v.as_string());
ASSERT_LOG(font_.get(), "UNKNOWN FONT: " << v.as_string());
reset_text_dimensions();
} else if(key == "size") {
size_ = v.as_int();
reset_text_dimensions();
}
//widget::set_value(key);
}
variant variant::operator^(const variant& v) const
{
if( type_ == TYPE_DECIMAL || v.type_ == TYPE_DECIMAL ) {
double res = pow( as_decimal().value()/double(VARIANT_DECIMAL_PRECISION),
v.as_decimal().value()/double(VARIANT_DECIMAL_PRECISION));
res *= DECIMAL_PRECISION;
#if defined(TARGET_BLACKBERRY)
return variant(static_cast<int64_t>(llround(res)), DECIMAL_VARIANT);
#else
return variant(static_cast<int64_t>(res), DECIMAL_VARIANT);
#endif
}
return variant(static_cast<int>(pow(static_cast<double>(as_int()), v.as_int())));
}
void label::set_value(const std::string& key, const variant& v)
{
if(key == "text") {
if(v.is_null()) {
set_text("");
} else {
set_text(v.as_string());
}
} else if(key == "color") {
set_color(graphics::color(v).as_sdl_color());
} else if(key == "size") {
set_font_size(v.as_int());
} else if(key == "font") {
set_font(v.as_string());
}
widget::set_value(key, v);
}
variant variant::operator/(const variant& v) const
{
if(type_ == TYPE_DECIMAL || v.type_ == TYPE_DECIMAL) {
if(v.as_decimal().value() == 0) {
throw type_error((formatter() << "divide by zero error").str());
}
return variant(as_decimal() / v.as_decimal());
}
const int numerator = as_int();
const int denominator = v.as_int();
if(denominator == 0) {
throw type_error(formatter() << "divide by zero error");
}
return variant(numerator/denominator);
}
void widget::set_value(const std::string& key, const variant& v)
{
if(key == "width") {
w_ = v.as_int();
} else if(key == "height") {
h_ = v.as_int();
} else if(key == "rect" || key == "draw_area") {
std::vector<int> r = v.as_list_int();
ASSERT_LOG(r.size() == 4, "Four values must be supplied to the rect attribute");
set_loc(r[0], r[1]);
set_dim(r[2], r[3]);
} else if(key == "xy" || key == "left_top") {
std::vector<int> xy = v.as_list_int();
ASSERT_LOG(xy.size() == 2, "Two values must be supplied to the X, Y attribute");
set_loc(xy[0], xy[1]);
} else if(key == "wh") {
std::vector<int> wh = v.as_list_int();
ASSERT_LOG(wh.size() == 2, "Two values must be supplied to the W, H attribute");
set_dim(wh[0], wh[1]);
} else if(key == "right_bottom") {
std::vector<int> rb = v.as_list_int();
ASSERT_LOG(rb.size() == 2, "Two values must be supplied to the R, B attribute");
set_dim(rb[0] - x(), rb[1] - y());
} else if(key == "left") {
x_ = v.as_int();
} else if(key == "top") {
y_ = v.as_int();
} else if(key == "right") {
w_ = v.as_int() - x();
} else if(key == "bottom") {
h_ = v.as_int() - y();
} else if(key == "visible") {
visible_ = v.as_bool();
} else if(key == "id") {
id_ = v.as_string();
} else if(key == "disable") {
disabled_ = v.as_bool();
} else if(key == "enable") {
disabled_ = !v.as_bool();
} else if(key == "disabled_opacity") {
int opa = v.as_int();
disabled_opacity_ = (opa > 255) ? 255 : (opa < 0) ? 0 : opa;
}
}
variant variant::operator^(const variant& v) const
{
if( type_ == TYPE_DECIMAL || v.type_ == TYPE_DECIMAL ) {
double res = pow( as_decimal()/1000.0 , v.as_decimal()/1000.0 );
res *= 1000;
int i = static_cast<int>( res );
res -= i;
if( res > 0.5 )
i++;
return variant( i , variant::DECIMAL_VARIANT);
}
return variant(static_cast<int>(
round_portable(pow(static_cast<double>(as_int()), v.as_int()))));
}
variant variant::operator*(const variant& v) const
{
if(type_ == TYPE_DECIMAL || v.type_ == TYPE_DECIMAL) {
long long long_int = as_decimal();
long_int *= v.as_decimal();
long_int /= 100;
if( long_int%10 >= 5) {
long_int /= 10;
++long_int;
} else
long_int/=10;
return variant( static_cast<int>(long_int) , variant::DECIMAL_VARIANT );
}
return variant(as_int() * v.as_int());
}
variant variant::operator+(const variant& v) const
{
if(type_ == TYPE_LIST) {
if(v.type_ == TYPE_LIST) {
std::vector<variant> res;
res.reserve(list_->elements.size() + v.list_->elements.size());
for(size_t i = 0; i<list_->elements.size(); ++i) {
const variant& var = list_->elements[i];
res.push_back(var);
}
for(size_t j = 0; j<v.list_->elements.size(); ++j) {
const variant& var = v.list_->elements[j];
res.push_back(var);
}
return variant(&res);
}
}
if(type_ == TYPE_MAP) {
if(v.type_ == TYPE_MAP) {
std::map<variant,variant> res(map_->elements);
for(std::map<variant,variant>::const_iterator i = v.map_->elements.begin(); i != v.map_->elements.end(); ++i) {
res[i->first] = i->second;
}
return variant(&res);
}
}
if(type_ == TYPE_DECIMAL || v.type_ == TYPE_DECIMAL) {
return variant( as_decimal() + v.as_decimal() , DECIMAL_VARIANT);
}
return variant(as_int() + v.as_int());
}
variant variant::operator+(const variant& v) const
{
if(type_ == TYPE_INT && v.type_ == TYPE_INT) {
//strictly an optimization -- this is handled below, but the case
//of adding two integers is the most common so we want it to be fast.
return variant(int_value_ + v.int_value_);
}
if(type_ == TYPE_STRING) {
if(v.type_ == TYPE_MAP) {
return variant(as_string() + v.as_string());
} else if(v.type_ == TYPE_STRING) {
return variant(as_string() + v.as_string());
}
std::string s;
v.serialize_to_string(s);
return variant(as_string() + s);
}
if(v.type_ == TYPE_STRING) {
std::string s;
serialize_to_string(s);
return variant(s + v.as_string());
}
if(type_ == TYPE_DECIMAL || v.type_ == TYPE_DECIMAL) {
return variant(as_decimal() + v.as_decimal());
}
if(type_ == TYPE_INT) {
return variant(int_value_ + v.as_int());
}
if(type_ == TYPE_NULL) {
return v;
} else if(v.type_ == TYPE_NULL) {
return *this;
}
if(type_ == TYPE_LIST) {
if(v.type_ == TYPE_LIST) {
std::vector<variant> res;
res.reserve(list_->elements.size() + v.list_->elements.size());
for(size_t i = 0; i<list_->elements.size(); ++i) {
const variant& var = list_->elements[i];
res.push_back(var);
}
for(size_t j = 0; j<v.list_->elements.size(); ++j) {
const variant& var = v.list_->elements[j];
res.push_back(var);
}
return variant(&res);
}
}
if(type_ == TYPE_MAP) {
if(v.type_ == TYPE_MAP) {
std::map<variant,variant> res(map_->elements);
for(std::map<variant,variant>::const_iterator i = v.map_->elements.begin(); i != v.map_->elements.end(); ++i) {
res[i->first] = i->second;
}
return variant(&res);
}
}
return variant(as_int() + v.as_int());
}
static void variant_to_value(const variant &var, int &value)
{
value = var.as_int();
}
