jaildesigner-jailgames/coffee_crisis_arcade_edition
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 13 Wiki Activity

Player: afegides animacions per al estat WAITING

Browse Source 
Player: si tires a jugar desde el estat WAITING passes al ENTERING_SCREEN i despres sempre tens inmunitat, fins i tot la primera volta (al començar el joc)
falta: arregñar el z-order per al estat WAITING
This commit is contained in:
Sergio
2025-07-25 20:54:00 +02:00
parent b165484e03
commit 03a7bbc6d1
17 changed files with 619 additions and 554 deletions
Download Patch File Download Diff File Expand all files Collapse all files

264
source/player.cpp
View File

@@ -42,9 +42,8 @@ Player::Player(int id, float x, int y, bool demo, SDL_FRect &play_area, std::vec
void Player::init() {
// Inicializa variables de estado
pos_y_ = default_pos_y_;
walking_state_ = PlayerState::WALKING_STOP;
firing_state_ = PlayerState::FIRING_NONE;
playing_state_ = PlayerState::WAITING;
walking_state_ = State::WALKING_STOP;
firing_state_ = State::FIRING_NONE;
power_up_ = false;
power_up_counter_ = POWERUP_COUNTER;
extra_hit_ = false;
@@ -73,12 +72,12 @@ void Player::init() {
// Actua en consecuencia de la entrada recibida
void Player::setInput(InputAction input) {
switch (playing_state_) {
case PlayerState::PLAYING: {
case State::PLAYING: {
setInputPlaying(input);
break;
}
case PlayerState::ENTERING_NAME:
case PlayerState::ENTERING_NAME_GAME_COMPLETED: {
case State::ENTERING_NAME:
case State::ENTERING_NAME_GAME_COMPLETED: {
setInputEnteringName(input);
break;
}
@@ -92,29 +91,29 @@ void Player::setInputPlaying(InputAction input) {
switch (input) {
case InputAction::LEFT: {
vel_x_ = -BASE_SPEED;
setWalkingState(PlayerState::WALKING_LEFT);
setWalkingState(State::WALKING_LEFT);
break;
}
case InputAction::RIGHT: {
vel_x_ = BASE_SPEED;
setWalkingState(PlayerState::WALKING_RIGHT);
setWalkingState(State::WALKING_RIGHT);
break;
}
case InputAction::FIRE_CENTER: {
setFiringState(PlayerState::FIRING_UP);
setFiringState(State::FIRING_UP);
break;
}
case InputAction::FIRE_LEFT: {
setFiringState(PlayerState::FIRING_LEFT);
setFiringState(State::FIRING_LEFT);
break;
}
case InputAction::FIRE_RIGHT: {
setFiringState(PlayerState::FIRING_RIGHT);
setFiringState(State::FIRING_RIGHT);
break;
}
default: {
vel_x_ = 0;
setWalkingState(PlayerState::WALKING_STOP);
setWalkingState(State::WALKING_STOP);
break;
}
}
@@ -147,27 +146,30 @@ void Player::setInputEnteringName(InputAction input) {
// Mueve el jugador a la posición y animación que le corresponde
void Player::move() {
switch (playing_state_) {
case PlayerState::PLAYING:
case State::PLAYING:
handlePlayingMovement();
break;
case PlayerState::ROLLING:
case State::ROLLING:
handleRollingMovement();
break;
case PlayerState::TITLE_ANIMATION:
case State::TITLE_ANIMATION:
handleTitleAnimation();
break;
case PlayerState::CONTINUE_TIME_OUT:
case State::CONTINUE_TIME_OUT:
handleContinueTimeOut();
break;
case PlayerState::LEAVING_SCREEN:
case State::LEAVING_SCREEN:
handleLeavingScreen();
break;
case PlayerState::ENTERING_SCREEN:
case State::ENTERING_SCREEN:
handleEnteringScreen();
break;
case PlayerState::CREDITS:
case State::CREDITS:
handleCreditsMovement();
break;
case State::WAITING:
handleWaitingMovement();
break;
default:
break;
}
@@ -215,9 +217,9 @@ void Player::handleRollingGroundCollision() {
}
void Player::handleRollingStop() {
const auto NEXT_PLAYER_STATUS = isEligibleForHighScore() ? PlayerState::ENTERING_NAME : PlayerState::CONTINUE;
const auto NEXT_PLAYER_STATUS = isEligibleForHighScore() ? State::ENTERING_NAME : State::CONTINUE;
const auto NEXT_STATE = demo_ ? PlayerState::LYING_ON_THE_FLOOR_FOREVER : NEXT_PLAYER_STATUS;
const auto NEXT_STATE = demo_ ? State::LYING_ON_THE_FLOOR_FOREVER : NEXT_PLAYER_STATUS;
setPlayingState(NEXT_STATE);
pos_x_ = player_sprite_->getPosX();
@@ -245,14 +247,15 @@ void Player::handleTitleAnimation() {
shiftSprite();
if (pos_x_ == MIN_X || pos_x_ == MAX_X) {
setPlayingState(PlayerState::TITLE_HIDDEN);
setPlayingState(State::TITLE_HIDDEN);
}
}
void Player::handleContinueTimeOut() {
// Si el cadaver desaparece por el suelo, cambia de estado
if (player_sprite_->getPosY() > play_area_.h) {
setPlayingState(PlayerState::WAITING);
player_sprite_->stop();
setPlayingState(State::WAITING);
}
}
@@ -267,7 +270,7 @@ void Player::handleLeavingScreen() {
shiftSprite();
if (pos_x_ == MIN_X || pos_x_ == MAX_X) {
setPlayingState(PlayerState::GAME_OVER);
setPlayingState(State::GAME_OVER);
}
}
@@ -288,8 +291,7 @@ void Player::handlePlayer1Entering() {
pos_x_ += vel_x_;
if (pos_x_ > default_pos_x_) {
pos_x_ = default_pos_x_;
setPlayingState(PlayerState::PLAYING);
setInvulnerable(false);
setPlayingState(State::RESPAWNING);
}
}
@@ -298,8 +300,7 @@ void Player::handlePlayer2Entering() {
pos_x_ += vel_x_;
if (pos_x_ < default_pos_x_) {
pos_x_ = default_pos_x_;
setPlayingState(PlayerState::PLAYING);
setInvulnerable(false);
setPlayingState(State::RESPAWNING);
}
}
@@ -330,11 +331,19 @@ void Player::handleCreditsLeftMovement() {
}
}
void Player::handleWaitingMovement() {
++waiting_counter_;
if (waiting_counter_ == WAITING_COUNTER) {
waiting_counter_ = 0;
player_sprite_->resetAnimation();
}
}
void Player::updateWalkingStateForCredits() {
if (pos_x_ > param.game.game_area.center_x - WIDTH / 2) {
setWalkingState(PlayerState::WALKING_LEFT);
setWalkingState(State::WALKING_LEFT);
} else {
setWalkingState(PlayerState::WALKING_RIGHT);
setWalkingState(State::WALKING_RIGHT);
}
}
@@ -374,25 +383,25 @@ void Player::render() {
// Establece la animación correspondiente al estado
void Player::setAnimation() {
switch (playing_state_) {
case PlayerState::PLAYING:
case PlayerState::ENTERING_NAME_GAME_COMPLETED:
case PlayerState::ENTERING_SCREEN:
case PlayerState::LEAVING_SCREEN:
case PlayerState::TITLE_ANIMATION:
case PlayerState::CREDITS: {
case State::PLAYING:
case State::ENTERING_NAME_GAME_COMPLETED:
case State::ENTERING_SCREEN:
case State::LEAVING_SCREEN:
case State::TITLE_ANIMATION:
case State::CREDITS: {
// Crea cadenas de texto para componer el nombre de la animación
const std::string WALK_ANIMATION = walking_state_ == PlayerState::WALKING_STOP ? "stand" : "walk";
const std::string FIRE_ANIMATION = firing_state_ == PlayerState::FIRING_UP ? "-fire-center" : "-fire-side";
const std::string RECOIL_ANIMATION = firing_state_ == PlayerState::RECOILING_UP ? "-recoil-center" : "-recoil-side";
const std::string COOL_ANIMATION = firing_state_ == PlayerState::COOLING_UP ? "-cool-center" : "-cool-side";
const std::string WALK_ANIMATION = walking_state_ == State::WALKING_STOP ? "stand" : "walk";
const std::string FIRE_ANIMATION = firing_state_ == State::FIRING_UP ? "-fire-center" : "-fire-side";
const std::string RECOIL_ANIMATION = firing_state_ == State::RECOILING_UP ? "-recoil-center" : "-recoil-side";
const std::string COOL_ANIMATION = firing_state_ == State::COOLING_UP ? "-cool-center" : "-cool-side";
const SDL_FlipMode FLIP_WALK = walking_state_ == PlayerState::WALKING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_FlipMode FLIP_FIRE = firing_state_ == PlayerState::FIRING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_FlipMode FLIP_RECOIL = firing_state_ == PlayerState::RECOILING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_FlipMode FLIP_COOL = firing_state_ == PlayerState::COOLING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_FlipMode FLIP_WALK = walking_state_ == State::WALKING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_FlipMode FLIP_FIRE = firing_state_ == State::FIRING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_FlipMode FLIP_RECOIL = firing_state_ == State::RECOILING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_FlipMode FLIP_COOL = firing_state_ == State::COOLING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
// Establece la animación a partir de las cadenas
if (firing_state_ == PlayerState::FIRING_NONE) {
if (firing_state_ == State::FIRING_NONE) {
// No esta disparando
player_sprite_->setCurrentAnimation(WALK_ANIMATION, false);
player_sprite_->setFlip(FLIP_WALK);
@@ -413,18 +422,22 @@ void Player::setAnimation() {
}
break;
}
case PlayerState::ROLLING:
case PlayerState::CONTINUE_TIME_OUT: {
case State::WAITING: {
player_sprite_->setCurrentAnimation("hello");
break;
}
case State::ROLLING:
case State::CONTINUE_TIME_OUT: {
player_sprite_->setCurrentAnimation("rolling");
break;
}
case PlayerState::LYING_ON_THE_FLOOR_FOREVER:
case PlayerState::ENTERING_NAME:
case PlayerState::CONTINUE: {
case State::LYING_ON_THE_FLOOR_FOREVER:
case State::ENTERING_NAME:
case State::CONTINUE: {
player_sprite_->setCurrentAnimation("dead");
break;
}
case PlayerState::CELEBRATING: {
case State::CELEBRATING: {
player_sprite_->setCurrentAnimation("celebration");
break;
}
@@ -439,7 +452,7 @@ void Player::setAnimation() {
// Actualiza el valor de la variable
void Player::updateCooldown() {
if (playing_state_ != PlayerState::PLAYING) {
if (playing_state_ != State::PLAYING) {
return;
}
@@ -488,14 +501,14 @@ void Player::handleCoolingState() {
void Player::transitionToRecoiling() {
switch (firing_state_) {
case PlayerState::FIRING_LEFT:
setFiringState(PlayerState::RECOILING_LEFT);
case State::FIRING_LEFT:
setFiringState(State::RECOILING_LEFT);
break;
case PlayerState::FIRING_RIGHT:
setFiringState(PlayerState::RECOILING_RIGHT);
case State::FIRING_RIGHT:
setFiringState(State::RECOILING_RIGHT);
break;
case PlayerState::FIRING_UP:
setFiringState(PlayerState::RECOILING_UP);
case State::FIRING_UP:
setFiringState(State::RECOILING_UP);
break;
default:
break;
@@ -504,14 +517,14 @@ void Player::transitionToRecoiling() {
void Player::transitionToCooling() {
switch (firing_state_) {
case PlayerState::RECOILING_LEFT:
setFiringState(PlayerState::COOLING_LEFT);
case State::RECOILING_LEFT:
setFiringState(State::COOLING_LEFT);
break;
case PlayerState::RECOILING_RIGHT:
setFiringState(PlayerState::COOLING_RIGHT);
case State::RECOILING_RIGHT:
setFiringState(State::COOLING_RIGHT);
break;
case PlayerState::RECOILING_UP:
setFiringState(PlayerState::COOLING_UP);
case State::RECOILING_UP:
setFiringState(State::COOLING_UP);
break;
default:
break;
@@ -519,7 +532,7 @@ void Player::transitionToCooling() {
}
void Player::completeCooling() {
setFiringState(PlayerState::FIRING_NONE);
setFiringState(State::FIRING_NONE);
cooling_state_counter_ = -1;
}
@@ -547,14 +560,14 @@ void Player::addScore(int score) {
// Actualiza el panel del marcador
void Player::updateScoreboard() {
switch (playing_state_) {
case PlayerState::CONTINUE: {
Scoreboard::get()->setContinue(getScoreBoardPanel(), getContinueCounter());
case State::CONTINUE: {
Scoreboard::get()->setContinue(scoreboard_panel_, getContinueCounter());
break;
}
case PlayerState::ENTERING_NAME:
case PlayerState::ENTERING_NAME_GAME_COMPLETED: {
Scoreboard::get()->setRecordName(getScoreBoardPanel(), enter_name_->getCurrentName());
Scoreboard::get()->setSelectorPos(getScoreBoardPanel(), getRecordNamePos());
case State::ENTERING_NAME:
case State::ENTERING_NAME_GAME_COMPLETED: {
Scoreboard::get()->setRecordName(scoreboard_panel_, enter_name_->getCurrentName());
Scoreboard::get()->setSelectorPos(scoreboard_panel_, getRecordNamePos());
break;
}
default:
@@ -563,55 +576,70 @@ void Player::updateScoreboard() {
}
// Cambia el modo del marcador
void Player::setScoreboardMode(ScoreboardMode mode) const {
void Player::setScoreboardMode(Scoreboard::Mode mode) const {
if (!demo_) {
Scoreboard::get()->setMode(getScoreBoardPanel(), mode);
Scoreboard::get()->setMode(scoreboard_panel_, mode);
}
}
// Establece el estado del jugador en el juego
void Player::setPlayingState(PlayerState state) {
void Player::setPlayingState(State state) {
playing_state_ = state;
switch (playing_state_) {
case PlayerState::RESPAWNING: {
case State::RESPAWNING: {
setInvulnerable(true);
addCredit();
playSound("voice_thankyou.wav");
setPlayingState(PlayerState::PLAYING);
setPlayingState(State::PLAYING);
}
case PlayerState::PLAYING: {
case State::PLAYING: {
init();
playing_state_ = PlayerState::PLAYING;
setScoreboardMode(ScoreboardMode::SCORE);
playing_state_ = State::PLAYING;
setScoreboardMode(Scoreboard::Mode::SCORE);
Stage::power_can_be_added = true;
break;
}
case PlayerState::CONTINUE: {
case State::CONTINUE: {
// Inicializa el contador de continuar
continue_ticks_ = SDL_GetTicks();
continue_counter_ = 9;
setScoreboardMode(ScoreboardMode::CONTINUE);
setScoreboardMode(Scoreboard::Mode::CONTINUE);
playSound("continue_clock.wav");
break;
}
case PlayerState::WAITING: {
pos_x_ = default_pos_x_;
setScoreboardMode(ScoreboardMode::WAITING);
case State::WAITING: {
switch (id_) {
case 1:
pos_x_ = param.game.game_area.rect.x;
break;
case 2:
pos_x_ = param.game.game_area.rect.w - WIDTH;
break;
default:
pos_x_ = 0;
break;
}
pos_y_ = default_pos_y_;
waiting_counter_ = 0;
shiftSprite();
player_sprite_->setCurrentAnimation("hello");
player_sprite_->animtionPause();
setScoreboardMode(Scoreboard::Mode::WAITING);
break;
}
case PlayerState::ENTERING_NAME: {
setScoreboardMode(ScoreboardMode::ENTER_NAME);
case State::ENTERING_NAME: {
setScoreboardMode(Scoreboard::Mode::ENTER_NAME);
break;
}
case PlayerState::SHOWING_NAME: {
case State::SHOWING_NAME: {
showing_name_ticks_ = SDL_GetTicks();
setScoreboardMode(ScoreboardMode::SHOW_NAME);
setScoreboardMode(Scoreboard::Mode::SHOW_NAME);
Scoreboard::get()->setRecordName(scoreboard_panel_, last_enter_name_);
addScoreToScoreBoard();
break;
}
case PlayerState::ROLLING: {
case State::ROLLING: {
// Activa la animación de rodar
player_sprite_->setCurrentAnimation("rolling");
player_sprite_->setAnimationSpeed(4);
@@ -620,52 +648,52 @@ void Player::setPlayingState(PlayerState state) {
(rand() % 2 == 0) ? player_sprite_->setVelX(3.3F) : player_sprite_->setVelX(-3.3F);
break;
}
case PlayerState::TITLE_ANIMATION: {
case State::TITLE_ANIMATION: {
// Activa la animación de rodar
player_sprite_->setCurrentAnimation("walk");
playSound("voice_thankyou.wav");
break;
}
case PlayerState::TITLE_HIDDEN: {
case State::TITLE_HIDDEN: {
player_sprite_->setVelX(0.0F);
player_sprite_->setVelY(0.0F);
break;
}
case PlayerState::CONTINUE_TIME_OUT: {
case State::CONTINUE_TIME_OUT: {
// Activa la animación de morir
player_sprite_->setAccelY(0.2F);
player_sprite_->setVelY(-4.0F);
player_sprite_->setVelX(0.0F);
player_sprite_->setCurrentAnimation("rolling");
player_sprite_->setAnimationSpeed(5);
setScoreboardMode(ScoreboardMode::GAME_OVER);
setScoreboardMode(Scoreboard::Mode::GAME_OVER);
playSound("voice_aw_aw_aw.wav");
playSound("jump.wav");
break;
}
case PlayerState::GAME_OVER: {
setScoreboardMode(ScoreboardMode::GAME_OVER);
case State::GAME_OVER: {
setScoreboardMode(Scoreboard::Mode::GAME_OVER);
break;
}
case PlayerState::CELEBRATING: {
case State::CELEBRATING: {
game_completed_ = true;
setScoreboardMode(ScoreboardMode::SCORE);
setScoreboardMode(Scoreboard::Mode::SCORE);
break;
}
case PlayerState::ENTERING_NAME_GAME_COMPLETED: {
setWalkingState(PlayerState::WALKING_STOP);
setFiringState(PlayerState::FIRING_NONE);
setScoreboardMode(ScoreboardMode::ENTER_NAME);
case State::ENTERING_NAME_GAME_COMPLETED: {
setWalkingState(State::WALKING_STOP);
setFiringState(State::FIRING_NONE);
setScoreboardMode(Scoreboard::Mode::ENTER_NAME);
break;
}
case PlayerState::LEAVING_SCREEN: {
case State::LEAVING_SCREEN: {
step_counter_ = 0;
setScoreboardMode(ScoreboardMode::GAME_COMPLETED);
setScoreboardMode(Scoreboard::Mode::GAME_COMPLETED);
break;
}
case PlayerState::ENTERING_SCREEN: {
case State::ENTERING_SCREEN: {
step_counter_ = 0;
setScoreboardMode(ScoreboardMode::SCORE);
setScoreboardMode(Scoreboard::Mode::SCORE);
switch (id_) {
case 1:
pos_x_ = param.game.game_area.rect.x - WIDTH;
@@ -680,8 +708,8 @@ void Player::setPlayingState(PlayerState state) {
}
break;
}
case PlayerState::CREDITS: {
vel_x_ = (walking_state_ == PlayerState::WALKING_RIGHT) ? BASE_SPEED : -BASE_SPEED;
case State::CREDITS: {
vel_x_ = (walking_state_ == State::WALKING_RIGHT) ? BASE_SPEED : -BASE_SPEED;
break;
}
default:
@@ -709,7 +737,7 @@ void Player::setInvulnerable(bool value) {
// Monitoriza el estado
void Player::updateInvulnerable() {
if (playing_state_ == PlayerState::PLAYING) {
if (playing_state_ == State::PLAYING) {
if (invulnerable_) {
if (invulnerable_counter_ > 0) {
--invulnerable_counter_;
@@ -730,7 +758,7 @@ void Player::setPowerUp() {
// Actualiza el valor de la variable
void Player::updatePowerUp() {
if (playing_state_ == PlayerState::PLAYING) {
if (playing_state_ == State::PLAYING) {
if (power_up_) {
--power_up_counter_;
power_up_ = power_up_counter_ > 0;
@@ -772,7 +800,7 @@ void Player::setPlayerTextures(const std::vector<std::shared_ptr<Texture>> &text
// Actualiza el contador de continue
void Player::updateContinueCounter() {
if (playing_state_ == PlayerState::CONTINUE) {
if (playing_state_ == State::CONTINUE) {
constexpr int TICKS_SPEED = 1000;
if (SDL_GetTicks() - continue_ticks_ > TICKS_SPEED) {
decContinueCounter();
@@ -782,7 +810,7 @@ void Player::updateContinueCounter() {
// Actualiza el contador de entrar nombre
void Player::updateEnterNameCounter() {
if (playing_state_ == PlayerState::ENTERING_NAME || playing_state_ == PlayerState::ENTERING_NAME_GAME_COMPLETED) {
if (playing_state_ == State::ENTERING_NAME || playing_state_ == State::ENTERING_NAME_GAME_COMPLETED) {
constexpr int TICKS_SPEED = 1000;
if (SDL_GetTicks() - name_entry_ticks_ > TICKS_SPEED) {
decNameEntryCounter();
@@ -792,10 +820,10 @@ void Player::updateEnterNameCounter() {
// Actualiza el estado de SHOWING_NAME
void Player::updateShowingName() {
if (playing_state_ == PlayerState::SHOWING_NAME) {
if (playing_state_ == State::SHOWING_NAME) {
constexpr int TICKS_SPEED = 5000;
if (SDL_GetTicks() - name_entry_ticks_ > TICKS_SPEED) {
game_completed_ ? setPlayingState(PlayerState::LEAVING_SCREEN) : setPlayingState(PlayerState::CONTINUE);
game_completed_ ? setPlayingState(State::LEAVING_SCREEN) : setPlayingState(State::CONTINUE);
}
}
}
@@ -805,7 +833,7 @@ void Player::decContinueCounter() {
continue_ticks_ = SDL_GetTicks();
--continue_counter_;
if (continue_counter_ < 0) {
setPlayingState(PlayerState::CONTINUE_TIME_OUT);
setPlayingState(State::CONTINUE_TIME_OUT);
} else {
playSound("continue_clock.wav");
}
@@ -824,11 +852,11 @@ void Player::decNameEntryCounter() {
(name_entry_idle_counter_ >= param.game.name_entry_idle_time)) {
name_entry_total_counter_ = 0;
name_entry_idle_counter_ = 0;
if (playing_state_ == PlayerState::ENTERING_NAME) {
if (playing_state_ == State::ENTERING_NAME) {
last_enter_name_ = getRecordName();
setPlayingState(PlayerState::SHOWING_NAME);
setPlayingState(State::SHOWING_NAME);
} else {
setPlayingState(PlayerState::LEAVING_SCREEN);
setPlayingState(State::LEAVING_SCREEN);
}
}
}
@@ -861,7 +889,7 @@ void Player::playSound(const std::string &name) const {
// Indica si se puede dibujar el objeto
auto Player::isRenderable() const -> bool {
return !isWaiting() && !isGameOver() && !isTitleHidden();
return !isGameOver() && !isTitleHidden();
};
// Añade una puntuación a la tabla de records