void
WillOWisp::vanish()
{
mystate = STATE_VANISHING;
sprite->set_action("vanishing", 1);
set_colgroup_active(COLGROUP_DISABLED);
}
void
Fish::jump()
{
physic.set_velocity_y(FISH_JUMP_POWER);
physic.enable_gravity(true);
set_colgroup_active(COLGROUP_MOVING);
}
void
GoldBomb::ungrab(MovingObject& object, Direction dir_)
{
int toss_velocity_x = 0;
int toss_velocity_y = 0;
auto player = dynamic_cast<Player*> (&object);
// toss upwards
if(dir_ == UP)
toss_velocity_y += -500;
// toss to the side when moving sideways
if(player && player->m_physic.get_velocity_x()*(dir_ == LEFT ? -1 : 1) > 1) {
toss_velocity_x += (dir_ == LEFT) ? -200 : 200;
toss_velocity_y = (toss_velocity_y < -200) ? toss_velocity_y : -200;
// toss farther when running
if(player && player->m_physic.get_velocity_x()*(dir_ == LEFT ? -1 : 1) > 200)
toss_velocity_x += static_cast<int>(player->m_physic.get_velocity_x() - (190*(dir_ == LEFT ? -1 : 1)));
}
log_warning << toss_velocity_x << toss_velocity_y << std::endl;////
//set_pos(object.get_pos() + Vector((dir_ == LEFT ? -33 : 33), get_bbox().get_height()*0.66666 - 32));
physic.set_velocity(static_cast<float>(toss_velocity_x),
static_cast<float>(toss_velocity_y));
set_colgroup_active(COLGROUP_MOVING);
grabbed = false;
}
void
MrBomb::ungrab(MovingObject& , Direction dir_)
{
this->dir = dir_;
set_colgroup_active(COLGROUP_MOVING);
grabbed = false;
}
void
Bomb::ungrab(MovingObject& object, Direction dir_)
{
this->dir = dir_;
// This object is now thrown.
int toss_velocity_x = 0;
int toss_velocity_y = 0;
auto player = dynamic_cast<Player*> (&object);
// toss upwards
if(dir_ == UP)
toss_velocity_y += -500;
// toss to the side when moving sideways
if(player && player->physic.get_velocity_x()*(dir_ == LEFT ? -1 : 1) > 1) {
toss_velocity_x += (dir_ == LEFT) ? -200 : 200;
toss_velocity_y = (toss_velocity_y < -200) ? toss_velocity_y : -200;
// toss farther when running
if(player && player->physic.get_velocity_x()*(dir_ == LEFT ? -1 : 1) > 200)
toss_velocity_x += player->physic.get_velocity_x()-(190*(dir_ == LEFT ? -1 : 1));
}
physic.set_velocity(toss_velocity_x, toss_velocity_y);
set_colgroup_active(COLGROUP_MOVING);
grabbed = false;
}
void
Stalactite::active_update(float elapsed_time)
{
if(state == STALACTITE_HANGING) {
Player* player = this->get_nearest_player();
if (player) {
if(player->get_bbox().p2.x > bbox.p1.x - SHAKE_RANGE_X
&& player->get_bbox().p1.x < bbox.p2.x + SHAKE_RANGE_X
&& player->get_bbox().p2.y > bbox.p1.y
&& player->get_bbox().p1.y < bbox.p2.y + SHAKE_RANGE_Y
&& Sector::current()->can_see_player(get_bbox().get_middle())) {
timer.start(SHAKE_TIME);
state = STALACTITE_SHAKING;
SoundManager::current()->play("sounds/cracking.wav", get_pos());
}
}
} else if(state == STALACTITE_SHAKING) {
shake_delta = Vector(graphicsRandom.rand(-3,3), 0);
if(timer.check()) {
state = STALACTITE_FALLING;
physic.enable_gravity(true);
set_colgroup_active(COLGROUP_MOVING);
}
} else if(state == STALACTITE_FALLING) {
movement = physic.get_movement(elapsed_time);
}
}
void Yeti::take_hit(Player& )
{
if(safe_timer.started())
return;
SoundManager::current()->play("sounds/yeti_roar.wav");
hit_points--;
if(hit_points <= 0) {
// We're dead
physic.set_velocity_x(((dir==RIGHT)?+RUN_VX:-RUN_VX)/5);
physic.set_velocity_y(0);
// Set the badguy layer to be above the foremost, so that
// this does not reveal secret tilemaps:
layer = Sector::current()->get_foremost_layer() + 1;
state = SQUISHED;
state_timer.start(YETI_SQUISH_TIME);
set_colgroup_active(COLGROUP_MOVING_ONLY_STATIC);
//sprite->set_action("dead"); // This sprite does not look very good
}
else {
safe_timer.start(SAFE_TIME);
}
}
void
Fish::start_waiting()
{
waiting.start(FISH_WAIT_TIME);
set_colgroup_active(COLGROUP_DISABLED);
physic.enable_gravity(false);
physic.set_velocity_y(0);
}
Dispenser::Dispenser(const Reader& reader) :
BadGuy(reader, "images/creatures/dispenser/dispenser.sprite"),
colgroup_active(),
cycle(),
badguys(),
next_badguy(),
dispense_timer(),
autotarget(),
swivel(),
broken(),
random(),
type()
{
set_colgroup_active(COLGROUP_MOVING_STATIC);
SoundManager::current()->preload("sounds/squish.wav");
reader.get("cycle", cycle);
reader.get("badguy", badguys);
random = false; // default
reader.get("random", random);
type = "dropper"; //default
reader.get("type", type);
next_badguy = 0;
autotarget = false;
swivel = false;
broken = false;
if (badguys.size() <= 0)
throw std::runtime_error("No badguys in dispenser.");
if (type == "rocketlauncher") {
sprite->set_action(dir == LEFT ? "working-left" : "working-right");
set_colgroup_active(COLGROUP_MOVING); //if this were COLGROUP_MOVING_STATIC MrRocket would explode on launch.
if (start_dir == AUTO) {
autotarget = true;
}
} else if (type == "cannon") {
sprite->set_action("working");
} else {
sprite->set_action("dropper");
}
bbox.set_size(sprite->get_current_hitbox_width(), sprite->get_current_hitbox_height());
countMe = false;
}
void
MrIceBlock::grab(MovingObject&, const Vector& pos, Direction dir_)
{
movement = pos - get_pos();
this->dir = dir_;
this->set_action(dir_ == LEFT ? "flat-left" : "flat-right", /* loops = */ -1);
set_state(ICESTATE_GRABBED);
set_colgroup_active(COLGROUP_DISABLED);
}
void
Snail::grab(MovingObject&, const Vector& pos, Direction dir_)
{
m_col.m_movement = pos - get_pos();
m_dir = dir_;
set_action(dir_ == Direction::LEFT ? "flat-left" : "flat-right", /* loops = */ -1);
be_grabbed();
set_colgroup_active(COLGROUP_DISABLED);
}
void
SkyDive::ungrab (MovingObject& , Direction)
{
is_grabbed = false;
physic.set_velocity_y (0);
physic.set_acceleration_y (0);
physic.enable_gravity (true);
set_colgroup_active (COLGROUP_MOVING);
}
void
MrBomb::grab(MovingObject&, const Vector& pos, Direction dir_)
{
assert(frozen);
movement = pos - get_pos();
this->dir = dir_;
sprite->set_action(dir_ == LEFT ? "iced-left" : "iced-right");
set_colgroup_active(COLGROUP_DISABLED);
grabbed = true;
}
void
Bomb::ungrab(MovingObject& object, Direction dir_)
{
this->dir = dir_;
// portable objects are usually pushed away from Tux when dropped, but we
// don't want that, so we set the position
//FIXME: why don't we want that? shouldn't behavior be consistent?
set_pos(object.get_pos() + Vector(dir_ == LEFT ? -16 : 16, get_bbox().get_height()*0.66666 - 32));
set_colgroup_active(COLGROUP_MOVING);
grabbed = false;
}
void
MrIceBlock::ungrab(MovingObject& , Direction dir_)
{
if(dir_ == UP) {
set_state(ICESTATE_FLAT, true);
} else {
this->dir = dir_;
set_state(ICESTATE_KICKED);
}
set_colgroup_active(COLGROUP_MOVING);
}
void
Snail::ungrab(MovingObject& , Direction dir_)
{
if (dir_ == Direction::UP) {
be_flat();
} else {
m_dir = dir_;
be_kicked();
}
set_colgroup_active(COLGROUP_MOVING);
}
Stalactite::Stalactite(const Reader& lisp) :
BadGuy(lisp, "images/creatures/stalactite/stalactite.sprite", LAYER_TILES - 1),
timer(),
state(STALACTITE_HANGING),
shake_delta()
{
countMe = false;
set_colgroup_active(COLGROUP_TOUCHABLE);
SoundManager::current()->preload("sounds/cracking.wav");
SoundManager::current()->preload("sounds/sizzle.ogg");
SoundManager::current()->preload("sounds/icecrash.ogg");
}
Root::Root(const Vector& pos) :
BadGuy(pos, "images/creatures/ghosttree/root.sprite", LAYER_TILES-1),
mystate(STATE_APPEARING),
base_sprite(SpriteManager::current()->create("images/creatures/ghosttree/root-base.sprite")),
offset_y(0),
hatch_timer()
{
base_sprite->set_action("appearing", 1);
base_sprite->set_animation_loops(1); // TODO: necessary because set_action ignores loops for default action
m_physic.enable_gravity(false);
set_colgroup_active(COLGROUP_TOUCHABLE);
}
void
Bomb::grab(MovingObject& object, const Vector& pos, Direction dir_)
{
movement = pos - get_pos();
this->dir = dir_;
// We actually face the opposite direction of Tux here to make the fuse more
// visible instead of hiding it behind Tux
sprite->set_action_continued(dir == LEFT ? "ticking-right" : "ticking-left");
set_colgroup_active(COLGROUP_DISABLED);
grabbed = true;
grabber = &object;
}
void
GoldBomb::grab(MovingObject& object, const Vector& pos, Direction dir_)
{
if(tstate == STATE_TICKING){
movement = pos - get_pos();
dir = dir_;
// We actually face the opposite direction of Tux here to make the fuse more
// visible instead of hiding it behind Tux
sprite->set_action_continued(dir == LEFT ? "ticking-right" : "ticking-left");
set_colgroup_active(COLGROUP_DISABLED);
grabbed = true;
grabber = &object;
}
else if(frozen){
movement = pos - get_pos();
dir = dir_;
sprite->set_action(dir_ == LEFT ? "iced-left" : "iced-right");
set_colgroup_active(COLGROUP_DISABLED);
grabbed = true;
}
}
void
SkyDive::grab (MovingObject&, const Vector& pos, Direction dir_)
{
movement = pos - get_pos();
this->dir = dir_;
is_grabbed = true;
physic.set_velocity_x (movement.x * LOGICAL_FPS);
physic.set_velocity_y (0.0);
physic.set_acceleration_y (0.0);
physic.enable_gravity (false);
set_colgroup_active (COLGROUP_DISABLED);
}
void
YetiStalactite::update(float elapsed_time)
{
// Respawn instead of removing once squished
if(get_state() == STATE_SQUISHED && check_state_timer()) {
set_state(STATE_ACTIVE);
state = STALACTITE_HANGING;
// Hopefully we shouldn't come into contact with anything...
sprite->set_action("normal");
set_pos(start_position);
set_colgroup_active(COLGROUP_TOUCHABLE);
}
// Call back to badguy to do normal stuff
BadGuy::update(elapsed_time);
}
TreeWillOWisp::TreeWillOWisp(GhostTree* tree_, const Vector& pos,
float radius_, float speed_) :
BadGuy(tree_->get_pos() + pos, "images/creatures/willowisp/willowisp.sprite",
LAYER_OBJECTS - 20),
was_sucked(false),
mystate(STATE_DEFAULT),
color(),
angle(0),
radius(radius_),
speed(speed_),
sound_source(),
tree(tree_),
suck_target()
{
SoundManager::current()->preload(TREEWILLOSOUND);
set_colgroup_active(COLGROUP_MOVING);
}
//TODO: Add launching velocity to certain badguys
bool
Dispenser::collision_squished(GameObject& object)
{
//Cannon launching MrRocket can be broken by jumping on it
//other dispensers are not that fragile.
if (broken || type != DT_ROCKETLAUNCHER) {
return false;
}
sprite->set_action(dir == LEFT ? "broken-left" : "broken-right");
dispense_timer.start(0);
set_colgroup_active(COLGROUP_MOVING_STATIC); // Tux can stand on broken cannon.
Player* player = dynamic_cast<Player*>(&object);
if (player){
player->bounce(*this);
}
SoundManager::current()->play("sounds/squish.wav", get_pos());
broken = true;
return true;
}
Flame::Flame(const ReaderMapping& reader) :
BadGuy(reader, "images/creatures/flame/flame.sprite", LAYER_FLOATINGOBJECTS,
"images/objects/lightmap_light/lightmap_light-small.sprite"),
angle(0),
radius(),
speed(),
light(0.0f,0.0f,0.0f),
sound_source()
{
if ( !reader.get("radius", radius)) radius = 100;
if ( !reader.get("speed", speed)) speed = 2;
bbox.set_pos(Vector(start_position.x + cos(angle) * radius,
start_position.y + sin(angle) * radius));
countMe = false;
SoundManager::current()->preload(FLAME_SOUND);
set_colgroup_active(COLGROUP_TOUCHABLE);
lightsprite->set_color(Color(0.21f, 0.13f, 0.08f));
glowing = true;
}
GhostTree::GhostTree(const Reader& lisp) :
BadGuy(lisp, "images/creatures/ghosttree/ghosttree.sprite", LAYER_OBJECTS - 10),
mystate(STATE_IDLE),
willowisp_timer(),
willo_spawn_y(0),
willo_radius(200),
willo_speed(1.8f),
willo_color(0),
glow_sprite(SpriteManager::current()->create("images/creatures/ghosttree/ghosttree-glow.sprite")),
colorchange_timer(),
suck_timer(),
root_timer(),
treecolor(0),
suck_lantern_color(),
suck_lantern(0),
willowisps()
{
set_colgroup_active(COLGROUP_TOUCHABLE);
SoundManager::current()->preload("sounds/tree_howling.ogg");
SoundManager::current()->preload("sounds/tree_suck.ogg");
}
Iceflame::Iceflame(const Reader& reader) :
BadGuy(reader, "images/creatures/flame/iceflame.sprite", LAYER_FLOATINGOBJECTS),
angle(0),
radius(100),
speed(2),
light(0.0f,0.0f,0.0f),
lightsprite(SpriteManager::current()->create("images/objects/lightmap_light/lightmap_light-small.sprite"))
{
reader.get("radius", radius);
reader.get("speed", speed);
bbox.set_pos(Vector(start_position.x + cos(angle) * radius,
start_position.y + sin(angle) * radius));
countMe = false;
SoundManager::current()->preload("sounds/sizzle.ogg");
set_colgroup_active(COLGROUP_TOUCHABLE);
lightsprite->set_blend(Blend(GL_SRC_ALPHA, GL_ONE));
lightsprite->set_color(Color(0.00f, 0.13f, 0.18f));
}
TreeWillOWisp::TreeWillOWisp(GhostTree* tree, const Vector& pos,
float radius, float speed) :
BadGuy(tree->get_pos() + pos, "images/creatures/willowisp/willowisp.sprite",
LAYER_OBJECTS - 20),
was_sucked(false),
mystate(STATE_DEFAULT),
color(),
angle(),
radius(),
speed(),
sound_source(),
tree(tree),
suck_target()
{
sound_manager->preload(TREEWILLOSOUND);
this->radius = radius;
this->angle = 0;
this->speed = speed;
set_colgroup_active(COLGROUP_MOVING);
}
void
Mole::set_state(MoleState new_state)
{
if (frozen)
return;
switch (new_state) {
case PRE_THROWING:
sprite->set_action("idle");
set_colgroup_active(COLGROUP_DISABLED);
timer.start(MOLE_WAIT_TIME);
break;
case THROWING:
sprite->set_action("idle");
set_colgroup_active(COLGROUP_DISABLED);
timer.start(THROW_TIME);
throw_timer.start(THROW_INTERVAL);
break;
case POST_THROWING:
sprite->set_action("idle");
set_colgroup_active(COLGROUP_DISABLED);
timer.start(MOLE_WAIT_TIME);
break;
case PEEKING:
sprite->set_action("peeking", 1);
set_colgroup_active(COLGROUP_STATIC);
break;
case DEAD:
sprite->set_action("idle");
set_colgroup_active(COLGROUP_DISABLED);
break;
case BURNING:
sprite->set_action("burning", 1);
set_colgroup_active(COLGROUP_DISABLED);
break;
}
state = new_state;
}
Dispenser::Dispenser(const Reader& reader) :
BadGuy(reader, "images/creatures/dispenser/dispenser.sprite"),
colgroup_active(),
cycle(),
badguys(),
next_badguy(),
dispense_timer(),
autotarget(),
swivel(),
broken(),
random(),
type()
{
set_colgroup_active(COLGROUP_MOVING_STATIC);
SoundManager::current()->preload("sounds/squish.wav");
reader.get("cycle", cycle);
reader.get("badguy", badguys);
random = false; // default
reader.get("random", random);
std::string type_s = "dropper"; //default
reader.get("type", type_s);
if (type_s == "dropper") {
type = DT_DROPPER;
} else if (type_s == "rocketlauncher") {
type = DT_ROCKETLAUNCHER;
} else if (type_s == "cannon") {
type = DT_CANNON;
} else {
log_warning << "Unknown type of dispenser:" << type_s << ", setting to dropper." << std::endl;
type = DT_DROPPER;
}
next_badguy = 0;
autotarget = false;
swivel = false;
broken = false;
if (badguys.size() <= 0)
throw std::runtime_error("No badguys in dispenser.");
switch (type) {
case DT_DROPPER:
sprite->set_action("dropper");
break;
case DT_ROCKETLAUNCHER:
sprite->set_action(dir == LEFT ? "working-left" : "working-right");
set_colgroup_active(COLGROUP_MOVING); //if this were COLGROUP_MOVING_STATIC MrRocket would explode on launch.
if (start_dir == AUTO) {
autotarget = true;
}
break;
case DT_CANNON:
sprite->set_action("working");
break;
default:
break;
}
bbox.set_size(sprite->get_current_hitbox_width(), sprite->get_current_hitbox_height());
countMe = false;
}
