HitResponse
MoleRock::collision_badguy(BadGuy& badguy, const CollisionHit& )
{
// ignore collisions with parent
if (&badguy == parent) {
return FORCE_MOVE;
}
sound_manager->play("sounds/stomp.wav", get_pos());
remove_me();
badguy.kill_fall();
return ABORT_MOVE;
}
void
MrRocket::active_update(float elapsed_time)
{
if (collision_timer.check()) {
Sector::current()->add_object(new RocketExplosion(get_pos(), dir));
remove_me();
}
else if (!collision_timer.started()) {
movement=physic.get_movement(elapsed_time);
sprite->set_action(dir == LEFT ? "left" : "right");
}
}
HitResponse
Star::collision(GameObject& other, const CollisionHit& )
{
Player* player = dynamic_cast<Player*> (&other);
if(player) {
player->make_invincible();
remove_me();
return ABORT_MOVE;
}
return FORCE_MOVE;
}
void
Flame::active_update(float elapsed_time)
{
angle = fmodf(angle + elapsed_time * speed, (float) (2*M_PI));
Vector newpos(start_position.x + cos(angle) * radius,
start_position.y + sin(angle) * radius);
movement = newpos - get_pos();
sound_source->set_position(get_pos());
if (sprite->get_action() == "fade" && sprite->animation_done()) remove_me();
}
void
BadGuy::update(float elapsed_time)
{
if(!Sector::current()->inside(bbox)) {
is_active_flag = false;
remove_me();
return;
}
if ((state != STATE_INACTIVE) && is_offscreen()) {
if (state == STATE_ACTIVE) deactivate();
set_state(STATE_INACTIVE);
}
switch(state) {
case STATE_ACTIVE:
is_active_flag = true;
active_update(elapsed_time);
break;
case STATE_INIT:
case STATE_INACTIVE:
is_active_flag = false;
inactive_update(elapsed_time);
try_activate();
break;
case STATE_SQUISHED:
is_active_flag = false;
if(state_timer.check()) {
remove_me();
break;
}
movement = physic.get_movement(elapsed_time);
break;
case STATE_FALLING:
is_active_flag = false;
movement = physic.get_movement(elapsed_time);
break;
}
on_ground_flag = false;
}
LevelTime::LevelTime(const ReaderMapping& reader) :
GameObject(reader),
ExposedObject<LevelTime, scripting::LevelTime>(this),
time_surface(Surface::create("images/engine/hud/time-0.png")),
running(!Editor::is_active()),
time_left()
{
reader.get("time", time_left, 0);
if(time_left <= 0 && !Editor::is_active()) {
log_warning << "No or invalid leveltime specified." << std::endl;
remove_me();
}
}
void
WillOWisp::active_update(float elapsed_time)
{
Player* player = get_nearest_player();
if (!player) return;
Vector p1 = this->get_pos() + (this->get_bbox().p2 - this->get_bbox().p1) / 2;
Vector p2 = player->get_pos() + (player->get_bbox().p2 - player->get_bbox().p1) / 2;
Vector dist = (p2 - p1);
if (mystate == STATE_IDLE) {
if (dist.norm() <= TRACK_RANGE) {
mystate = STATE_TRACKING;
}
}
if (mystate == STATE_TRACKING) {
if (dist.norm() <= VANISH_RANGE) {
Vector dir = dist.unit();
movement = dir*elapsed_time*FLYSPEED;
} else {
mystate = STATE_VANISHING;
sprite->set_action("vanishing", 1);
}
soundSource->set_position(get_pos());
}
if (mystate == STATE_WARPING) {
if(sprite->animation_done()) {
remove_me();
}
}
if (mystate == STATE_VANISHING) {
if(sprite->animation_done()) {
remove_me();
}
}
}
void
EditorInputCenter::delete_markers() {
auto sector = Editor::current()->currentsector;
for (auto& moving_object : sector->moving_objects) {
auto marker = dynamic_cast<PointMarker*>(moving_object);
if (marker) {
marker->remove_me();
}
}
marked_object = NULL;
edited_path = NULL;
last_node_marker = NULL;
}
LevelTime::LevelTime(const ReaderMapping& reader) :
time_surface(),
running(true),
time_left()
{
if (!reader.get("name", name)) name = "";
if (!reader.get("time", time_left)) time_left = 0;
if(time_left <= 0) {
log_warning << "No or invalid leveltime specified." << std::endl;
remove_me();
}
time_surface = Surface::create("images/engine/hud/time-0.png");
}
void
Upgrade::collision(void* p_c_object, int c_object, CollisionType type)
{
Player* pplayer = NULL;
if(type == COLLISION_BUMP) {
if(c_object == CO_PLAYER)
pplayer = (Player*) p_c_object;
bump(pplayer);
return;
}
switch (c_object)
{
case CO_PLAYER:
/* Remove the upgrade: */
/* p_c_object is CO_PLAYER, so assign it to pplayer */
pplayer = (Player*) p_c_object;
/* Affect the player: */
if (kind == UPGRADE_GROWUP)
{
play_sound(sounds[SND_EXCELLENT], SOUND_CENTER_SPEAKER);
pplayer->grow();
}
else if (kind == UPGRADE_ICEFLOWER)
{
play_sound(sounds[SND_COFFEE], SOUND_CENTER_SPEAKER);
pplayer->grow();
pplayer->got_coffee = true;
}
else if (kind == UPGRADE_HERRING)
{
play_sound(sounds[SND_HERRING], SOUND_CENTER_SPEAKER);
pplayer->invincible_timer.start(TUX_INVINCIBLE_TIME);
World::current()->play_music(HERRING_MUSIC);
}
else if (kind == UPGRADE_1UP)
{
if(player_status.lives < MAX_LIVES) {
player_status.lives++;
play_sound(sounds[SND_LIFEUP], SOUND_CENTER_SPEAKER);
}
}
remove_me();
return;
}
}
void
SpriteParticle::update(float elapsed_time)
{
// die when animation is complete
if (sprite->animation_done()) {
remove_me();
return;
}
// calculate new position and velocity
position.x += velocity.x * elapsed_time;
position.y += velocity.y * elapsed_time;
velocity.x += acceleration.x * elapsed_time;
velocity.y += acceleration.y * elapsed_time;
// die when too far offscreen
Vector camera = Sector::current()->camera->get_translation();
if ((position.x < camera.x - 128) || (position.x > SCREEN_WIDTH + camera.x + 128) ||
(position.y < camera.y - 128) || (position.y > SCREEN_HEIGHT + camera.y + 128)) {
remove_me();
return;
}
}
void
RustyTrampoline::update(float elapsed_time)
{
if(sprite->animation_done()) {
if (counter < 1) {
remove_me();
} else {
sprite->set_action("normal");
}
}
Rock::update(elapsed_time);
}
void
SecretAreaTrigger::draw(DrawingContext& context)
{
if (message_timer.started()) {
context.push_transform();
context.set_translation(Vector(0, 0));
Vector pos = Vector(0, SCREEN_HEIGHT/2 - Resources::normal_font->get_height()/2);
context.draw_center_text(Resources::normal_font, message, pos, LAYER_HUD, SecretAreaTrigger::text_color);
context.pop_transform();
}
if (message_timer.check()) {
remove_me();
}
}
HitResponse
Flower::collision(GameObject& other, const CollisionHit& )
{
Player* player = dynamic_cast<Player*>(&other);
if(!player)
return ABORT_MOVE;
if(!player->add_bonus(type, true))
return FORCE_MOVE;
SoundManager::current()->play("sounds/fire-flower.wav");
remove_me();
return ABORT_MOVE;
}
void
Bullet::collision_solid(const CollisionHit& hit)
{
if(hit.top || hit.bottom) {
physic.set_velocity_y(-physic.get_velocity_y());
life_count--;
} else if(hit.left || hit.right) {
if(type == ICE_BONUS) {
physic.set_velocity_x(-physic.get_velocity_x());
life_count--;
} else
remove_me();
}
}
void
Explosion::update(float )
{
switch(state) {
case STATE_WAITING:
explode();
break;
case STATE_EXPLODING:
if(sprite->animation_done()) {
remove_me();
}
break;
}
}
void
SkyDive::explode (void)
{
if (!is_valid())
return;
auto explosion = std::make_shared<Explosion>(get_anchor_pos (bbox, ANCHOR_BOTTOM));
explosion->hurts(true);
explosion->pushes(false);
Sector::current()->add_object(explosion);
remove_me ();
} /* void explode */
bool
MrTree::collision_squished(GameObject& object)
{
// replace with Stumpy
Vector stumpy_pos = get_pos();
stumpy_pos.x += 20;
stumpy_pos.y += 25;
Stumpy* stumpy = new Stumpy(stumpy_pos, dir);
remove_me();
Sector::current()->add_object(stumpy);
// give Feedback
sound_manager->play("sounds/mr_tree.ogg", get_pos());
Player* player = dynamic_cast<Player*>(&object);
if (player) player->bounce(*this);
// spawn some particles
// TODO: provide convenience function in MovingSprite or MovingObject?
for (int px = (int)stumpy->get_bbox().p1.x; px < (int)stumpy->get_bbox().p2.x; px+=10) {
Vector ppos = Vector(px, stumpy->get_bbox().p1.y-5);
float angle = systemRandom.randf(-M_PI_2, M_PI_2);
float velocity = systemRandom.randf(45, 90);
float vx = sin(angle)*velocity;
float vy = -cos(angle)*velocity;
Vector pspeed = Vector(vx, vy);
Vector paccel = Vector(0, 100);
Sector::current()->add_object(new SpriteParticle("images/objects/particles/leaf.sprite", "default", ppos, ANCHOR_MIDDLE, pspeed, paccel, LAYER_OBJECTS-1));
}
// spawn PoisonIvy
Vector leaf1_pos = Vector(stumpy_pos.x - POISONIVY_WIDTH - 1, stumpy_pos.y - POISONIVY_Y_OFFSET);
Rect leaf1_bbox = Rect(leaf1_pos.x, leaf1_pos.y, leaf1_pos.x + POISONIVY_WIDTH, leaf1_pos.y + POISONIVY_HEIGHT);
if (Sector::current()->is_free_of_movingstatics(leaf1_bbox, this)) {
PoisonIvy* leaf1 = new PoisonIvy(leaf1_bbox.p1, LEFT);
leaf1 = leaf1;
Sector::current()->add_object(leaf1);
}
// spawn PoisonIvy
Vector leaf2_pos = Vector(stumpy_pos.x + sprite->get_current_hitbox_width() + 1, stumpy_pos.y - POISONIVY_Y_OFFSET);
Rect leaf2_bbox = Rect(leaf2_pos.x, leaf2_pos.y, leaf2_pos.x + POISONIVY_WIDTH, leaf2_pos.y + POISONIVY_HEIGHT);
if (Sector::current()->is_free_of_movingstatics(leaf2_bbox, this)) {
PoisonIvy* leaf2 = new PoisonIvy(leaf2_bbox.p1, RIGHT);
leaf2 = leaf2;
Sector::current()->add_object(leaf2);
}
return true;
}
void
Haywire::kill_fall()
{
if(is_exploding) {
ticking->stop();
grunting->stop();
}
if(is_valid()) {
remove_me();
auto explosion = std::make_shared<Explosion>(get_bbox().get_middle());
Sector::current()->add_object(explosion);
}
run_dead_script();
}
void UnstableTile::fall_down (void)
{
if ((state != STATE_NORMAL) && (state != STATE_DISSOLVE))
return;
if (sprite->has_action ("fall-down")) {
state = STATE_FALL;
this->set_action ("fall-down", /* loops = */ 1);
set_group (COLGROUP_DISABLED);
physic.enable_gravity (true);
}
else {
remove_me ();
}
}
void UnstableTile::fall_down()
{
if (state == STATE_FALL)
return;
if (sprite->has_action ("fall-down")) {
state = STATE_FALL;
set_action ("fall-down", /* loops = */ 1);
physic.set_gravity_modifier (.98f);
physic.enable_gravity (true);
}
else {
remove_me ();
}
}
void
ShortFuse::explode()
{
if (!is_valid())
return;
auto explosion = std::make_shared<Explosion>(get_bbox ().get_middle());
explosion->hurts(false);
explosion->pushes(true);
Sector::current()->add_object(explosion);
run_dead_script();
remove_me();
}
HitResponse
OneUp::collision(GameObject& other, const CollisionHit& )
{
Player* player = dynamic_cast<Player*> (&other);
if(player) {
player->get_status()->add_coins(100);
#if 0
// FIXME: do we want this? q.v. src/level.cpp
Sector::current()->get_level()->stats.coins += 100;
#endif
remove_me();
return ABORT_MOVE;
}
return FORCE_MOVE;
}
void
Haywire::kill_fall()
{
if(is_exploding) {
ticking->stop();
grunting->stop();
}
if(is_valid()) {
remove_me();
Explosion* explosion = new Explosion(get_bbox().get_middle());
Sector::current()->add_object(explosion);
}
run_dead_script();
}
void cdrop_widget::handling_entry_drop_event(quint32 our_index, QString drop_event_text)
{
//adding that thing here
// qDebug() << drop_event_text;
cdrop_widget_entry* adde;
//this decides if we start a "initial edit dialog"
//after creating everything
bool firstblood = false;
//diff between template btn drag and other dropped entry
if ( drop_event_text.contains( "gnurpgm::drop::" ) )
{
firstblood = true;
drop_event_text.remove( "gnurpgm::drop::" );
adde = new cdrop_widget_entry( drop_event_text.toInt(),
this->elements.count(),
this );
}
else
{
//create new entry as a copy from the old one
//this is also used when initial loading entries into the drop widget
drop_event_text.remove( "gnurpgm::eventeditor::entrydrop::" );
adde = new cdrop_widget_entry( drop_event_text,
this->elements.count(),
this );
}
QObject::connect( adde, SIGNAL(got_something_dropped_here(quint32,QString)),
this, SLOT(handling_entry_drop_event(quint32,QString)) );
QObject::connect( adde, SIGNAL(remove_me(quint32)),
this, SLOT(remove_entry_on_request(quint32)) );
QObject::connect( adde, SIGNAL(edit_me(quint32)),
this, SLOT(edit_entry_on_request(quint32)) );
this->elements.insert( our_index, adde );
//initial edit dialog
if ( firstblood == true )
this->edit_entry_on_request( our_index );
this->relayouting();
adde->clear_stack_cache();
}
void
Platform::update(float elapsed_time)
{
if (!path->is_valid()) {
remove_me();
return;
}
// check if Platform should automatically pick a destination
if (automatic) {
if (!player_contact && !walker->is_moving()) {
// Player doesn't touch platform and Platform is not moving
// Travel to node nearest to nearest player
auto player = Sector::current()->get_nearest_player(bbox);
if (player) {
int nearest_node_id = path->get_nearest_node_no(player->get_bbox().p2);
if (nearest_node_id != -1) {
goto_node(nearest_node_id);
}
}
}
if (player_contact && !last_player_contact && !walker->is_moving()) {
// Player touched platform, didn't touch last frame and Platform is not moving
// Travel to node farthest from current position
int farthest_node_id = path->get_farthest_node_no(get_pos());
if (farthest_node_id != -1) {
goto_node(farthest_node_id);
}
}
// Clear player_contact flag set by collision() method
last_player_contact = player_contact;
player_contact = false;
}
Vector new_pos = walker->advance(elapsed_time);
if (Editor::is_active()) {
set_pos(new_pos);
} else {
movement = new_pos - get_pos();
speed = movement / elapsed_time;
}
}
bool
MrBomb::collision_squished(GameObject& object)
{
auto player = dynamic_cast<Player*>(&object);
if(player && player->is_invincible()) {
player->bounce(*this);
kill_fall();
return true;
}
if(is_valid()) {
remove_me();
Sector::current()->add_object(std::make_shared<Bomb>(get_pos(), dir, sprite_name));
}
kill_squished(object);
return true;
}
void
Block::break_me()
{
Sector* sector = Sector::current();
sector->add_object(
std::make_shared<BrokenBrick>(sprite->clone(), get_pos(), Vector(-100, -400)));
sector->add_object(
std::make_shared<BrokenBrick>(sprite->clone(), get_pos() + Vector(0, 16),
Vector(-150, -300)));
sector->add_object(
std::make_shared<BrokenBrick>(sprite->clone(), get_pos() + Vector(16, 0),
Vector(100, -400)));
sector->add_object(
std::make_shared<BrokenBrick>(sprite->clone(), get_pos() + Vector(16, 16),
Vector(150, -300)));
remove_me();
}
void
Snail::active_update(float dt_sec)
{
if (state == STATE_GRABBED)
return;
if (m_frozen)
{
BadGuy::active_update(dt_sec);
return;
}
switch (state) {
case STATE_NORMAL:
WalkingBadguy::active_update(dt_sec);
return;
case STATE_FLAT:
if (m_sprite->animation_done()) {
be_normal();
}
break;
case STATE_KICKED_DELAY:
if (kicked_delay_timer.check()) {
m_physic.set_velocity_x(m_dir == Direction::LEFT ? -SNAIL_KICK_SPEED : SNAIL_KICK_SPEED);
m_physic.set_velocity_y(SNAIL_KICK_SPEED_Y);
state = STATE_KICKED;
}
break;
case STATE_KICKED:
m_physic.set_velocity_x(m_physic.get_velocity_x() * powf(0.99f, dt_sec/0.02f));
if (m_sprite->animation_done() || (fabsf(m_physic.get_velocity_x()) < walk_speed)) be_normal();
break;
case STATE_GRABBED:
break;
}
BadGuy::active_update(dt_sec);
if (m_ignited)
remove_me();
}
void
Block::break_me()
{
Sector* sector = Sector::current();
sector->add_object(
new BrokenBrick(new Sprite(*sprite), get_pos(), Vector(-100, -400)));
sector->add_object(
new BrokenBrick(new Sprite(*sprite), get_pos() + Vector(0, 16),
Vector(-150, -300)));
sector->add_object(
new BrokenBrick(new Sprite(*sprite), get_pos() + Vector(16, 0),
Vector(100, -400)));
sector->add_object(
new BrokenBrick(new Sprite(*sprite), get_pos() + Vector(16, 16),
Vector(150, -300)));
remove_me();
}
