X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Fobject%2Fplayer.cpp;h=2005f512d179c36d937e650fe1da40a2fac01c12;hb=5f1c84ed5ce0ab5450f92082a9aaaa9ca0effc39;hp=e2b8a88b453a0059b4637da51eb5f2b0c0924ecb;hpb=626ab69641b179048b9d0fc528cd1626886fe9db;p=supertux.git diff --git a/src/object/player.cpp b/src/object/player.cpp index e2b8a88b4..2005f512d 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,31 @@ #include #include -#include "app/globals.h" -#include "app/gettext.h" -#include "special/sprite_manager.h" -#include "player.h" -#include "tile.h" -#include "player_status.h" -#include "special/sprite.h" -#include "sector.h" -#include "resources.h" -#include "video/screen.h" -#include "statistics.h" -#include "gameloop.h" -#include "object/tilemap.h" -#include "object/camera.h" -#include "object/gameobjs.h" -#include "object/portable.h" -#include "trigger/trigger_base.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" static const int TILES_FOR_BUTTJUMP = 3; static const float SHOOTING_TIME = .150; @@ -54,6 +62,10 @@ 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 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]; @@ -65,39 +77,6 @@ TuxBodyParts* big_tux = 0; TuxBodyParts* fire_tux = 0; TuxBodyParts* ice_tux = 0; -PlayerKeymap keymap; - -PlayerKeymap::PlayerKeymap() -{ - keymap.up = SDLK_UP; - keymap.down = SDLK_DOWN; - keymap.left = SDLK_LEFT; - keymap.right = SDLK_RIGHT; - - keymap.power = SDLK_LCTRL; - keymap.jump = SDLK_SPACE; -} - -PlayerInputType::PlayerInputType() -{ - reset(); -} - -void -PlayerInputType::reset() -{ - up = false; - old_up = false; - down = false; - fire = false; - old_fire = false; - left = false; - right = false; - jump = false; - old_jump = false; - activate = false; -} - void TuxBodyParts::set_action(std::string action, int loops) { @@ -112,25 +91,31 @@ TuxBodyParts::set_action(std::string action, int loops) } void -TuxBodyParts::draw(DrawingContext& context, const Vector& pos, int layer, - Uint32 drawing_effect) +TuxBodyParts::draw(DrawingContext& context, const Vector& pos, int layer) { if(head != NULL) - head->draw(context, pos, layer-1, drawing_effect); + head->draw(context, pos, layer-1); if(body != NULL) - body->draw(context, pos, layer-3, drawing_effect); + body->draw(context, pos, layer-3); if(arms != NULL) - arms->draw(context, pos, layer, drawing_effect); + arms->draw(context, pos, layer+10); if(feet != NULL) - feet->draw(context, pos, layer-2, drawing_effect); + feet->draw(context, pos, layer-2); } -Player::Player() - : grabbed_object(0) +Player::Player(PlayerStatus* _player_status) + : player_status(_player_status), grabbed_object(NULL), ghost_mode(false) { - smalltux_gameover = sprite_manager->create("smalltux-gameover"); - smalltux_star = sprite_manager->create("smalltux-star"); - bigtux_star = sprite_manager->create("bigtux-star"); + 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"); + + sound_manager->preload("sounds/bigjump.wav"); + sound_manager->preload("sounds/jump.wav"); + sound_manager->preload("sounds/hurt.wav"); + sound_manager->preload("sounds/skid.wav"); + init(); } @@ -144,10 +129,10 @@ Player::~Player() void Player::init() { - bbox.set_size(31.8, 31.8); - - size = SMALL; - got_power = NONE_POWER; + if(is_big()) + set_size(31.8, 62.8); + else + set_size(31.8, 30.8); dir = RIGHT; old_dir = dir; @@ -158,143 +143,79 @@ 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; - - // temporary to help player's choosing a flapping - flapping_mode = MAREK_FLAP; - - // Ricardo's flapping - flaps_nb = 0; - on_ground_flag = false; - grabbed_object = 0; + grabbed_object = NULL; + + floor_normal = Vector(0,-1); - input.reset(); physic.reset(); } -bool -Player::key_event(SDLKey key, bool state) +void +Player::expose(HSQUIRRELVM vm, SQInteger table_idx) { - idle_timer.start(IDLE_TIME, true); - - if(key == keymap.right) - { - input.right = state; - return true; - } - else if(key == keymap.left) - { - input.left = state; - return true; - } - else if(key == keymap.up) - { - if(state == false) - input.old_up = false; - input.up = state; - /* Up key also opens activates stuff */ - input.activate = state; - return true; - } - else if(key == keymap.down) - { - input.down = state; - return true; - } - else if(key == keymap.power) - { - if(state == false) - input.old_fire = false; - input.fire = state; - - return true; - } - else if(key == keymap.jump) - { - if(state == false) - input.old_jump = false; - input.jump = state; - return true; - } - else - return false; + Scripting::Player* interface = static_cast (this); + Scripting::expose_object(vm, table_idx, interface, "Tux", false); } void -Player::level_begin() +Player::unexpose(HSQUIRRELVM vm, SQInteger table_idx) { - move(Vector(100, 170)); - duck = false; - - dying = false; - - input.reset(); - - on_ground_flag = false; + Scripting::unexpose_object(vm, table_idx, "Tux"); +} - physic.reset(); +void +Player::set_controller(Controller* controller) +{ + this->controller = controller; } -PlayerStatus& -Player::get_status() +bool +Player::adjust_height(float new_height) { - return player_status; + 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::action(float elapsed_time) +Player::update(float elapsed_time) { if(dying && dying_timer.check()) { dead = true; return; } - if(input.fire == false && 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) + if(!dying && !deactivated) handle_input(); movement = physic.get_movement(elapsed_time); - on_ground_flag = false; -#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; - } -#endif - - if(grabbed_object != 0) { + 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 @@ -303,6 +224,15 @@ Player::on_ground() return on_ground_flag; } +bool +Player::is_big() +{ + if(player_status->bonus == NO_BONUS) + return false; + + return true; +} + void Player::handle_horizontal_input() { @@ -313,18 +243,19 @@ Player::handle_horizontal_input() float dirsign = 0; if(!duck || physic.get_velocity_y() != 0) { - if(input.left && !input.right) { + if(controller->hold(Controller::LEFT) && !controller->hold(Controller::RIGHT)) { old_dir = dir; dir = LEFT; dirsign = -1; - } else if(!input.left && input.right) { + } else if(!controller->hold(Controller::LEFT) + && controller->hold(Controller::RIGHT)) { old_dir = dir; dir = RIGHT; dirsign = 1; } } - if (!input.fire) { + if (!controller->hold(Controller::ACTION)) { ax = dirsign * WALK_ACCELERATION_X; // limit speed if(vx >= MAX_WALK_XM && dirsign > 0) { @@ -356,14 +287,13 @@ Player::handle_horizontal_input() // let's skid! if(fabs(vx)>SKID_XM && !skidding_timer.started()) { skidding_timer.start(SKID_TIME); - SoundManager::get()->play_sound(IDToSound(SND_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; @@ -374,7 +304,7 @@ Player::handle_horizontal_input() // we get slower when not pressing any keys if(dirsign == 0) { - if(fabs(vx) < WALK_SPEED) { + if ((on_ground()) && (fabs(vx) < WALK_SPEED)) { vx = 0; ax = 0; } else if(vx < 0) { @@ -402,9 +332,19 @@ Player::handle_horizontal_input() // 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); + set_width(34); } else { - bbox.set_width(31.8); + 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 * vx) > 0) { + // we overdo it a little, just to be on the safe side + vy = vx * (floor_normal.x / floor_normal.y) * 2; + } + } } physic.set_velocity(vx, vy); @@ -427,200 +367,91 @@ Player::handle_vertical_input() if(on_ground()) { /* Make sure jumping is off. */ jumping = false; - flapping = false; - falling_from_flap = false; - if (flapping_timer.started()) { - flapping_timer.start(0); + if (backflipping) { + backflipping = false; + backflip_direction = 0; } - - physic.set_acceleration_y(0); //for flapping } // Press jump key - if(input.jump && can_jump && on_ground()) - { - if(duck) { // only jump a little bit when in duck mode { + 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 { - // jump higher if we are running - if (fabs(physic.get_velocity_x()) > MAX_WALK_XM) - physic.set_velocity_y(580); - else - physic.set_velocity_y(520); + else { //do a backflip + backflipping = true; + physic.set_velocity_y(580); + backflip_timer.start(0.15); } - - //bbox.move(Vector(0, -1)); - jumping = true; - flapping = false; - can_jump = false; - can_flap = false; - flaps_nb = 0; // Ricardo's flapping - if (size == SMALL) - SoundManager::get()->play_sound(IDToSound(SND_JUMP)); - else - SoundManager::get()->play_sound(IDToSound(SND_BIGJUMP)); - } - // Let go of jump key - else if(!input.jump) - { - if (!flapping && !duck && !falling_from_flap && !on_ground()) - { - can_flap = true; - } - if (jumping && physic.get_velocity_y() > 0) - { - jumping = false; - physic.set_velocity_y(0); - } - } - - // temporary to help player's choosing a flapping - if(flapping_mode == RICARDO_FLAP) - { - // Flapping, Ricardo's version - // similar to SM3 Fox - if(input.jump && !input.old_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) - { - // Flapping, Marek's version - if (input.jump && can_flap) - { - if (!flapping_timer.started()) - { - flapping_timer.start(TUX_FLAPPING_TIME); - flapping_velocity = physic.get_velocity_x(); - } - if (flapping_timer.check()) - { - can_flap = false; - falling_from_flap = true; - } - jumping = true; - flapping = true; - if (!flapping_timer.check()) { - 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); - } - physic.set_velocity_x(cv); - physic.set_velocity_y( - flapping_timer.get_timegone()/.850); - } - } - } - else if(flapping_mode == RYAN_FLAP) - { - // Flapping, Ryan's version - if (input.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 if (fabs(physic.get_velocity_x()) > MAX_WALK_XM) // jump higher if we are running + physic.set_velocity_y(580); else - { - physic.set_acceleration_y(0); - } - } - -#if 0 - /* In case the player has pressed Down while in a certain range of air, - enable butt jump action */ - if (input.down && !butt_jump && !duck) - if(tiles_on_air(TILES_FOR_BUTTJUMP) && jumping) - butt_jump = true; -#endif + 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) { + jumping = false; + physic.set_velocity_y(0); + } + } - /* When Down is not held anymore, disable butt jump */ - if(butt_jump && !input.down) + /* 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) + 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() && size == BIG) - { + 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)); + Vector(get_pos().x - 32, get_pos().y + 32)); butt_jump = false; - -#if 0 + // 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)) - { + 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; } -#endif - -#if 0 + // Kill nearby badguys std::vector gameobjects = Sector::current()->gameobjects; for (std::vector::iterator i = gameobjects.begin(); i != gameobjects.end(); - i++) - { + i++) { BadGuy* badguy = dynamic_cast (*i); - if(badguy) - { + 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); - } + 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 } +#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 @@ -639,95 +470,200 @@ Player::handle_vertical_input() can_jump = true; } #endif - - // FIXME: why the heck is this here and not somewhere where the keys are - // checked?!? - input.old_jump = input.jump; } void Player::handle_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: */ - handle_horizontal_input(); + 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); + } + /* Jump/jumping? */ - if (on_ground() && !input.jump) + if (on_ground() && !controller->hold(Controller::JUMP)) can_jump = true; handle_vertical_input(); /* Shoot! */ - if (input.fire && !input.old_fire && got_power != NONE_POWER) { + if (controller->pressed(Controller::ACTION) && player_status->bonus == FIRE_BONUS) { if(Sector::current()->add_bullet( -// get_pos() + 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)) + 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); - // FIXME: why the heck is this here - input.old_fire = false; } - + /* Duck! */ - if (input.down && size == BIG && !duck - && physic.get_velocity_y() == 0 && on_ground()) - { + if (controller->hold(Controller::DOWN) && is_big() && !duck + && physic.get_velocity_y() == 0 && on_ground()) { + if (adjust_height(31.8)) { duck = true; - bbox.move(Vector(0, 32)); - bbox.set_height(31.8); + unduck_hurt_timer.stop(); + } else { + // FIXME: what now? } - else if(!input.down && size == BIG && duck) - { - // try if we can really unduck - bbox.move(Vector(0, -32)); - bbox.set_height(63.8); + } + /* Unduck! */ + else if(!controller->hold(Controller::DOWN) && is_big() && duck) { + if (adjust_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); + 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); } -#endif } + } +} + +void +Player::handle_input_ghost() +{ + float vx = 0; + float vy = 0; + if (controller->hold(Controller::LEFT)) vx -= MAX_RUN_XM; + if (controller->hold(Controller::RIGHT)) vx += MAX_RUN_XM; + if ((controller->hold(Controller::UP)) || (controller->hold(Controller::JUMP))) vy += MAX_RUN_XM; + if (controller->hold(Controller::DOWN)) vy -= MAX_RUN_XM; + 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 +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::grow(bool animate) +Player::add_bonus(BonusType type, bool animate) { - if(size == BIG) + // always ignore NO_BONUS + if (type == NO_BONUS) { return; - - size = BIG; - bbox.set_height(63.8); - bbox.move(Vector(0, -32)); + } + + // 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) { + if (!adjust_height(62.8)) return; + if(animate) + growing_timer.start(GROWING_TIME); + } + + if ((type == NO_BONUS) || (type == GROWUP_BONUS)) { + 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; +} - if(animate) - growing_timer.start(GROWING_TIME); +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 (size == SMALL) - tux_body = small_tux; - else if (got_power == FIRE_POWER) + if (player_status->bonus == GROWUP_BONUS) + tux_body = big_tux; + else if (player_status->bonus == FIRE_BONUS) tux_body = fire_tux; - else if (got_power == ICE_POWER) + else if (player_status->bonus == ICE_BONUS) tux_body = ice_tux; else - tux_body = big_tux; + tux_body = small_tux; - int layer = LAYER_OBJECTS + 10; + int layer = LAYER_OBJECTS + 1; /* Set Tux sprite action */ - if (duck && size == BIG) + if (duck && is_big()) { if(dir == LEFT) tux_body->set_action("duck-left"); @@ -748,14 +684,14 @@ Player::draw(DrawingContext& context) else // dir == RIGHT tux_body->set_action("kick-right"); } - else if (butt_jump && size == BIG) + else if (butt_jump && is_big()) { if(dir == LEFT) tux_body->set_action("buttjump-left"); 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"); @@ -782,7 +718,7 @@ Player::draw(DrawingContext& context) if(idle_timer.check()) { - if(size == BIG) + if(is_big()) { if(dir == LEFT) tux_body->head->set_action("idle-left", 1); @@ -814,33 +750,18 @@ Player::draw(DrawingContext& context) /* Draw Tux */ if(dying) { - smalltux_gameover->draw(context, get_pos(), layer); - } else if(growing_timer.get_timeleft() > 0) { - if(size == SMALL) - { - 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() * - GROWING_FRAMES) / GROWING_TIME)], get_pos(), layer); - } - else - { - if (dir == RIGHT) - context.draw_surface(growingtux_right[ - int((growing_timer.get_timegone() * + } else { + context.draw_surface(growingtux_left[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); @@ -848,51 +769,127 @@ 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 (size == SMALL || duck) + if (!is_big() || duck) smalltux_star->draw(context, get_pos(), layer + 5); else bigtux_star->draw(context, get_pos(), layer + 5); - } - - if (debug_mode) - context.draw_filled_rect(get_pos(), - Vector(bbox.get_width(), bbox.get_height()), - Color(75,75,75, 150), LAYER_OBJECTS+20); + } +} + +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 && input.fire + 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; - return CONTINUE; + 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); + + // 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(input.up && !input.old_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; @@ -901,95 +898,103 @@ Player::collision(GameObject& other, const CollisionHit& hit) void Player::make_invincible() { - SoundManager::get()->play_sound(IDToSound(SND_HERRING)); + 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(safe_timer.get_timeleft() > 0 || invincible_timer.get_timeleft() > 0) + if(!completely && safe_timer.started() || invincible_timer.started()) return; - SoundManager::get()->play_sound(IDToSound(SND_HURT)); + sound_manager->play("sounds/hurt.wav"); physic.set_velocity_x(0); - if (mode == SHRINK && size == BIG) - { - if (got_power != NONE_POWER) - { - safe_timer.start(TUX_SAFE_TIME); - got_power = NONE_POWER; - } - else - { - growing_timer.start(GROWING_TIME); - safe_timer.start(TUX_SAFE_TIME + GROWING_TIME); - size = SMALL; - bbox.set_height(31.8); - duck = false; - } + 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); + safe_timer.start(TUX_SAFE_TIME /* + GROWING_TIME */); + adjust_height(30.8); + duck = false; + set_bonus(NO_BONUS); } - 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; - 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))); } -} - -/* Remove Tux's power ups */ -void -Player::remove_powerups() -{ - got_power = NONE_POWER; - size = SMALL; - bbox.set_height(31.8); + physic.enable_gravity(true); + physic.set_acceleration(0, 0); + physic.set_velocity(0, 700); + player_status->coins -= 25; + set_bonus(NO_BONUS); + 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()) + set_size(31.8, 63.8); + else + set_size(31.8, 31.8); + duck = false; + last_ground_y = vector.y; + + physic.reset(); } 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->w - bbox.get_width()) + if(get_pos().x >= camera->get_translation().x + SCREEN_WIDTH - bbox.get_width()) { - bbox.set_pos(Vector( - camera->get_translation().x + screen->w - bbox.get_width(), + set_pos(Vector( + camera->get_translation().x + SCREEN_WIDTH - bbox.get_width(), get_pos().y)); adjust = true; } @@ -1007,15 +1012,66 @@ 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 (input.jump) + if(controller->hold(Controller::JUMP)) physic.set_velocity_y(520); else - physic.set_velocity_y(200); + physic.set_velocity_y(300); +} + +//Scripting Functions Below + +void +Player::deactivate() +{ + 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() +{ + 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; + } }