X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Fobject%2Fplayer.cpp;h=5e68d1d58d3702cbec8efc25b6ec790b6ff995f5;hb=bf50931d8b9cdf1b9c0215832c9b2bd3ce452d49;hp=3d33ce7318dee5c5e1cace16beb0ac8bb9053b24;hpb=fe138b9ec292ca9679b43cf5c4555f0193bab25d;p=supertux.git diff --git a/src/object/player.cpp b/src/object/player.cpp index 3d33ce731..5e68d1d58 100644 --- a/src/object/player.cpp +++ b/src/object/player.cpp @@ -48,85 +48,87 @@ #include "log.hpp" #include "falling_coin.hpp" #include "random_generator.hpp" +#include "object/sprite_particle.hpp" +#include "trigger/climbable.hpp" + +//#define SWIMMING static const int TILES_FOR_BUTTJUMP = 3; -static const float SHOOTING_TIME = .150; +static const float BUTTJUMP_MIN_VELOCITY_Y = 700.0f; +static const float SHOOTING_TIME = .150f; /// time before idle animation starts -static const float IDLE_TIME = 2.5; +static const float IDLE_TIME = 2.5f; +/** acceleration in horizontal direction when walking + * (all acceleratiosn are in pixel/s^2) */ static const float WALK_ACCELERATION_X = 300; +/** acceleration in horizontal direction when running */ static const float RUN_ACCELERATION_X = 400; +/** acceleration when skidding */ static const float SKID_XM = 200; -static const float SKID_TIME = .3; +/** time of skidding in seconds */ +static const float SKID_TIME = .3f; +/** maximum walk velocity (pixel/s) */ static const float MAX_WALK_XM = 230; +/** maximum run velcoity (pixel/s) */ static const float MAX_RUN_XM = 320; +/** maximum horizontal climb velocity */ +static const float MAX_CLIMB_XM = 48; +/** maximum vertical climb velocity */ +static const float MAX_CLIMB_YM = 128; +/** instant velocity when tux starts to walk */ static const float WALK_SPEED = 100; -static const float KICK_TIME = .3; - -// growing animation -Surface* growingtux_left[GROWING_FRAMES]; -Surface* growingtux_right[GROWING_FRAMES]; - -Surface* tux_life = 0; - -TuxBodyParts* small_tux = 0; -TuxBodyParts* big_tux = 0; -TuxBodyParts* fire_tux = 0; -TuxBodyParts* ice_tux = 0; +/** time of the kick (kicking mriceblock) animation */ +static const float KICK_TIME = .3f; +/** time of tux cheering (currently unused) */ +static const float CHEER_TIME = 1.0f; -void -TuxBodyParts::set_action(std::string action, int loops) -{ - if(head != NULL) - head->set_action(action, loops); - if(body != NULL) - body->set_action(action, loops); - if(arms != NULL) - arms->set_action(action, loops); - if(feet != NULL) - feet->set_action(action, loops); -} +/** if Tux cannot unduck for this long, he will get hurt */ +static const float UNDUCK_HURT_TIME = 0.25f; -void -TuxBodyParts::draw(DrawingContext& context, const Vector& pos, int layer) -{ - if(head != NULL) - head->draw(context, pos, layer-1); - if(body != NULL) - body->draw(context, pos, layer-3); - if(arms != NULL) - arms->draw(context, pos, layer+10); - if(feet != NULL) - feet->draw(context, pos, layer-2); +namespace{ + bool no_water = true; } -Player::Player(PlayerStatus* _player_status) - : player_status(_player_status), grabbed_object(0) +Player::Player(PlayerStatus* _player_status, const std::string& name) + : scripting_controller(0), + player_status(_player_status), + scripting_controller_old(0), + grabbed_object(NULL), ghost_mode(false), edit_mode(false), climbing(0) { + this->name = name; controller = main_controller; - smalltux_gameover = sprite_manager->create("images/creatures/tux_small/smalltux-gameover.sprite"); - smalltux_star = sprite_manager->create("images/creatures/tux_small/smalltux-star.sprite"); - bigtux_star = sprite_manager->create("images/creatures/tux_big/bigtux-star.sprite"); + scripting_controller = new CodeController(); + sprite = sprite_manager->create("images/creatures/tux/tux.sprite"); + airarrow.reset(new Surface("images/engine/hud/airarrow.png")); + + sound_manager->preload("sounds/bigjump.wav"); + sound_manager->preload("sounds/jump.wav"); + sound_manager->preload("sounds/hurt.wav"); + sound_manager->preload("sounds/skid.wav"); + sound_manager->preload("sounds/flip.wav"); + sound_manager->preload("sounds/invincible.wav"); + sound_manager->preload("sounds/splash.ogg"); + sound_manager->preload("sounds/shoot.wav"); init(); } Player::~Player() { - delete smalltux_gameover; - delete smalltux_star; - delete bigtux_star; + if (climbing) stop_climbing(*climbing); + delete sprite; + delete scripting_controller; } void Player::init() { if(is_big()) - bbox.set_size(31.8, 62.8); + set_size(31.8f, 62.8f); else - bbox.set_size(31.8, 30.8); - adjust_height = 0; + set_size(31.8f, 30.8f); dir = RIGHT; old_dir = dir; @@ -134,20 +136,24 @@ Player::init() dead = false; dying = false; + peeking = AUTO; last_ground_y = 0; fall_mode = ON_GROUND; jumping = false; can_jump = true; butt_jump = false; + growing = false; deactivated = false; backflipping = false; backflip_direction = 0; visible = true; - + swimming = false; + speedlimit = 0; //no special limit + on_ground_flag = false; - grabbed_object = 0; + grabbed_object = NULL; - floor_normal = Vector(0,-1); + climbing = 0; physic.reset(); } @@ -155,14 +161,31 @@ Player::init() void Player::expose(HSQUIRRELVM vm, SQInteger table_idx) { - Scripting::Player* interface = static_cast (this); - Scripting::expose_object(vm, table_idx, interface, "Tux", false); + if (name.empty()) + return; + + Scripting::expose_object(vm, table_idx, dynamic_cast(this), name, false); } void Player::unexpose(HSQUIRRELVM vm, SQInteger table_idx) { - Scripting::unexpose_object(vm, table_idx, "Tux"); + if (name.empty()) + return; + + Scripting::unexpose_object(vm, table_idx, name); +} + +float +Player::get_speedlimit() +{ + return speedlimit; +} + +void +Player::set_speedlimit(float newlimit) +{ + speedlimit=newlimit; } void @@ -171,61 +194,168 @@ Player::set_controller(Controller* controller) this->controller = controller; } +void +Player::use_scripting_controller(bool use_or_release) +{ + if ((use_or_release == true) && (controller != scripting_controller)) { + scripting_controller_old = get_controller(); + set_controller(scripting_controller); + } + if ((use_or_release == false) && (controller == scripting_controller)) { + set_controller(scripting_controller_old); + scripting_controller_old = 0; + } +} + +void +Player::do_scripting_controller(std::string control, bool pressed) +{ + for(int i = 0; Controller::controlNames[i] != 0; ++i) { + if(control == std::string(Controller::controlNames[i])) { + scripting_controller->press(Controller::Control(i), pressed); + } + } +} + +bool +Player::adjust_height(float new_height) +{ + Rect bbox2 = bbox; + bbox2.move(Vector(0, bbox.get_height() - new_height)); + bbox2.set_height(new_height); + + if(new_height > bbox.get_height()) { + Rect additional_space = bbox2; + additional_space.set_height(new_height - bbox.get_height()); + if(!Sector::current()->is_free_of_statics(additional_space, this, true)) + return false; + } + + // adjust bbox accordingly + // note that we use members of moving_object for this, so we can run this during CD, too + set_pos(bbox2.p1); + set_size(bbox2.get_width(), bbox2.get_height()); + return true; +} + +void +Player::trigger_sequence(std::string sequence_name) +{ + if (climbing) stop_climbing(*climbing); + GameSession::current()->start_sequence(sequence_name); +} + void Player::update(float elapsed_time) { + if( no_water ){ + swimming = false; + } + no_water = true; + if(dying && dying_timer.check()) { dead = true; return; } - if(adjust_height != 0) { - bbox.move(Vector(0, bbox.get_height() - adjust_height)); - bbox.set_height(adjust_height); - adjust_height = 0; + if(!dying && !deactivated) + handle_input(); + + // handle_input() calls apply_friction() when Tux is not walking, so we'll have to do this ourselves + if (deactivated) + apply_friction(); + + // extend/shrink tux collision rectangle so that we fall through/walk over 1 + // tile holes + if(fabsf(physic.get_velocity_x()) > MAX_WALK_XM) { + set_width(34); + } else { + set_width(31.8f); } - if(!controller->hold(Controller::ACTION) && grabbed_object) { - // move the grabbed object a bit away from tux - Vector pos = get_pos() + - Vector(dir == LEFT ? -bbox.get_width()-1 : bbox.get_width()+1, - bbox.get_height()*0.66666 - 32); - Rect dest(pos, pos + Vector(32, 32)); - if(Sector::current()->is_free_space(dest)) { - MovingObject* moving_object = dynamic_cast (grabbed_object); - if(moving_object) { - moving_object->set_pos(pos); - } else { - log_debug << "Non MovingObjetc grabbed?!?" << std::endl; + // on downward slopes, adjust vertical velocity so tux walks smoothly down + if (on_ground()) { + if(floor_normal.y != 0) { + if ((floor_normal.x * physic.get_velocity_x()) >= 0) { + physic.set_velocity_y(250); } - grabbed_object->ungrab(*this, dir); - grabbed_object = 0; } } - if(!dying && !deactivated) - handle_input(); + // handle backflipping + if (backflipping) { + //prevent player from changing direction when backflipping + dir = (backflip_direction == 1) ? LEFT : RIGHT; + if (backflip_timer.started()) physic.set_velocity_x(100 * backflip_direction); + } - movement = physic.get_movement(elapsed_time); + // set fall mode... + if(on_ground()) { + fall_mode = ON_GROUND; + last_ground_y = get_pos().y; + } else { + if(get_pos().y > last_ground_y) + fall_mode = FALLING; + else if(fall_mode == ON_GROUND) + fall_mode = JUMPING; + } + + // check if we landed + if(on_ground()) { + jumping = false; + if (backflipping && (!backflip_timer.started())) { + backflipping = false; + backflip_direction = 0; -#if 0 - // special exception for cases where we're stuck under tiles after - // being ducked. In this case we drift out - if(!duck && on_ground() && old_base.x == base.x && old_base.y == base.y - && collision_object_map(base)) { - base.x += elapsed_time * WALK_SPEED * (dir ? 1: -1); - previous_base = old_base = base; + // if controls are currently deactivated, we take care of standing up ourselves + if (deactivated) + do_standup(); + } } -#endif - if(grabbed_object != 0) { - Vector pos = get_pos() + - Vector(dir == LEFT ? -16 : 16, - bbox.get_height()*0.66666 - 32); + // calculate movement for this frame + movement = physic.get_movement(elapsed_time); + + if(grabbed_object != NULL && !dying) { + Vector pos = get_pos() + + Vector(dir == LEFT ? -16 : 16, get_bbox().get_height()*0.66666 - 32); grabbed_object->grab(*this, pos, dir); } + if(grabbed_object != NULL && dying){ + grabbed_object->ungrab(*this, dir); + grabbed_object = NULL; + } + on_ground_flag = false; + + // when invincible, spawn particles + if (invincible_timer.started() && !dying) + { + if (systemRandom.rand(0, 2) == 0) { + float px = systemRandom.randf(bbox.p1.x+0, bbox.p2.x-0); + float py = systemRandom.randf(bbox.p1.y+0, bbox.p2.y-0); + Vector ppos = Vector(px, py); + Vector pspeed = Vector(0, 0); + Vector paccel = Vector(0, 0); + // draw bright sparkle when there is lots of time left, dark sparkle when invincibility is about to end + if (invincible_timer.get_timeleft() > TUX_INVINCIBLE_TIME_WARNING) { + // make every other a longer sparkle to make trail a bit fuzzy + if (size_t(game_time*20)%2) { + Sector::current()->add_object(new SpriteParticle("images/objects/particles/sparkle.sprite", "small", ppos, ANCHOR_MIDDLE, pspeed, paccel, LAYER_OBJECTS+1+5)); + } else { + Sector::current()->add_object(new SpriteParticle("images/objects/particles/sparkle.sprite", "medium", ppos, ANCHOR_MIDDLE, pspeed, paccel, LAYER_OBJECTS+1+5)); + } + } else { + Sector::current()->add_object(new SpriteParticle("images/objects/particles/sparkle.sprite", "dark", ppos, ANCHOR_MIDDLE, pspeed, paccel, LAYER_OBJECTS+1+5)); + } + } + } + + if (growing) { + if (sprite->animation_done()) growing = false; + } + } bool @@ -244,6 +374,19 @@ Player::is_big() } void +Player::apply_friction() +{ + if ((on_ground()) && (fabs(physic.get_velocity_x()) < WALK_SPEED)) { + physic.set_velocity_x(0); + physic.set_acceleration_x(0); + } else if(physic.get_velocity_x() < 0) { + physic.set_acceleration_x(WALK_ACCELERATION_X * 1.5); + } else if(physic.get_velocity_x() > 0) { + physic.set_acceleration_x(WALK_ACCELERATION_X * -1.5); + } +} + +void Player::handle_horizontal_input() { float vx = physic.get_velocity_x(); @@ -265,7 +408,9 @@ Player::handle_horizontal_input() } } - if (!controller->hold(Controller::ACTION)) { + // do not run if action key is pressed or we're holding something + // so tux can only walk while shooting + if ( controller->hold(Controller::ACTION) || grabbed_object ) { ax = dirsign * WALK_ACCELERATION_X; // limit speed if(vx >= MAX_WALK_XM && dirsign > 0) { @@ -276,7 +421,11 @@ Player::handle_horizontal_input() ax = 0; } } else { - ax = dirsign * RUN_ACCELERATION_X; + if( vx * dirsign < MAX_WALK_XM ) { + ax = dirsign * WALK_ACCELERATION_X; + } else { + ax = dirsign * RUN_ACCELERATION_X; + } // limit speed if(vx >= MAX_RUN_XM && dirsign > 0) { vx = MAX_RUN_XM; @@ -292,6 +441,12 @@ Player::handle_horizontal_input() vx = dirsign * WALK_SPEED; } + //Check speedlimit. + if( speedlimit > 0 && vx * dirsign >= speedlimit ) { + vx = dirsign * speedlimit; + ax = 0; + } + // changing directions? if(on_ground() && ((vx < 0 && dirsign >0) || (vx>0 && dirsign<0))) { // let's skid! @@ -301,113 +456,131 @@ Player::handle_horizontal_input() // dust some particles Sector::current()->add_object( new Particles( - Vector(dir == RIGHT ? bbox.p2.x : bbox.p1.x, bbox.p2.y), + Vector(dir == RIGHT ? get_bbox().p2.x : get_bbox().p1.x, get_bbox().p2.y), dir == RIGHT ? 270+20 : 90-40, dir == RIGHT ? 270+40 : 90-20, - Vector(280, -260), Vector(0, 300), 3, Color(.4, .4, .4), 3, .8, + Vector(280, -260), Vector(0, 300), 3, Color(.4f, .4f, .4f), 3, .8f, LAYER_OBJECTS+1)); - + ax *= 2.5; } else { ax *= 2; } } + physic.set_velocity(vx, vy); + physic.set_acceleration(ax, ay); + // we get slower when not pressing any keys if(dirsign == 0) { - if(fabs(vx) < WALK_SPEED) { - vx = 0; - ax = 0; - } else if(vx < 0) { - ax = WALK_ACCELERATION_X * 1.5; - } else { - ax = WALK_ACCELERATION_X * -1.5; - } + apply_friction(); } -#if 0 - // if we're on ice slow down acceleration or deceleration - if (isice(base.x, base.y + base.height)) - { - /* the acceleration/deceleration rate on ice is inversely proportional to - * the current velocity. - */ +} - // increasing 1 will increase acceleration/deceleration rate - // decreasing 1 will decrease acceleration/deceleration rate - // must stay above zero, though - if (ax != 0) ax *= 1 / fabs(vx); - } -#endif +void +Player::do_cheer() +{ + do_duck(); + do_backflip(); + do_standup(); +} - // extend/shrink tux collision rectangle so that we fall through/walk over 1 - // tile holes - if(fabsf(vx) > MAX_WALK_XM) { - bbox.set_width(34); +void +Player::do_duck() { + if (duck) + return; + if (!is_big()) + return; + + if (physic.get_velocity_y() != 0) + return; + if (!on_ground()) + return; + if (butt_jump) + return; + + if (adjust_height(31.8f)) { + duck = true; + growing = false; + unduck_hurt_timer.stop(); } else { - bbox.set_width(31.8); + // FIXME: what now? } +} - // on downward slopes, adjust vertical velocity to match slope angle - if (on_ground()) { - if (floor_normal.y != 0) { - if ((floor_normal.x * vx) > 0) { - // we overdo it a little, just to be on the safe side - vy = vx * (floor_normal.x / floor_normal.y) * 2; - } +void +Player::do_standup() { + if (!duck) + return; + if (!is_big()) + return; + if (backflipping) + return; + + if (adjust_height(63.8f)) { + duck = false; + unduck_hurt_timer.stop(); + } else { + // if timer is not already running, start it. + if (unduck_hurt_timer.get_period() == 0) { + unduck_hurt_timer.start(UNDUCK_HURT_TIME); + } + else if (unduck_hurt_timer.check()) { + kill(false); } } - physic.set_velocity(vx, vy); - physic.set_acceleration(ax, ay); } void -Player::handle_vertical_input() -{ - // set fall mode... - if(on_ground()) { - fall_mode = ON_GROUND; - last_ground_y = get_pos().y; - } else { - if(get_pos().y > last_ground_y) - fall_mode = FALLING; - else if(fall_mode == ON_GROUND) - fall_mode = JUMPING; - } +Player::do_backflip() { + if (!duck) + return; + if (!on_ground()) + return; - if(on_ground()) { /* Make sure jumping is off. */ - jumping = false; - if (backflipping) { - backflipping = false; - backflip_direction = 0; - } + backflip_direction = (dir == LEFT)?(+1):(-1); + backflipping = true; + do_jump(-580); + sound_manager->play("sounds/flip.wav"); + backflip_timer.start(0.15f); +} + +void +Player::do_jump(float yspeed) { + if (!on_ground()) + return; + + physic.set_velocity_y(yspeed); + //bbox.move(Vector(0, -1)); + jumping = true; + on_ground_flag = false; + can_jump = false; + + // play sound + if (is_big()) { + sound_manager->play("sounds/bigjump.wav"); + } else { + sound_manager->play("sounds/jump.wav"); } +} +void +Player::handle_vertical_input() +{ // Press jump key - if(controller->pressed(Controller::JUMP) && can_jump && on_ground()) { - if (duck) { - if (physic.get_velocity_x() != 0) // only jump a little bit when running ducked - physic.set_velocity_y(300); - else { //do a backflip - backflipping = true; - physic.set_velocity_y(580); - backflip_timer.start(0.15); - } + if(controller->pressed(Controller::JUMP) && (can_jump)) { + if (duck) { + // when running, only jump a little bit; else do a backflip + if ((physic.get_velocity_x() != 0) || (controller->hold(Controller::LEFT)) || (controller->hold(Controller::RIGHT))) do_jump(-300); else do_backflip(); + } else { + // jump a bit higher if we are running; else do a normal jump + if (fabs(physic.get_velocity_x()) > MAX_WALK_XM) do_jump(-580); else do_jump(-520); } - else if (fabs(physic.get_velocity_x()) > MAX_WALK_XM) // jump higher if we are running - physic.set_velocity_y(580); - else - physic.set_velocity_y(520); - - //bbox.move(Vector(0, -1)); - jumping = true; - can_jump = false; - if (is_big()) - sound_manager->play("sounds/bigjump.wav"); - else - sound_manager->play("sounds/jump.wav"); - } else if(!controller->hold(Controller::JUMP)) { // Let go of jump key - if (!backflipping && jumping && physic.get_velocity_y() > 0) { + } + // Let go of jump key + else if(!controller->hold(Controller::JUMP)) { + if (!backflipping && jumping && physic.get_velocity_y() < 0) { jumping = false; physic.set_velocity_y(0); } @@ -415,177 +588,273 @@ Player::handle_vertical_input() /* In case the player has pressed Down while in a certain range of air, enable butt jump action */ - if (controller->hold(Controller::DOWN) && !butt_jump && !duck) - //if(tiles_on_air(TILES_FOR_BUTTJUMP) && jumping) + if (controller->hold(Controller::DOWN) && !butt_jump && !duck && is_big() && !on_ground() && (physic.get_velocity_y() >= BUTTJUMP_MIN_VELOCITY_Y)) { butt_jump = true; - + } + /* When Down is not held anymore, disable butt jump */ if(butt_jump && !controller->hold(Controller::DOWN)) butt_jump = false; - -#if 0 - // Do butt jump - if (butt_jump && on_ground() && is_big()) { - // Add a smoke cloud - if (duck) - Sector::current()->add_smoke_cloud(Vector(get_pos().x - 32, get_pos().y)); - else - Sector::current()->add_smoke_cloud( - Vector(get_pos().x - 32, get_pos().y + 32)); - - butt_jump = false; - - // Break bricks beneath Tux - if(Sector::current()->trybreakbrick( - Vector(base.x + 1, base.y + base.height), false) - || Sector::current()->trybreakbrick( - Vector(base.x + base.width - 1, base.y + base.height), false)) { - physic.set_velocity_y(2); - butt_jump = true; - } - - // Kill nearby badguys - std::vector gameobjects = Sector::current()->gameobjects; - for (std::vector::iterator i = gameobjects.begin(); - i != gameobjects.end(); - i++) { - BadGuy* badguy = dynamic_cast (*i); - if(badguy) { - // don't kill when badguys are already dying or in a certain mode - if(badguy->dying == DYING_NOT && badguy->mode != BadGuy::BOMB_TICKING && - badguy->mode != BadGuy::BOMB_EXPLODE) { - if (fabsf(base.x - badguy->base.x) < 96 && - fabsf(base.y - badguy->base.y) < 64) - badguy->kill_me(25); - } - } - } - } -#endif - /** jumping is only allowed if we're about to touch ground soon and if the - * button has been up in between the last jump - */ - // FIXME -#if 0 - if ( (issolid(get_pos().x + bbox.get_width() / 2, - get_pos().y + bbox.get_height() + 64) || - issolid(get_pos().x + 1, get_pos().y + bbox.get_height() + 64) || - issolid(get_pos().x + bbox.get_width() - 1, - get_pos().y + bbox.get_height() + 64)) - && jumping == false - && can_jump == false - && input.jump && !input.old_jump) - { - can_jump = true; - } + // swimming + physic.set_acceleration_y(0); +#ifdef SWIMMING + if (swimming) { + if (controller->hold(Controller::UP) || controller->hold(Controller::JUMP)) + physic.set_acceleration_y(-2000); + physic.set_velocity_y(physic.get_velocity_y() * 0.94); + } #endif } void Player::handle_input() { - /* Handle horizontal movement: */ - if (!backflipping) handle_horizontal_input(); - else { - if (backflip_direction == 0) { - dir == LEFT ? backflip_direction = 1 : backflip_direction = -1; - } - else backflip_direction == 1 ? dir = LEFT : dir = RIGHT; //prevent player from changing direction when backflipping - if (backflip_timer.check()) physic.set_velocity_x(100 * backflip_direction); + if (ghost_mode) { + handle_input_ghost(); + return; + } + if (climbing) { + handle_input_climbing(); + return; + } + + /* Peeking */ + if( controller->released( Controller::PEEK_LEFT ) ) { + peeking = AUTO; + } + if( controller->released( Controller::PEEK_RIGHT ) ) { + peeking = AUTO; + } + if( controller->released( Controller::UP ) ) { + peeking = AUTO; + } + if( controller->released( Controller::DOWN ) ) { + peeking = AUTO; + } + if( controller->pressed( Controller::PEEK_LEFT ) ) { + peeking = LEFT; + } + if( controller->pressed( Controller::PEEK_RIGHT ) ) { + peeking = RIGHT; + } + if( controller->pressed( Controller::UP ) ) { + peeking = UP; + } + if( controller->pressed( Controller::DOWN ) ) { + peeking = DOWN; } + /* Handle horizontal movement: */ + if (!backflipping) handle_horizontal_input(); /* Jump/jumping? */ if (on_ground() && !controller->hold(Controller::JUMP)) can_jump = true; + + /* Handle vertical movement: */ handle_vertical_input(); /* Shoot! */ - if (controller->pressed(Controller::ACTION) && player_status->bonus == FIRE_BONUS) { + if (controller->pressed(Controller::ACTION) && (player_status->bonus == FIRE_BONUS || player_status->bonus == ICE_BONUS)) { if(Sector::current()->add_bullet( - get_pos() + ((dir == LEFT)? Vector(0, bbox.get_height()/2) + get_pos() + ((dir == LEFT)? Vector(0, bbox.get_height()/2) : Vector(32, bbox.get_height()/2)), physic.get_velocity_x(), dir)) shooting_timer.start(SHOOTING_TIME); } - - /* Duck! */ - if (controller->hold(Controller::DOWN) && is_big() && !duck - && physic.get_velocity_y() == 0 && on_ground()) { - duck = true; - bbox.move(Vector(0, 32)); - bbox.set_height(31.8); - } else if(!controller->hold(Controller::DOWN) && is_big() && duck) { - // if we have some velocity left then check if there is space for - // unducking - bbox.move(Vector(0, -32)); - bbox.set_height(63.8); - if(Sector::current()->is_free_space(bbox) || ( - physic.get_velocity_x() > -.01 && physic.get_velocity_x() < .01 - && physic.get_velocity_y() > -.01 && physic.get_velocity_y() < .01)) - { - duck = false; + + /* Duck or Standup! */ + if (controller->hold(Controller::DOWN)) { + do_duck(); + } else { + do_standup(); + } + + /* grabbing */ + try_grab(); + + if(!controller->hold(Controller::ACTION) && grabbed_object) { + // move the grabbed object a bit away from tux + Vector pos = get_pos() + + Vector(dir == LEFT ? -bbox.get_width()-1 : bbox.get_width()+1, + bbox.get_height()*0.66666 - 32); + Rect dest(pos, pos + Vector(32, 32)); + if(Sector::current()->is_free_of_movingstatics(dest)) { + MovingObject* moving_object = dynamic_cast (grabbed_object); + if(moving_object) { + moving_object->set_pos(pos); + } else { + log_debug << "Non MovingObject grabbed?!?" << std::endl; + } + if(controller->hold(Controller::UP)) { + grabbed_object->ungrab(*this, UP); + } else { + grabbed_object->ungrab(*this, dir); + } + grabbed_object = NULL; + } + } +} + +void +Player::try_grab() +{ + if(controller->hold(Controller::ACTION) && !grabbed_object + && !duck) { + Sector* sector = Sector::current(); + Vector pos; + if(dir == LEFT) { + pos = Vector(bbox.get_left() - 5, bbox.get_bottom() - 16); } else { - // undo the ducking changes - bbox.move(Vector(0, 32)); - bbox.set_height(31.8); + pos = Vector(bbox.get_right() + 5, bbox.get_bottom() - 16); + } + + for(Sector::Portables::iterator i = sector->portables.begin(); + i != sector->portables.end(); ++i) { + Portable* portable = *i; + if(!portable->is_portable()) + continue; + + // make sure the Portable is a MovingObject + MovingObject* moving_object = dynamic_cast (portable); + assert(moving_object); + if(moving_object == NULL) + continue; + + // make sure the Portable isn't currently non-solid + if(moving_object->get_group() == COLGROUP_DISABLED) continue; + + // check if we are within reach + if(moving_object->get_bbox().contains(pos)) { + if (climbing) stop_climbing(*climbing); + grabbed_object = portable; + grabbed_object->grab(*this, get_pos(), dir); + break; + } } } } void +Player::handle_input_ghost() +{ + float vx = 0; + float vy = 0; + if (controller->hold(Controller::LEFT)) { + dir = LEFT; + vx -= MAX_RUN_XM * 2; + } + if (controller->hold(Controller::RIGHT)) { + dir = RIGHT; + vx += MAX_RUN_XM * 2; + } + if ((controller->hold(Controller::UP)) || (controller->hold(Controller::JUMP))) { + vy -= MAX_RUN_XM * 2; + } + if (controller->hold(Controller::DOWN)) { + vy += MAX_RUN_XM * 2; + } + if (controller->hold(Controller::ACTION)) { + set_ghost_mode(false); + } + physic.set_velocity(vx, vy); + physic.set_acceleration(0, 0); +} + +void Player::add_coins(int count) { player_status->add_coins(count); } -void +int +Player::get_coins() +{ + return player_status->coins; +} + +bool Player::add_bonus(const std::string& bonustype) { + BonusType type = NO_BONUS; + if(bonustype == "grow") { - add_bonus(GROWUP_BONUS); + type = GROWUP_BONUS; } else if(bonustype == "fireflower") { - add_bonus(FIRE_BONUS); + type = FIRE_BONUS; } else if(bonustype == "iceflower") { - add_bonus(ICE_BONUS); + type = ICE_BONUS; } else if(bonustype == "none") { - add_bonus(NO_BONUS); + type = NO_BONUS; } else { std::ostringstream msg; msg << "Unknown bonus type " << bonustype; throw std::runtime_error(msg.str()); } + + return add_bonus(type); } -void +bool Player::add_bonus(BonusType type, bool animate) { // always ignore NO_BONUS if (type == NO_BONUS) { - return; + return true; } // ignore GROWUP_BONUS if we're already big if (type == GROWUP_BONUS) { - if (player_status->bonus == GROWUP_BONUS) return; - if (player_status->bonus == FIRE_BONUS) return; - if (player_status->bonus == ICE_BONUS) return; + if (player_status->bonus == GROWUP_BONUS) + return true; + if (player_status->bonus == FIRE_BONUS) + return true; + if (player_status->bonus == ICE_BONUS) + return true; } - set_bonus(type, animate); + return set_bonus(type, animate); } -void +bool Player::set_bonus(BonusType type, bool animate) { if(player_status->bonus == NO_BONUS) { - adjust_height = 62.8; - if(animate) - growing_timer.start(GROWING_TIME); + if (!adjust_height(62.8f)) { + printf("can't adjust\n"); + return false; + } + if(animate) { + growing = true; + sprite->set_action((dir == LEFT)?"grow-left":"grow-right", 1); + } + if (climbing) stop_climbing(*climbing); + } + + if (type == NO_BONUS) { + if (butt_jump) butt_jump = false; } if ((type == NO_BONUS) || (type == GROWUP_BONUS)) { + if ((player_status->bonus == FIRE_BONUS) && (animate)) { + // visually lose helmet + Vector ppos = Vector((bbox.p1.x + bbox.p2.x) / 2, bbox.p1.y); + Vector pspeed = Vector(((dir==LEFT) ? +100 : -100), -300); + Vector paccel = Vector(0, 1000); + std::string action = (dir==LEFT)?"left":"right"; + Sector::current()->add_object(new SpriteParticle("images/objects/particles/firetux-helmet.sprite", action, ppos, ANCHOR_TOP, pspeed, paccel, LAYER_OBJECTS-1)); + if (climbing) stop_climbing(*climbing); + } + if ((player_status->bonus == ICE_BONUS) && (animate)) { + // visually lose cap + Vector ppos = Vector((bbox.p1.x + bbox.p2.x) / 2, bbox.p1.y); + Vector pspeed = Vector(((dir==LEFT) ? +100 : -100), -300); + Vector paccel = Vector(0, 1000); + std::string action = (dir==LEFT)?"left":"right"; + Sector::current()->add_object(new SpriteParticle("images/objects/particles/icetux-cap.sprite", action, ppos, ANCHOR_TOP, pspeed, paccel, LAYER_OBJECTS-1)); + if (climbing) stop_climbing(*climbing); + } player_status->max_fire_bullets = 0; player_status->max_ice_bullets = 0; } @@ -593,12 +862,17 @@ Player::set_bonus(BonusType type, bool animate) if (type == ICE_BONUS) player_status->max_ice_bullets++; player_status->bonus = type; + return true; } void Player::set_visible(bool visible) { this->visible = visible; + if( visible ) + set_group(COLGROUP_MOVING); + else + set_group(COLGROUP_DISABLED); } bool @@ -619,133 +893,86 @@ Player::draw(DrawingContext& context) if(!visible) return; - TuxBodyParts* tux_body; - + // if Tux is above camera, draw little "air arrow" to show where he is x-wise + if (Sector::current() && Sector::current()->camera && (get_bbox().p2.y - 16 < Sector::current()->camera->get_translation().y)) { + float px = get_pos().x + (get_bbox().p2.x - get_bbox().p1.x - airarrow.get()->get_width()) / 2; + float py = Sector::current()->camera->get_translation().y; + py += std::min(((py - (get_bbox().p2.y + 16)) / 4), 16.0f); + context.draw_surface(airarrow.get(), Vector(px, py), LAYER_HUD - 1); + } + + std::string sa_prefix = ""; if (player_status->bonus == GROWUP_BONUS) - tux_body = big_tux; + sa_prefix = "big"; else if (player_status->bonus == FIRE_BONUS) - tux_body = fire_tux; + sa_prefix = "fire"; else if (player_status->bonus == ICE_BONUS) - tux_body = ice_tux; + sa_prefix = "ice"; else - tux_body = small_tux; - - int layer = LAYER_OBJECTS + 1; + sa_prefix = "small"; /* Set Tux sprite action */ - if (duck && is_big()) - { - if(dir == LEFT) - tux_body->set_action("duck-left"); - else // dir == RIGHT - tux_body->set_action("duck-right"); - } - else if (skidding_timer.started() && !skidding_timer.check()) - { - if(dir == LEFT) - tux_body->set_action("skid-left"); - else // dir == RIGHT - tux_body->set_action("skid-right"); - } - else if (kick_timer.started() && !kick_timer.check()) - { - if(dir == LEFT) - tux_body->set_action("kick-left"); - else // dir == RIGHT - tux_body->set_action("kick-right"); - } - else if (butt_jump && is_big()) - { - if(dir == LEFT) - tux_body->set_action("buttjump-left"); - else // dir == RIGHT - tux_body->set_action("buttjump-right"); + if (growing) { + // while growing, do not change action + // do_duck() will take care of cancelling growing manually + // update() will take care of cancelling when growing completed + } + else if (climbing) { + sprite->set_action(sa_prefix+((dir == LEFT)?"-skid-left":"-skid-right")); + } + else if (backflipping) { + sprite->set_action(sa_prefix+((dir == LEFT)?"-backflip-left":"-backflip-right")); + } + else if (duck && is_big()) { + sprite->set_action(sa_prefix+((dir == LEFT)?"-duck-left":"-duck-right")); + } + else if (skidding_timer.started() && !skidding_timer.check()) { + sprite->set_action(sa_prefix+((dir == LEFT)?"-skid-left":"-skid-right")); + } + else if (kick_timer.started() && !kick_timer.check()) { + sprite->set_action(sa_prefix+((dir == LEFT)?"-kick-left":"-kick-right")); + } + else if (butt_jump && is_big()) { + sprite->set_action(sa_prefix+((dir == LEFT)?"-buttjump-left":"-buttjump-right")); + } + else if (!on_ground()) { + sprite->set_action(sa_prefix+((dir == LEFT)?"-jump-left":"-jump-right")); + } + else { + if (fabsf(physic.get_velocity_x()) < 1.0f) { +// if(idle_timer.check()) { +// sprite->set_action(sa_prefix+((dir == LEFT)?"-idle-left":"-idle-right")); +// } else { + sprite->set_action(sa_prefix+((dir == LEFT)?"-stand-left":"-stand-right")); +// } } - else if (!on_ground()) - { - if(dir == LEFT) - tux_body->set_action("jump-left"); - else // dir == RIGHT - tux_body->set_action("jump-right"); - } - else - { - if (fabsf(physic.get_velocity_x()) < 1.0f) // standing - { - if(dir == LEFT) - tux_body->set_action("stand-left"); - else // dir == RIGHT - tux_body->set_action("stand-right"); - } - else // moving - { - if(dir == LEFT) - tux_body->set_action("walk-left"); - else // dir == RIGHT - tux_body->set_action("walk-right"); - } + else { + sprite->set_action(sa_prefix+((dir == LEFT)?"-walk-left":"-walk-right")); } + } - if(idle_timer.check()) - { - if(is_big()) - { - if(dir == LEFT) - tux_body->head->set_action("idle-left", 1); - else // dir == RIGHT - tux_body->head->set_action("idle-right", 1); - } - - } +/* // Tux is holding something if ((grabbed_object != 0 && physic.get_velocity_y() == 0) || - (shooting_timer.get_timeleft() > 0 && !shooting_timer.check())) - { - if (duck) - { - if(dir == LEFT) - tux_body->arms->set_action("duck+grab-left"); - else // dir == RIGHT - tux_body->arms->set_action("duck+grab-right"); - } - else - { - if(dir == LEFT) - tux_body->arms->set_action("grab-left"); - else // dir == RIGHT - tux_body->arms->set_action("grab-right"); - } + (shooting_timer.get_timeleft() > 0 && !shooting_timer.check())) { + if (duck) { + } else { } + } +*/ - /* Draw Tux */ if(dying) { - smalltux_gameover->draw(context, get_pos(), LAYER_FLOATINGOBJECTS + 1); - } else if(growing_timer.get_timeleft() > 0) { - if (dir == RIGHT) { - context.draw_surface(growingtux_right[int((growing_timer.get_timegone() * - GROWING_FRAMES) / GROWING_TIME)], get_pos() - Vector(0, 32), layer); - } else { - context.draw_surface(growingtux_left[int((growing_timer.get_timegone() * - GROWING_FRAMES) / GROWING_TIME)], get_pos() - Vector(0, 32), layer); - } - } - else if (safe_timer.started() && size_t(game_time*40)%2) + sprite->set_action("gameover"); + } + + /* Draw Tux */ + if (safe_timer.started() && size_t(game_time*40)%2) ; // don't draw Tux - else - tux_body->draw(context, get_pos(), layer); + else { + sprite->draw(context, get_pos(), LAYER_OBJECTS + 1); + } - // Draw blinking star overlay - if (invincible_timer.started() && - (invincible_timer.get_timeleft() > TUX_INVINCIBLE_TIME_WARNING - || size_t(game_time*20)%2) - && !dying) - { - if (!is_big() || duck) - smalltux_star->draw(context, get_pos(), layer + 5); - else - bigtux_star->draw(context, get_pos(), layer + 5); - } } void @@ -753,6 +980,68 @@ Player::collision_tile(uint32_t tile_attributes) { if(tile_attributes & Tile::HURTS) kill(false); + +#ifdef SWIMMING + if( swimming ){ + if( tile_attributes & Tile::WATER ){ + no_water = false; + } else { + swimming = false; + } + } else { + if( tile_attributes & Tile::WATER ){ + swimming = true; + no_water = false; + sound_manager->play( "sounds/splash.ogg" ); + } + } +#endif +} + +void +Player::collision_solid(const CollisionHit& hit) +{ + if(hit.bottom) { + if(physic.get_velocity_y() > 0) + physic.set_velocity_y(0); + + on_ground_flag = true; + floor_normal = hit.slope_normal; + + // Butt Jump landed + if (butt_jump) { + butt_jump = false; + physic.set_velocity_y(-300); + on_ground_flag = false; + Sector::current()->add_object(new Particles( + Vector(get_bbox().p2.x, get_bbox().p2.y), + 270+20, 270+40, + Vector(280, -260), Vector(0, 300), 3, Color(.4f, .4f, .4f), 3, .8f, + LAYER_OBJECTS+1)); + Sector::current()->add_object(new Particles( + Vector(get_bbox().p1.x, get_bbox().p2.y), + 90-40, 90-20, + Vector(280, -260), Vector(0, 300), 3, Color(.4f, .4f, .4f), 3, .8f, + LAYER_OBJECTS+1)); + } + + } else if(hit.top) { + if(physic.get_velocity_y() < 0) + physic.set_velocity_y(.2f); + } + + if(hit.left || hit.right) { + physic.set_velocity_x(0); + } + + // crushed? + if(hit.crush) { + if(hit.left || hit.right) { + kill(true); + } else if(hit.top || hit.bottom) { + kill(false); + } + } } HitResponse @@ -763,83 +1052,13 @@ Player::collision(GameObject& other, const CollisionHit& hit) return FORCE_MOVE; } - if(other.get_flags() & FLAG_PORTABLE) { - Portable* portable = dynamic_cast (&other); - if(portable && grabbed_object == 0 && controller->hold(Controller::ACTION) - && fabsf(hit.normal.x) > .9) { - grabbed_object = portable; - return CONTINUE; - } - } - - if(other.get_flags() & FLAG_SOLID) { - /* - printf("Col %p: HN: %3.1f %3.1f D %.1f P: %3.1f %3.1f M: %3.1f %3.1f\n", - &other, - hit.normal.x, hit.normal.y, hit.depth, - get_pos().x, get_pos().y, - movement.x, movement.y); - */ - - if(hit.normal.y < 0) { // landed on floor? - if(physic.get_velocity_y() < 0) - physic.set_velocity_y(0); - - on_ground_flag = true; - - // remember normal of this tile - if (hit.normal.y > -0.9) { - floor_normal.x = hit.normal.x; - floor_normal.y = hit.normal.y; - } else { - // slowly adjust to unisolid tiles. - // Necessary because our bounding box sometimes reaches through slopes and thus hits unisolid tiles - floor_normal.x = (floor_normal.x * 0.9) + (hit.normal.x * 0.1); - floor_normal.y = (floor_normal.y * 0.9) + (hit.normal.y * 0.1); - } - - // hack platforms so that we stand normally on them when going down... - Platform* platform = dynamic_cast (&other); - if(platform != NULL) { - if(platform->get_speed().y > 0) - physic.set_velocity_y(-platform->get_speed().y); - //physic.set_velocity_x(platform->get_speed().x); - } - } else if(hit.normal.y > 0) { // bumped against the roof - physic.set_velocity_y(.1); - - // hack platform so that we are not glued to it from below - Platform* platform = dynamic_cast (&other); - if(platform != NULL) { - physic.set_velocity_y(-platform->get_speed().y); - } - } - - if(fabsf(hit.normal.x) > .9) { // hit on the side? - physic.set_velocity_x(0); - } - - MovingObject* omov = dynamic_cast (&other); - if(omov != NULL) { - Vector mov = movement - omov->get_movement(); - /* - printf("W %p - HITN: %3.1f %3.1f D:%3.1f TM: %3.1f %3.1f TD: %3.1f %3.1f PM: %3.2f %3.1f\n", - omov, - hit.normal.x, hit.normal.y, - hit.depth, - movement.x, movement.y, - dest.p1.x, dest.p1.y, - omov->get_movement().x, omov->get_movement().y); - */ - } - - return CONTINUE; + if(hit.left || hit.right) { + try_grab(); //grab objects right now, in update it will be too late } - #ifdef DEBUG assert(dynamic_cast (&other) != NULL); #endif - MovingObject* moving_object = static_cast (&other); + MovingObject* moving_object = static_cast (&other); if(moving_object->get_group() == COLGROUP_TOUCHABLE) { TriggerBase* trigger = dynamic_cast (&other); if(trigger) { @@ -852,13 +1071,13 @@ Player::collision(GameObject& other, const CollisionHit& hit) BadGuy* badguy = dynamic_cast (&other); if(badguy != NULL) { - if(safe_timer.started()) + if(safe_timer.started() || invincible_timer.started()) return FORCE_MOVE; return CONTINUE; } - return FORCE_MOVE; + return CONTINUE; } void @@ -866,7 +1085,7 @@ Player::make_invincible() { sound_manager->play("sounds/invincible.wav"); invincible_timer.start(TUX_INVINCIBLE_TIME); - Sector::current()->play_music(HERRING_MUSIC); + Sector::current()->play_music(HERRING_MUSIC); } /* Kill Player! */ @@ -876,39 +1095,57 @@ Player::kill(bool completely) if(dying || deactivated) return; - if(!completely && - (safe_timer.get_timeleft() > 0 || invincible_timer.get_timeleft() > 0)) - return; - + if(!completely && (safe_timer.started() || invincible_timer.started())) + return; + sound_manager->play("sounds/hurt.wav"); + if (climbing) stop_climbing(*climbing); + physic.set_velocity_x(0); if(!completely && is_big()) { if(player_status->bonus == FIRE_BONUS || player_status->bonus == ICE_BONUS) { safe_timer.start(TUX_SAFE_TIME); - set_bonus(GROWUP_BONUS); - } else { - //growing_timer.start(GROWING_TIME); + set_bonus(GROWUP_BONUS, true); + } else if(player_status->bonus == GROWUP_BONUS) { safe_timer.start(TUX_SAFE_TIME /* + GROWING_TIME */); - adjust_height = 30.8; + adjust_height(30.8f); + duck = false; + set_bonus(NO_BONUS, true); + } else if(player_status->bonus == NO_BONUS) { + safe_timer.start(TUX_SAFE_TIME); + adjust_height(30.8f); duck = false; - set_bonus(NO_BONUS); } } else { - for (int i = 0; (i < 5) && (i < player_status->coins); i++) + + // do not die when in edit mode + if (edit_mode) { + set_ghost_mode(true); + return; + } + + if (player_status->coins >= 25 && !GameSession::current()->get_reset_point_sectorname().empty()) { - // the numbers: starting x, starting y, velocity y - Sector::current()->add_object(new FallingCoin(get_pos() + - Vector(systemRandom.rand(5), systemRandom.rand(-32,18)), - systemRandom.rand(-100,100))); + for (int i = 0; i < 5; i++) + { + // the numbers: starting x, starting y, velocity y + Sector::current()->add_object(new FallingCoin(get_pos() + + Vector(systemRandom.rand(5), systemRandom.rand(-32,18)), + systemRandom.rand(-100,100))); + } + player_status->coins -= std::max(player_status->coins/10, 25); + } + else + { + GameSession::current()->set_reset_point("", Vector()); } physic.enable_gravity(true); physic.set_acceleration(0, 0); - physic.set_velocity(0, 700); - player_status->coins -= 25; - set_bonus(NO_BONUS); + physic.set_velocity(0, -700); + set_bonus(NO_BONUS, true); dying = true; dying_timer.start(3.0); set_group(COLGROUP_DISABLED); @@ -923,13 +1160,16 @@ Player::kill(bool completely) void Player::move(const Vector& vector) { - bbox.set_pos(vector); + set_pos(vector); + + // TODO: do we need the following? Seems irrelevant to moving the player if(is_big()) - bbox.set_size(31.8, 63.8); + set_size(31.8f, 63.8f); else - bbox.set_size(31.8, 31.8); + set_size(31.8f, 31.8f); duck = false; last_ground_y = vector.y; + if (climbing) stop_climbing(*climbing); physic.reset(); } @@ -941,38 +1181,24 @@ Player::check_bounds(Camera* camera) if (get_pos().x < 0) { // Lock Tux to the size of the level, so that he doesn't fall of // on the left side - bbox.set_pos(Vector(0, get_pos().y)); + set_pos(Vector(0, get_pos().y)); } - /* Keep in-bounds, vertically: */ - if (get_pos().y > Sector::current()->solids->get_height() * 32) { + /* fallen out of the level? */ + if ((get_pos().y > Sector::current()->get_height()) && (!ghost_mode)) { kill(true); return; } - bool adjust = false; // can happen if back scrolling is disabled if(get_pos().x < camera->get_translation().x) { - bbox.set_pos(Vector(camera->get_translation().x, get_pos().y)); - adjust = true; + set_pos(Vector(camera->get_translation().x, get_pos().y)); } if(get_pos().x >= camera->get_translation().x + SCREEN_WIDTH - bbox.get_width()) { - bbox.set_pos(Vector( + set_pos(Vector( camera->get_translation().x + SCREEN_WIDTH - bbox.get_width(), get_pos().y)); - adjust = true; - } - - if(adjust) { - // FIXME -#if 0 - // squished now? - if(collision_object_map(bbox)) { - kill(KILL); - return; - } -#endif } } @@ -983,12 +1209,25 @@ Player::add_velocity(const Vector& velocity) } void +Player::add_velocity(const Vector& velocity, const Vector& end_speed) +{ + if (end_speed.x > 0) + physic.set_velocity_x(std::min(physic.get_velocity_x() + velocity.x, end_speed.x)); + if (end_speed.x < 0) + physic.set_velocity_x(std::max(physic.get_velocity_x() + velocity.x, end_speed.x)); + if (end_speed.y > 0) + physic.set_velocity_y(std::min(physic.get_velocity_y() + velocity.y, end_speed.y)); + if (end_speed.y < 0) + physic.set_velocity_y(std::max(physic.get_velocity_y() + velocity.y, end_speed.y)); +} + +void Player::bounce(BadGuy& ) { if(controller->hold(Controller::JUMP)) - physic.set_velocity_y(520); + physic.set_velocity_y(-520); else - physic.set_velocity_y(300); + physic.set_velocity_y(-300); } //Scripting Functions Below @@ -996,14 +1235,21 @@ Player::bounce(BadGuy& ) void Player::deactivate() { + if (deactivated) + return; deactivated = true; physic.set_velocity_x(0); physic.set_velocity_y(0); + physic.set_acceleration_x(0); + physic.set_acceleration_y(0); + if (climbing) stop_climbing(*climbing); } void Player::activate() { + if (!deactivated) + return; deactivated = false; } @@ -1012,3 +1258,106 @@ void Player::walk(float speed) physic.set_velocity_x(speed); } +void +Player::set_ghost_mode(bool enable) +{ + if (ghost_mode == enable) + return; + + if (climbing) stop_climbing(*climbing); + + 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 +Player::set_edit_mode(bool enable) +{ + edit_mode = enable; +} + +void +Player::start_climbing(Climbable& climbable) +{ + if (climbing == &climbable) return; + + climbing = &climbable; + physic.enable_gravity(false); + physic.set_velocity(0, 0); + physic.set_acceleration(0, 0); +} + +void +Player::stop_climbing(Climbable& /*climbable*/) +{ + if (!climbing) return; + + climbing = 0; + + if (grabbed_object) { + grabbed_object->ungrab(*this, dir); + grabbed_object = NULL; + } + + physic.enable_gravity(true); + physic.set_velocity(0, 0); + physic.set_acceleration(0, 0); + + if ((controller->hold(Controller::JUMP)) || (controller->hold(Controller::UP))) { + on_ground_flag = true; + // TODO: This won't help. Why? + do_jump(-300); + } +} + +void +Player::handle_input_climbing() +{ + if (!climbing) { + log_warning << "handle_input_climbing called with climbing set to 0. Input handling skipped" << std::endl; + return; + } + + float vx = 0; + float vy = 0; + if (controller->hold(Controller::LEFT)) { + dir = LEFT; + vx -= MAX_CLIMB_XM; + } + if (controller->hold(Controller::RIGHT)) { + dir = RIGHT; + vx += MAX_CLIMB_XM; + } + if (controller->hold(Controller::UP)) { + vy -= MAX_CLIMB_YM; + } + if (controller->hold(Controller::DOWN)) { + vy += MAX_CLIMB_YM; + } + if (controller->hold(Controller::JUMP)) { + if (can_jump) { + stop_climbing(*climbing); + return; + } + } else { + can_jump = true; + } + if (controller->hold(Controller::ACTION)) { + stop_climbing(*climbing); + return; + } + physic.set_velocity(vx, vy); + physic.set_acceleration(0, 0); +} + +