static void test_group(CuTest * tc)
{
unit *u;
region *r;
faction *f;
group *g;
test_cleanup();
test_create_world();
r = findregion(0, 0);
f = test_create_faction(0);
assert(r && f);
u = test_create_unit(f, r);
assert(u);
CuAssertTrue(tc, join_group(u, "hodor"));
CuAssertPtrNotNull(tc, (g = get_group(u)));
CuAssertStrEquals(tc, "hodor", g->name);
CuAssertIntEquals(tc, 1, g->members);
set_group(u, 0);
CuAssertIntEquals(tc, 0, g->members);
CuAssertPtrEquals(tc, 0, get_group(u));
set_group(u, g);
CuAssertIntEquals(tc, 1, g->members);
CuAssertPtrEquals(tc, g, get_group(u));
test_cleanup();
}
void
BadGuy::set_state(State state_)
{
if(this->state == state_)
return;
State laststate = this->state;
this->state = state_;
switch(state_) {
case STATE_SQUISHED:
state_timer.start(SQUISH_TIME);
break;
case STATE_ACTIVE:
set_group(colgroup_active);
//bbox.set_pos(start_position);
break;
case STATE_INACTIVE:
// was the badguy dead anyway?
if(laststate == STATE_SQUISHED || laststate == STATE_FALLING) {
remove_me();
}
set_group(COLGROUP_DISABLED);
break;
case STATE_FALLING:
set_group(COLGROUP_DISABLED);
break;
default:
break;
}
}
void
IceCrusher::set_state(IceCrusherState state_, bool force)
{
if ((state == state_) && (!force)) return;
switch (state_) {
case IDLE:
set_group(COLGROUP_STATIC);
physic.enable_gravity (false);
m_sprite->set_action("idle");
break;
case CRUSHING:
set_group(COLGROUP_MOVING_STATIC);
physic.reset ();
physic.enable_gravity (true);
m_sprite->set_action("crushing");
break;
case RECOVERING:
set_group(COLGROUP_MOVING_STATIC);
physic.enable_gravity (false);
m_sprite->set_action("recovering");
break;
default:
log_debug << "IceCrusher in invalid state" << std::endl;
break;
}
state = state_;
}
ScriptedObject::ScriptedObject(const ReaderMapping& lisp) :
MovingSprite(lisp, "images/objects/bonus_block/brick.sprite", LAYER_OBJECTS, COLGROUP_MOVING_STATIC),
ExposedObject<ScriptedObject, scripting::ScriptedObject>(this),
physic(),
solid(),
physic_enabled(),
visible(),
new_vel_set(false),
new_vel(),
new_size()
{
if (!lisp.get("name", name)) name = "";
if(name.empty()) {
name = "unnamed" + std::to_string(graphicsRandom.rand());
log_warning << "Scripted object must have a name specified, setting to: " << name << std::endl;
}
if (!lisp.get("solid", solid)) solid = true;
if (!lisp.get("physic-enabled", physic_enabled)) physic_enabled = true;
if (!lisp.get("visible", visible)) visible = true;
layer = reader_get_layer (lisp, /* default = */ LAYER_OBJECTS);
if( solid ) {
set_group( COLGROUP_MOVING_STATIC );
} else {
set_group( COLGROUP_DISABLED );
}
}
void
Player::set_visible(bool visible_)
{
this->visible = visible_;
if( visible_ )
set_group(COLGROUP_MOVING);
else
set_group(COLGROUP_DISABLED);
}
void
ScriptedObject::set_solid(bool solid_)
{
this->solid = solid_;
if( solid ){
set_group( COLGROUP_MOVING_STATIC );
} else {
set_group( COLGROUP_DISABLED );
}
}
dvl::pid_table::pid_table()
{
//register internal ids
set_group(pid().set_group(GROUP_INTERNAL), L"INTERNAL");
set_element(EMPTY, L"EMPTY");
set_element(PARSER, L"PARSER");
//register diagnostic routines
set_group(pid().set_group(GROUP_DIAGNOSTIC), L"DIAGNOSTIC");
set_element(ECHO, L"ECHO");
}
void recoder::init()
{
guard g(m_lock);
set_group("recoder");
set_state(STATE_WAIT);
init_timeout(FLAGS_recoder_timeout);
/* reset counters */
m_budget = 0;
m_rec_pkt_count = 0;
m_io->read_one_hops(_key.dst);
helper_msg best_helper = m_io->get_best_one_hop(_key.dst);
if (best_helper.tq_total == 0) {
VLOG(LOG_GEN) << "Recoder " << m_coder << ": No best one hop";
m_max_budget = this->symbols()*FLAGS_fixed_overshoot;
return;
}
m_io->read_link(best_helper.addr);
m_io->read_link(_key.dst);
e1 = ONE - m_io->get_link(best_helper.addr);
e2 = ONE - best_helper.tq_second_hop * 4.5; // Scale to revert hop penalty
e3 = ONE - m_io->get_link(_key.dst);
if (e1 == ONE || e2 == ONE || e3 == ONE) {
VLOG(LOG_GEN) << "Recoder " << m_coder << ": Missing link estimate";
m_max_budget = this->symbols()*FLAGS_fixed_overshoot;
return;
}
m_max_budget = recoder_budget(this->symbols(), e1, e2, e3);
VLOG(LOG_GEN) << "Recoder " << m_coder << ": Initialized" << _key;
}
static void
hippo_block_group_revision_update (HippoBlock *block)
{
HippoBlockGroupRevision *block_group_revision = HIPPO_BLOCK_GROUP_REVISION(block);
DDMDataResource *group_resource;
DDMDataResource *revision_resource;
HippoGroup *group = NULL;
HIPPO_BLOCK_CLASS(hippo_block_group_revision_parent_class)->update(block);
ddm_data_resource_get(block->resource,
"group", DDM_DATA_RESOURCE, &group_resource,
"revision", DDM_DATA_RESOURCE, &revision_resource,
NULL);
if (group_resource != NULL)
group = hippo_group_get_for_resource(group_resource);
set_group(block_group_revision, group);
update_edit_link(block_group_revision);
update_chat_id(block_group_revision);
if (group != NULL)
g_object_unref(group);
}
void
Fish::jump()
{
physic.set_velocity_y(FISH_JUMP_POWER);
physic.enable_gravity(true);
set_group(COLGROUP_MOVING);
}
void
WeakBlock::update(float )
{
switch (state) {
case STATE_NORMAL:
break;
case STATE_BURNING:
if (sprite->animation_done()) {
state = STATE_DISINTEGRATING;
sprite->set_action("disintegrating", 1);
flags &= ~FLAG_SOLID;
set_group(COLGROUP_DISABLED);
}
break;
case STATE_DISINTEGRATING:
if (sprite->animation_done()) {
remove_me();
return;
}
break;
}
}
void
MrIceBlock::ungrab(MovingObject& , Direction dir)
{
this->dir = dir;
set_state(dir == UP ? ICESTATE_FLAT : ICESTATE_KICKED);
set_group(COLGROUP_MOVING);
}
void
Player::set_ghost_mode(bool enable)
{
if (ghost_mode == enable) return;
if (enable) {
ghost_mode = true;
set_group(COLGROUP_DISABLED);
physic.enable_gravity(false);
log_debug << "You feel lightheaded. Use movement controls to float around, press ACTION to scare badguys." << std::endl;
} else {
ghost_mode = false;
set_group(COLGROUP_MOVING);
physic.enable_gravity(true);
log_debug << "You feel solid again." << std::endl;
}
}
void Yeti::take_hit(Player& )
{
if(safe_timer.started())
return;
sound_manager->play("sounds/yeti_roar.wav");
hit_points--;
if(hit_points <= 0) {
// We're dead
physic.enable_gravity(true);
physic.set_velocity_x(0);
physic.set_velocity_y(0);
state = SQUISHED;
state_timer.start(SQUISH_TIME);
set_group(COLGROUP_MOVING_ONLY_STATIC);
sprite->set_action("dead");
if (countMe) Sector::current()->get_level()->stats.badguys++;
if(dead_script != "") {
std::istringstream stream(dead_script);
Sector::current()->run_script(stream, "Yeti - dead-script");
}
}
else {
safe_timer.start(SAFE_TIME);
}
}
void item_palette::setup(const config& cfg)
{
for (const config& group : cfg.child_range("item_group")) {
groups_.push_back(item_group(group));
for (const config& item : group.child_range("item")) {
item_map_.insert(std::pair<std::string, overlay>(item["id"], overlay(item)));
group_map_[group["id"]].push_back(item["id"]);
if (!group["core"].to_bool(false))
non_core_items_.insert(item["id"]);
}
nmax_items_ = std::max(nmax_items_, group_map_[group["id"]].size());
}
select_fg_item("anvil");
select_bg_item("altar");
// Set the default group
set_group("items");
if(active_group().empty()) {
ERR_ED << "No items found." << std::endl;
}
}
Block::Block(const ReaderMapping& lisp, const std::string& sprite_file) :
sprite(),
sprite_name(),
default_sprite_name(),
bouncing(false),
breaking(false),
bounce_dir(0),
bounce_offset(0),
original_y(-1)
{
lisp.get("x", bbox.p1.x);
lisp.get("y", bbox.p1.y);
std::string sf;
lisp.get("sprite", sf);
if (sf.empty() || !PHYSFS_exists(sf.c_str())) {
sf = sprite_file;
}
sprite = SpriteManager::current()->create(sf);
sprite_name = sf;
default_sprite_name = sprite_name;
bbox.set_size(32, 32.1f);
set_group(COLGROUP_STATIC);
SoundManager::current()->preload("sounds/upgrade.wav");
SoundManager::current()->preload("sounds/brick.wav");
}
Wind::Wind(const ReaderMapping& reader) :
blowing(true),
speed(),
acceleration(100),
elapsed_time(0)
{
reader.get("name", name);
reader.get("x", bbox.p1.x);
reader.get("y", bbox.p1.y);
float w = 32, h = 32;
reader.get("width", w);
reader.get("height", h);
bbox.set_size(w, h);
reader.get("blowing", blowing);
float speed_x = 0, speed_y = 0;
reader.get("speed-x", speed_x);
reader.get("speed-y", speed_y);
speed = Vector(speed_x, speed_y);
reader.get("acceleration", acceleration);
set_group(COLGROUP_TOUCHABLE);
}
void
UnstableTile::update(float elapsed_time)
{
switch (state) {
case STATE_NORMAL:
break;
case STATE_CRUMBLING:
if (sprite->animation_done()) {
state = STATE_DISINTEGRATING;
sprite->set_action("disintegrating", 1);
set_group(COLGROUP_DISABLED);
physic.enable_gravity(true);
}
break;
case STATE_DISINTEGRATING:
movement = physic.get_movement(elapsed_time);
if (sprite->animation_done()) {
remove_me();
return;
}
break;
}
}
static Cmdret conf_syntax(List *args)
{
log_msg("CONFIG", "conf_syntax");
char *group = list_arg(args, 1, VAR_STRING);
List *words = list_arg(args, 2, VAR_LIST);
char *single = list_arg(args, 2, VAR_STRING);
if (!group && (!words || !single))
return NORET;
fn_group *grp = get_group(group);
if (!grp)
grp = set_group(group);
if (single) {
fn_syn syn = {
.key = strdup(single),
.group = grp,
};
set_syn(&syn);
return NORET;
}
log_msg("CONFIG", "# %d", utarray_len(words->items));
for (int i = 0; i < utarray_len(words->items); i++) {
fn_syn syn = {
.key = strdup(list_arg(words, i, VAR_STRING)),
.group = grp,
};
set_syn(&syn);
}
return NORET;
}
Flower::Flower(BonusType _type) :
type(_type),
sprite(),
drawing_effect(NO_EFFECT),
light(1.0f,1.0f,1.0f),
lightsprite(SpriteManager::current()->create("images/objects/lightmap_light/lightmap_light-small.sprite"))
{
bbox.set_size(32, 32);
lightsprite->set_blend(Blend(GL_SRC_ALPHA, GL_ONE));
if(type == FIRE_BONUS) {
sprite = SpriteManager::current()->create("images/powerups/fireflower/fireflower.sprite");
SoundManager::current()->preload("sounds/fire-flower.wav");
lightsprite->set_color(Color(0.3f, 0.0f, 0.0f));
}
else if(type == ICE_BONUS) {
sprite = SpriteManager::current()->create("images/powerups/iceflower/iceflower.sprite");
SoundManager::current()->preload("sounds/fire-flower.wav");
lightsprite->set_color(Color(0.0f, 0.1f, 0.2f));
}
else if(type == AIR_BONUS) {
sprite = SpriteManager::current()->create("images/powerups/airflower/airflower.sprite");
SoundManager::current()->preload("sounds/fire-flower.wav");
lightsprite->set_color(Color(0.15f, 0.0f, 0.15f));
}
else if(type == EARTH_BONUS) {
sprite = SpriteManager::current()->create("images/powerups/earthflower/earthflower.sprite");
SoundManager::current()->preload("sounds/fire-flower.wav");
lightsprite->set_color(Color(0.0f, 0.3f, 0.0f));
} else {
assert(false);
}
set_group(COLGROUP_TOUCHABLE);
}
void encoder::init()
{
guard g(m_lock);
set_group("encoder");
set_state(STATE_WAIT);
init_timeout(FLAGS_encoder_timeout);
/* allocate memory for encoder */
if (!m_symbol_storage)
m_symbol_storage = new uint8_t[this->block_size()];
/* reset counters */
m_plain_pkt_count = 0;
m_enc_pkt_count = 0;
m_last_req_seq = 0;
m_type = ENC_PACKET;
m_io->read_link(_key.dst);
m_io->read_one_hops(_key.dst);
helper_msg best_helper = m_io->get_best_one_hop(_key.dst);
m_io->read_link(best_helper.addr);
/*
e1 = ONE - m_io->get_link(best_helper.addr);
e2 = ONE - best_helper.tq_second_hop * 4.5; // Scale to revert hop penalty
e3 = ONE - m_io->get_link(_key.dst);
*/
m_max_budget = source_budget(this->symbols(), m_e1, m_e2, m_e3);
VLOG(LOG_GEN) << "Encoder " << m_coder << ": Initialized (B: "
<< m_max_budget << ") " << _key;
}
void
Dispenser::freeze()
{
set_group(COLGROUP_MOVING_STATIC);
frozen = true;
if(type == DT_ROCKETLAUNCHER && sprite->has_action("iced-left"))
// Only swivel dispensers can use their left/right iced actions.
sprite->set_action(dir == LEFT ? "iced-left" : "iced-right", 1);
// when the sprite doesn't have separate actions for left and right or isn't a rocketlauncher,
// it tries to use an universal one.
else
{
if(type == DT_CANNON && sprite->has_action("iced"))
sprite->set_action("iced", 1);
// When is the dispenser a cannon, it uses the "iced" action.
else
{
if(sprite->has_action("dropper-iced"))
sprite->set_action("dropper-iced", 1);
// When is the dispenser a dropper, it uses the "dropper-iced".
else
{
sprite->set_color(Color(0.60, 0.72, 0.88f));
sprite->stop_animation();
// When is the dispenser something else (unprobable), or has no matching iced sprite, it shades to blue.
}
}
}
dispense_timer.stop();
}
WinAbsSD::WinAbsSD(PSID owner, PSID group, PACL dacl, bool protect):
m_owner(nullptr),
m_group(nullptr),
m_dacl(nullptr),
m_sacl(nullptr)
{
m_sd = alloc(SECURITY_DESCRIPTOR_MIN_LENGTH);
CheckApi(::InitializeSecurityDescriptor(m_sd, SECURITY_DESCRIPTOR_REVISION));
try {
m_owner = Sid::clone(owner);
set_owner(m_sd, m_owner);
} catch (exception::Abstract & e) {
LogDebug(L"exception cought: %s, %s", e.what(), e.where());
}
try {
m_group = Sid::clone(group);
set_group(m_sd, m_group);
} catch (exception::Abstract & e) {
LogDebug(L"exception cought: %s, %s", e.what(), e.where());
}
try {
WinDacl(dacl).detach(m_dacl);
set_dacl(m_sd, m_dacl);
} catch (exception::Abstract & e) {
LogDebug(L"exception cought: %s, %s", e.what(), e.where());
}
CheckApi(::IsValidSecurityDescriptor(m_sd));
set_protect(protect);
}
Block::Block(Sprite* newsprite)
: sprite(newsprite), bouncing(false), bounce_dir(0), bounce_offset(0)
{
bbox.set_size(32, 32.1);
set_group(COLGROUP_STATIC);
sound_manager->preload("sounds/upgrade.wav");
sound_manager->preload("sounds/brick.wav");
}
void
GhostTree::activate()
{
willowisp_timer.start(1.0f, true);
colorchange_timer.start(13, true);
root_timer.start(5, true);
set_group(COLGROUP_TOUCHABLE);
}
LicenseItem::LicenseItem (struct rdf_license_t const* license, EntityEntry* entity, Registry &wr)
: Gtk::RadioButton(_(license->name)), _lic(license), _eep(entity), _wr(wr)
{
static Gtk::RadioButtonGroup group = get_group();
static bool first = true;
if (first) first = false;
else set_group (group);
}
void
Fish::start_waiting()
{
waiting.start(FISH_WAIT_TIME);
set_group(COLGROUP_DISABLED);
physic.enable_gravity(false);
physic.set_velocity_y(0);
}
HeavyCoin::HeavyCoin(const Reader& reader)
: Coin(reader),
physic()
{
physic.enable_gravity(true);
SoundManager::current()->preload("sounds/coin2.ogg");
set_group(COLGROUP_MOVING);
}
MovingSprite::MovingSprite(const Vector& pos, const std::string& sprite_name, int layer, CollisionGroup collision_group)
: sprite_name(sprite_name), layer(layer)
{
bbox.set_pos(pos);
sprite = sprite_manager->create(sprite_name);
bbox.set_size(sprite->get_current_hitbox_width(), sprite->get_current_hitbox_height());
set_group(collision_group);
}
/* The following defines a coin subject to gravity */
HeavyCoin::HeavyCoin(const Vector& pos, const Vector& init_velocity)
: Coin(pos),
physic()
{
physic.enable_gravity(true);
SoundManager::current()->preload("sounds/coin2.ogg");
set_group(COLGROUP_MOVING);
physic.set_velocity(init_velocity);
}
