X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Fobject%2Fplayer.cpp;h=ebed28a85466489eb8526e41d91e9ce6a0c0bdd8;hb=f44e2310e449113e4618d153b765b6d81ef187ce;hp=dd71bb9242dddbeb4a74d23b9249a1f618076fcf;hpb=001cb827d5d08d5f2a47cdd19a72070e314a028a;p=supertux.git diff --git a/src/object/player.cpp b/src/object/player.cpp index dd71bb924..ebed28a85 100644 --- a/src/object/player.cpp +++ b/src/object/player.cpp @@ -1,7 +1,7 @@ // $Id$ // -// SuperTux - A Jump'n Run -// Copyright (C) 2003 Tobias Glaesser +// SuperTux +// Copyright (C) 2006 Matthias Braun // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License @@ -23,23 +23,32 @@ #include #include -#include "gettext.h" -#include "sprite/sprite_manager.h" -#include "player.h" -#include "tile.h" -#include "sprite/sprite.h" -#include "sector.h" -#include "resources.h" -#include "video/screen.h" -#include "statistics.h" -#include "game_session.h" -#include "object/tilemap.h" -#include "object/camera.h" -#include "object/gameobjs.h" -#include "object/portable.h" -#include "trigger/trigger_base.h" -#include "control/joystickkeyboardcontroller.h" -#include "main.h" +#include "gettext.hpp" +#include "sprite/sprite_manager.hpp" +#include "audio/sound_manager.hpp" +#include "player.hpp" +#include "tile.hpp" +#include "sprite/sprite.hpp" +#include "sector.hpp" +#include "resources.hpp" +#include "statistics.hpp" +#include "game_session.hpp" +#include "object/tilemap.hpp" +#include "object/camera.hpp" +#include "object/particles.hpp" +#include "object/portable.hpp" +#include "object/bullet.hpp" +#include "trigger/trigger_base.hpp" +#include "control/joystickkeyboardcontroller.hpp" +#include "scripting/squirrel_util.hpp" +#include "main.hpp" +#include "platform.hpp" +#include "badguy/badguy.hpp" +#include "player_status.hpp" +#include "log.hpp" +#include "falling_coin.hpp" +#include "random_generator.hpp" +#include "object/sprite_particle.hpp" static const int TILES_FOR_BUTTJUMP = 3; static const float SHOOTING_TIME = .150; @@ -54,6 +63,11 @@ static const float MAX_WALK_XM = 230; static const float MAX_RUN_XM = 320; static const float WALK_SPEED = 100; +static const float KICK_TIME = .3; +static const float CHEER_TIME = 1; + +static const float UNDUCK_HURT_TIME = 0.25; /**< if Tux cannot unduck for this long, he will get hurt */ + // growing animation Surface* growingtux_left[GROWING_FRAMES]; Surface* growingtux_right[GROWING_FRAMES]; @@ -86,18 +100,25 @@ TuxBodyParts::draw(DrawingContext& context, const Vector& pos, int layer) if(body != NULL) body->draw(context, pos, layer-3); if(arms != NULL) - arms->draw(context, pos, layer); + arms->draw(context, pos, layer+10); if(feet != NULL) feet->draw(context, pos, layer-2); } Player::Player(PlayerStatus* _player_status) - : player_status(_player_status), grabbed_object(0) + : player_status(_player_status), grabbed_object(NULL), ghost_mode(false) { controller = main_controller; - smalltux_gameover = sprite_manager->create("smalltux-gameover"); - smalltux_star = sprite_manager->create("smalltux-star"); - bigtux_star = sprite_manager->create("bigtux-star"); + 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"); + + 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"); + init(); } @@ -112,9 +133,9 @@ void Player::init() { if(is_big()) - bbox.set_size(31.8, 63.8); + set_size(31.8, 62.8); else - bbox.set_size(31.8, 31.8); + set_size(31.8, 30.8); dir = RIGHT; old_dir = dir; @@ -125,25 +146,32 @@ Player::init() last_ground_y = 0; fall_mode = ON_GROUND; jumping = false; - flapping = false; can_jump = true; - can_flap = false; - falling_from_flap = false; - enable_hover = false; butt_jump = false; + deactivated = false; + backflipping = false; + backflip_direction = 0; + visible = true; - flapping_velocity = 0; + on_ground_flag = false; + grabbed_object = NULL; - // temporary to help player's choosing a flapping - flapping_mode = NO_FLAP; + floor_normal = Vector(0,-1); - // Ricardo's flapping - flaps_nb = 0; + physic.reset(); +} - on_ground_flag = false; - grabbed_object = 0; +void +Player::expose(HSQUIRRELVM vm, SQInteger table_idx) +{ + Scripting::Player* interface = static_cast (this); + Scripting::expose_object(vm, table_idx, interface, "Tux", false); +} - physic.reset(); +void +Player::unexpose(HSQUIRRELVM vm, SQInteger table_idx) +{ + Scripting::unexpose_object(vm, table_idx, "Tux"); } void @@ -152,6 +180,20 @@ Player::set_controller(Controller* controller) this->controller = controller; } +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 (!Sector::current()->is_free_space(bbox2)) 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::update(float elapsed_time) { @@ -160,44 +202,115 @@ Player::update(float elapsed_time) return; } - if(!controller->hold(Controller::ACTION) && grabbed_object) { - grabbed_object = 0; - // move the grabbed object a bit away from tux - Vector pos = get_pos() + - Vector(dir == LEFT ? -bbox.get_width() : bbox.get_width(), - bbox.get_height()*0.66666 - 32); - MovingObject* object = dynamic_cast (grabbed_object); - if(object) { - object->set_pos(pos); - } else { -#ifdef DEBUG - std::cout << "Non MovingObjetc grabbed?!?\n"; -#endif + 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.8); + } + + // on downward slopes, adjust vertical velocity to match slope angle + if (on_ground()) { + if (floor_normal.y != 0) { + if ((floor_normal.x * physic.get_velocity_x()) > 0) { + // we overdo it a little, just to be on the safe side + physic.set_velocity_y(-physic.get_velocity_x() * (floor_normal.x / floor_normal.y) * 2); + } } } - if(!dying) - 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); - on_ground_flag = false; + // 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 controls are currently deactivated, we take care of standing up ourselves + if (deactivated) do_standup(); + } + } + #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; + // 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 - if(grabbed_object != 0) { + // 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, - bbox.get_height()*0.66666 - 32); - grabbed_object->grab(*this, 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; } bool @@ -216,6 +329,35 @@ 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 { + physic.set_acceleration_x(WALK_ACCELERATION_X * -1.5); + } + +#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::handle_horizontal_input() { float vx = physic.get_velocity_x(); @@ -269,14 +411,13 @@ Player::handle_horizontal_input() // let's skid! if(fabs(vx)>SKID_XM && !skidding_timer.started()) { skidding_timer.start(SKID_TIME); - sound_manager->play_sound("skid"); - // dust some partcles + sound_manager->play("sounds/skid.wav"); + // dust some particles Sector::current()->add_object( new Particles( - Vector(bbox.p1.x + (dir == RIGHT ? bbox.get_width() : 0), - 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,0.030), 3, Color(100,100,100), 3, .8, + Vector(280, -260), Vector(0, 300), 3, Color(.4, .4, .4), 3, .8, LAYER_OBJECTS+1)); ax *= 2.5; @@ -285,244 +426,125 @@ Player::handle_horizontal_input() } } + 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); +void +Player::do_cheer() +{ + do_duck(); + do_backflip(); + do_standup(); +} + +void +Player::do_duck() { + if (duck) return; + if (!is_big()) return; + + if (physic.get_velocity_y() != 0) return; + if (!on_ground()) return; + + if (adjust_height(31.8)) { + duck = true; + unduck_hurt_timer.stop(); + } else { + // FIXME: what now? } -#endif +} - // extend/shrink tux collision rectangle so that we fall through/walk over 1 - // tile holes - if(fabsf(vx) > MAX_WALK_XM) { - bbox.set_width(33); +void +Player::do_standup() { + if (!duck) return; + if (!is_big()) return; + if (backflipping) return; + + if (adjust_height(63.8)) { + duck = false; + unduck_hurt_timer.stop(); } else { - bbox.set_width(31.8); + // 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; + + // TODO: we don't have an animation for firetux backflipping, so let's revert to bigtux + set_bonus(GROWUP_BONUS, true); + + backflip_direction = (dir == LEFT)?(+1):(-1); + backflipping = true; + do_jump(-580); + sound_manager->play("sounds/flip.wav"); + backflip_timer.start(0.15); +} - if(on_ground()) { /* Make sure jumping is off. */ - jumping = false; - flapping = false; - falling_from_flap = false; - if (flapping_timer.started()) { - flapping_timer.stop(); - } +void +Player::do_jump(float yspeed) { + if (!on_ground()) return; - physic.set_acceleration_y(0); //for flapping + 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) // only jump a little bit when in duck mode - physic.set_velocity_y(300); - 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; - flapping = false; - can_jump = false; - can_flap = false; - flaps_nb = 0; // Ricardo's flapping - if (is_big()) - sound_manager->play_sound("bigjump"); - else - sound_manager->play_sound("jump"); - } else if(!controller->hold(Controller::JUMP)) { // Let go of jump key - if (!flapping && !duck && !falling_from_flap && !on_ground()) { - can_flap = true; + 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) 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); } - if (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); } } -#if CHOOSEFLAPSTYLE - // temporary to help players choosing a flapping - if(flapping_mode == RICARDO_FLAP) { - // Flapping, Ricardo's version - // similar to SM3 Fox - if(controller->pressed(Controller::JUMP) && can_flap && flaps_nb < 3) { - physic.set_velocity_y(350); - physic.set_velocity_x(physic.get_velocity_x() * 35); - flaps_nb++; - } - } else if(flapping_mode == MAREK_FLAP) { -#endif - // Flapping, Marek and Ondra's version - if (controller->hold(Controller::JUMP) && can_flap) - { - if (flapping_timer.check()) - { - can_flap = false; - //flapping = false; - falling_from_flap = true; - } - else if (!flapping_timer.started()) - { - flapping_timer.start(TUX_FLAPPING_TIME); - flapping_velocity = physic.get_velocity_x(); - } - else - { - jumping = true; - flapping = true; - float cv = flapping_velocity * sqrt( - TUX_FLAPPING_TIME - flapping_timer.get_timegone() - / TUX_FLAPPING_TIME); - - //Handle change of direction while flapping - if (((dir == LEFT) && (cv > 0)) || (dir == RIGHT) && (cv < 0)) { - cv *= (-1); - } - else if (cv == 0) { - if (controller->hold(Controller::LEFT)) { - cv = -TUX_FLAPPING_LEAST_X; - } - else if (controller->hold(Controller::RIGHT)) { - cv = TUX_FLAPPING_LEAST_X; - } - } - physic.set_velocity_x(cv); - physic.set_velocity_y(flapping_timer.get_timegone() - * TUX_FLAPPING_STRENGTH); - //std::cout << "Timegone: " << flapping_timer.get_timegone() << ", Y velocity: " << physic.get_velocity_y() << "\n"; - } - } -#if CHOOSEFLAPSTYLE - } else if(flapping_mode == RYAN_FLAP) { - // Flapping, Ryan's version - if (controller->hold(Controller::JUMP) && can_flap) - { - if (!flapping_timer.started()) - { - flapping_timer.start(TUX_FLAPPING_TIME); - } - if (flapping_timer.check()) - { - can_flap = false; - falling_from_flap = true; - } - jumping = true; - flapping = true; - if (flapping && flapping_timer.get_timegone() <= TUX_FLAPPING_TIME - && physic.get_velocity_y() < 0) - { - float gravity = Sector::current()->gravity; - (void)gravity; - float xr = (fabsf(physic.get_velocity_x()) / MAX_RUN_XM); - - // XXX: magic numbers. should be a percent of gravity - // gravity is (by default) -0.1f - physic.set_acceleration_y(12 + 1*xr); - -#if 0 - // To slow down x-vel when flapping (not working) - if (fabsf(physic.get_velocity_x()) > MAX_WALK_XM) - { - if (physic.get_velocity_x() < 0) - physic.set_acceleration_x(1.0f); - else if (physic.get_velocity_x() > 0) - physic.set_acceleration_x(-1.0f); - } -#endif - } - } else { - physic.set_acceleration_y(0); - } - } -#endif /* 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() && jumping) { 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 - + if(butt_jump && !controller->hold(Controller::DOWN)) butt_jump = false; + /** jumping is only allowed if we're about to touch ground soon and if the * button has been up in between the last jump */ @@ -545,12 +567,37 @@ Player::handle_vertical_input() void Player::handle_input() { - /* Handle horizontal movement: */ - handle_horizontal_input(); + if (ghost_mode) { + handle_input_ghost(); + return; + } + 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; + } + grabbed_object->ungrab(*this, dir); + grabbed_object = NULL; + } + } + + /* 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! */ @@ -562,50 +609,130 @@ Player::handle_input() 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) { - // try if we can really unduck - bbox.move(Vector(0, -32)); - bbox.set_height(63.8); - duck = false; - // FIXME -#if 0 - // when unducking in air we need some space to do so - if(on_ground() || !collision_object_map(bbox)) { - duck = false; - } else { - // undo the ducking changes - bbox.move(Vector(0, 32)); - bbox.set_height(31.8); - } -#endif + /* Duck or Standup! */ + if (controller->hold(Controller::DOWN)) do_duck(); else do_standup(); + +} + +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::set_bonus(BonusType type, bool animate) +Player::add_coins(int count) { - if(player_status->bonus >= type) + player_status->add_coins(count); +} + +void +Player::add_bonus(const std::string& bonustype) +{ + if(bonustype == "grow") { + add_bonus(GROWUP_BONUS); + } else if(bonustype == "fireflower") { + add_bonus(FIRE_BONUS); + } else if(bonustype == "iceflower") { + add_bonus(ICE_BONUS); + } else if(bonustype == "none") { + add_bonus(NO_BONUS); + } else { + std::ostringstream msg; + msg << "Unknown bonus type " << bonustype; + throw std::runtime_error(msg.str()); + } +} + +void +Player::add_bonus(BonusType type, bool animate) +{ + // always ignore NO_BONUS + if (type == NO_BONUS) { return; - + } + + // 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; + } + + set_bonus(type, animate); +} + +void +Player::set_bonus(BonusType type, bool animate) +{ if(player_status->bonus == NO_BONUS) { - bbox.set_height(63.8); - bbox.move(Vector(0, -32)); + if (!adjust_height(62.8)) return; if(animate) growing_timer.start(GROWING_TIME); } - + + 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)); + } + player_status->max_fire_bullets = 0; + player_status->max_ice_bullets = 0; + } + if (type == FIRE_BONUS) player_status->max_fire_bullets++; + if (type == ICE_BONUS) player_status->max_ice_bullets++; + player_status->bonus = type; } void +Player::set_visible(bool visible) +{ + this->visible = visible; +} + +bool +Player::get_visible() +{ + return visible; +} + +void +Player::kick() +{ + kick_timer.start(KICK_TIME); +} + +void Player::draw(DrawingContext& context) { + if(!visible) + return; + TuxBodyParts* tux_body; if (player_status->bonus == GROWUP_BONUS) @@ -617,10 +744,17 @@ Player::draw(DrawingContext& context) else tux_body = small_tux; - int layer = LAYER_OBJECTS + 10; + int layer = LAYER_OBJECTS + 1; /* Set Tux sprite action */ - if (duck && is_big()) + if (backflipping) + { + if(dir == LEFT) + tux_body->set_action("backflip-left"); + else // dir == RIGHT + tux_body->set_action("backflip-right"); + } + else if (duck && is_big()) { if(dir == LEFT) tux_body->set_action("duck-left"); @@ -648,7 +782,7 @@ Player::draw(DrawingContext& context) else // dir == RIGHT tux_body->set_action("buttjump-right"); } - else if (physic.get_velocity_y() != 0) + else if (!on_ground()) { if(dir == LEFT) tux_body->set_action("jump-left"); @@ -707,33 +841,18 @@ Player::draw(DrawingContext& context) /* Draw Tux */ if(dying) { - smalltux_gameover->draw(context, get_pos(), layer); - } else if(growing_timer.get_timeleft() > 0) { - if(!is_big()) - { - if (dir == RIGHT) - context.draw_surface(growingtux_right[GROWING_FRAMES-1 - - int((growing_timer.get_timegone() * + smalltux_gameover->draw(context, get_pos(), LAYER_FLOATINGOBJECTS + 1); + } + else if ((growing_timer.get_timeleft() > 0) && (!duck)) { + if (dir == RIGHT) { + context.draw_surface(growingtux_right[int((growing_timer.get_timegone() * GROWING_FRAMES) / GROWING_TIME)], get_pos(), layer); - else - context.draw_surface(growingtux_left[GROWING_FRAMES-1 - - int((growing_timer.get_timegone() * + } else { + context.draw_surface(growingtux_left[int((growing_timer.get_timegone() * GROWING_FRAMES) / GROWING_TIME)], get_pos(), layer); } - else - { - if (dir == RIGHT) - context.draw_surface(growingtux_right[ - int((growing_timer.get_timegone() * - GROWING_FRAMES) / GROWING_TIME)], get_pos(), layer); - else - context.draw_surface(growingtux_left[ - int((growing_timer.get_timegone() * - GROWING_FRAMES) / GROWING_TIME)], - get_pos(), layer); - } } - else if (safe_timer.started() && size_t(global_time*40)%2) + else if (safe_timer.started() && size_t(game_time*40)%2) ; // don't draw Tux else tux_body->draw(context, get_pos(), layer); @@ -741,7 +860,7 @@ Player::draw(DrawingContext& context) // Draw blinking star overlay if (invincible_timer.started() && (invincible_timer.get_timeleft() > TUX_INVINCIBLE_TIME_WARNING - || size_t(global_time*20)%2) + || size_t(game_time*20)%2) && !dying) { if (!is_big() || duck) @@ -751,36 +870,117 @@ Player::draw(DrawingContext& context) } } +void +Player::collision_tile(uint32_t tile_attributes) +{ + if(tile_attributes & Tile::HURTS) + kill(false); +} + HitResponse Player::collision(GameObject& other, const CollisionHit& hit) { - Portable* portable = dynamic_cast (&other); - if(portable && grabbed_object == 0 && controller->hold(Controller::ACTION) - && fabsf(hit.normal.x) > .9) { - grabbed_object = portable; - return CONTINUE; + Bullet* bullet = dynamic_cast (&other); + if(bullet) { + return FORCE_MOVE; + } + + if(other.get_flags() & FLAG_PORTABLE) { + Portable* portable = dynamic_cast (&other); + assert(portable != NULL); + if(portable && grabbed_object == NULL + && controller->hold(Controller::ACTION) + && fabsf(hit.normal.x) > .9) { + grabbed_object = portable; + grabbed_object->grab(*this, get_pos(), dir); + 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) + 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); + 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; } - TriggerBase* trigger = dynamic_cast (&other); - if(trigger) { - if(controller->pressed(Controller::UP)) - trigger->event(*this, TriggerBase::EVENT_ACTIVATE); +#ifdef DEBUG + assert(dynamic_cast (&other) != NULL); +#endif + MovingObject* moving_object = static_cast (&other); + if(moving_object->get_group() == COLGROUP_TOUCHABLE) { + TriggerBase* trigger = dynamic_cast (&other); + if(trigger) { + if(controller->pressed(Controller::UP)) + trigger->event(*this, TriggerBase::EVENT_ACTIVATE); + } + + return FORCE_MOVE; + } + + BadGuy* badguy = dynamic_cast (&other); + if(badguy != NULL) { + if(safe_timer.started() || invincible_timer.started()) + return FORCE_MOVE; + + return CONTINUE; } return FORCE_MOVE; @@ -789,65 +989,71 @@ Player::collision(GameObject& other, const CollisionHit& hit) void Player::make_invincible() { - sound_manager->play_sound("invincible"); + sound_manager->play("sounds/invincible.wav"); invincible_timer.start(TUX_INVINCIBLE_TIME); Sector::current()->play_music(HERRING_MUSIC); } /* Kill Player! */ void -Player::kill(HurtMode mode) +Player::kill(bool completely) { - if(dying) + if(dying || deactivated) return; - if(mode != KILL && - safe_timer.get_timeleft() > 0 || invincible_timer.get_timeleft() > 0) + if(!completely && safe_timer.started() || invincible_timer.started()) return; - sound_manager->play_sound("hurt"); + sound_manager->play("sounds/hurt.wav"); physic.set_velocity_x(0); - if (mode == SHRINK && is_big()) - { - if (player_status->bonus == FIRE_BONUS - || player_status->bonus == ICE_BONUS) - { - safe_timer.start(TUX_SAFE_TIME); - player_status->bonus = GROWUP_BONUS; - } - else - { - growing_timer.start(GROWING_TIME); - safe_timer.start(TUX_SAFE_TIME + GROWING_TIME); - bbox.set_height(31.8); - duck = false; - player_status->bonus = NO_BONUS; - } + 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, true); + } else { + //growing_timer.start(GROWING_TIME); + safe_timer.start(TUX_SAFE_TIME /* + GROWING_TIME */); + adjust_height(30.8); + duck = false; + set_bonus(NO_BONUS, true); } - else + } else { + for (int i = 0; (i < 5) && (i < player_status->coins); i++) { - physic.enable_gravity(true); - physic.set_acceleration(0, 0); - physic.set_velocity(0, 700); - player_status->lives -= 1; - player_status->bonus = NO_BONUS; - dying = true; - dying_timer.start(3.0); - flags |= FLAG_NO_COLLDET; + // 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))); } + physic.enable_gravity(true); + physic.set_acceleration(0, 0); + physic.set_velocity(0, -700); + player_status->coins -= 25; + set_bonus(NO_BONUS, true); + dying = true; + dying_timer.start(3.0); + set_group(COLGROUP_DISABLED); + + DisplayEffect* effect = new DisplayEffect(); + effect->fade_out(3.0); + Sector::current()->add_object(effect); + sound_manager->stop_music(3.0); + } } 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.8, 63.8); else - bbox.set_size(31.8, 31.8); - on_ground_flag = false; + set_size(31.8, 31.8); duck = false; last_ground_y = vector.y; @@ -858,28 +1064,27 @@ void Player::check_bounds(Camera* camera) { /* Keep tux in bounds: */ - 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)); - } + if (get_pos().x < 0) { + // Lock Tux to the size of the level, so that he doesn't fall of + // on the left side + set_pos(Vector(0, get_pos().y)); + } /* Keep in-bounds, vertically: */ - if (get_pos().y > Sector::current()->solids->get_height() * 32) - { - kill(KILL); - return; - } + if (get_pos().y > Sector::current()->solids->get_height() * 32) { + 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)); + set_pos(Vector(camera->get_translation().x, get_pos().y)); adjust = true; } 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; @@ -898,15 +1103,68 @@ Player::check_bounds(Camera* camera) } void +Player::add_velocity(const Vector& velocity) +{ + physic.set_velocity(physic.get_velocity() + 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& ) { - //Make sure we stopped flapping - flapping = false; - falling_from_flap = false; - 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 + +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); +} + +void +Player::activate() +{ + if (!deactivated) return; + deactivated = false; +} + +void Player::walk(float speed) +{ + physic.set_velocity_x(speed); +} + +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; + } }