File indexing completed on 2024-04-28 04:04:39

 /*
     This file is part of the game 'KTron'
 
     SPDX-FileCopyrightText: 1998-2000 Matthias Kiefer <matthias.kiefer@gmx.de>
     SPDX-FileCopyrightText: 2005 Benjamin C. Meyer <ben at meyerhome dot net>
     SPDX-FileCopyrightText: 2008-2009 Stas Verberkt <legolas at legolasweb dot nl>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 
 */
 
 #include "player.h"
 
 #include "tron.h"
 #include "settings.h"
 
 #include "ksnakeduel_debug.h"
 #include <KLocalizedString>
 #include <KUser>
 
 Player::Player(PlayField &pf, int playerNr) : QObject()
 {
     m_playField = &pf;
     m_playerNumber = playerNr;
     m_computer = false;
 
     // Calling setName() with an empty string will cause the defaults
     setName(QString());
 
     m_score = 0;
     m_dir = PlayerDirections::Up;
     m_enlarge = 0;
     m_blockSwitchDir = false;
     
     reset();
 }
 
 //
 // Get / Set
 //
 
 int Player::getPlayerNumber()
 {
     return m_playerNumber;
 }
 
 int Player::getX()
 {
     if (m_snakeParts.isEmpty())
     {
         qCDebug(KSNAKEDUEL_LOG) << "Requested coordinate of nonexistent snake";
         return 0;
     }
     
     return m_snakeParts.last().getX();
 }
 
 int Player::getY()
 {
     if (m_snakeParts.isEmpty())
     {
         qCDebug(KSNAKEDUEL_LOG) << "Requested coordinate of nonexistent snake";
         return 0;
     }
     
     return m_snakeParts.last().getY();
 }
 
 int Player::getScore()
 {
     return m_score;
 }
 
 //
 // Player name
 //
 
 QString Player::getName() const
 {
     if (isComputer())
     {
         return i18n("KSnakeDuel");
     }
     else
     {
         return m_name;
     }
 }
 
 void Player::setName(const QString &name)
 {
     if (name.isEmpty())
     {
         // If first player, name it after the user
         KUser thisUser = KUser();
 
         if (m_playerNumber == 0 && thisUser.property(KUser::FullName).isValid())
         {
             this->m_name = thisUser.property(KUser::FullName).toString();
         }
         else
         {
             this->m_name = i18n("Player %1", m_playerNumber + 1);
         }
     }
     else
     {
         this->m_name = name;
     }
 }
 
 //
 // Snake growing
 //
 
 void Player::setEnlargement(int enlargement)
 {
     if (enlargement < 0)
     {
         return;
     }
 
     m_enlarge += enlargement;
 }
 
 //
 // Directions
 //
 
 PlayerDirections::Direction Player::getDirection()
 {
     return m_dir;
 }
 
 void Player::setDirection(PlayerDirections::Direction direction)
 {
     if (m_blockSwitchDir)
     {
         return;
     }
     else if (direction == PlayerDirections::Up && m_dir == PlayerDirections::Down)
     {
         return;
     }
     else if (direction == PlayerDirections::Down && m_dir == PlayerDirections::Up)
     {
         return;
     }
     else if (direction == PlayerDirections::Left && m_dir == PlayerDirections::Right)
     {
         return;
     }
     else if (direction == PlayerDirections::Right && m_dir == PlayerDirections::Left)
     {
         return;
     }
     
     m_dir = direction;
     m_blockSwitchDir = true;
 }
 
 //
 // Live Control
 //
 
 bool Player::isAlive()
 {
     return m_alive;
 }
 
 void Player::die()
 {
     m_alive = false;
 }
 
 //
 // Score updating
 //
 
 void Player::addScore(int increment)
 {
     if (increment < 0)
     {
         return;
     }
 
     m_score += increment;
 }
 
 void Player::resetScore()
 {
     m_score = 0;
 }
 
 //
 // Start
 //
 
 void Player::setStartPosition()
 {
     while (!m_snakeParts.isEmpty())
     {
         m_snakeParts.dequeue();
     }
     
     int x = (2 - getPlayerNumber()) * m_playField->getWidth() / 3;
     int y = m_playField->getHeight() / 2;
     
     SnakePart head(getPlayerNumber());
     head.setPartTop(true);
     head.setPartLeft(true);
     head.setPartRight(true);
     head.setPartType(SnakePartType::Head);
     head.generateSVGName();
     
     SnakePart tail(getPlayerNumber());
     tail.setPartBottom(true);
     tail.setPartLeft(true);
     tail.setPartRight(true);
     if (Settings::gameType() == Settings::EnumGameType::Snake)
     {
         tail.setPartType(SnakePartType::Tail);
     }
     else
     {
         tail.setPartType(SnakePartType::Hole);
     }
     tail.generateSVGName();
     
     m_playField->setObjectAt(x, y, head);
     m_playField->setObjectAt(x, y + 1, tail);
     
     m_snakeParts.enqueue(tail);
     m_snakeParts.enqueue(head);
     
     // Make the computer player start some random direction
     if (isComputer())
     {
         switch ((int)(rand() % 3))
         {
             default:
             case 0:
                 m_dir = PlayerDirections::Up;
                 break;
             case 1:
                 m_dir = PlayerDirections::Left;
                 break;
             case 2:
                 m_dir = PlayerDirections::Right;
                 break;
         }
         
         m_blockSwitchDir = true;
     }
     else
     {
         m_dir = PlayerDirections::Up;
     }
 }
 
 //
 // Movement
 //
 
 void Player::movePlayer()
 {
     int oldX = m_snakeParts.last().getX();
     int oldY = m_snakeParts.last().getY();
     SnakePart newHead(m_playerNumber);
 
     int newX = oldX;
     int newY = oldY;
 
     newHead.setPartType(SnakePartType::Head);
 
     switch (m_dir)
     {
         case PlayerDirections::Up:
             newY--;
             newHead.setPartTop(true);
             newHead.setPartLeft(true);
             newHead.setPartRight(true);
             break;
         case PlayerDirections::Down:
             newY++;
             newHead.setPartBottom(true);
             newHead.setPartLeft(true);
             newHead.setPartRight(true);
             break;
         case PlayerDirections::Left:
             newX--;
             newHead.setPartTop(true);
             newHead.setPartBottom(true);
             newHead.setPartLeft(true);
             break;
         case PlayerDirections::Right:
             newX++;
             newHead.setPartTop(true);
             newHead.setPartBottom(true);
             newHead.setPartRight(true);
             break;
         default:
             break;
     }
     
     if (crashed(newX, newY))
     {
         //qCDebug(KSNAKEDUEL_LOG) << "Crashed at: (" << newX << ", " << newY << ")";
         m_alive = false;
     }
     
     if (m_alive)
     {
         switch (m_dir)
         {
             // unset drawing flags in the moving direction
             case PlayerDirections::Up:
                 m_snakeParts.last().setPartTop(false);
                 break;
             case PlayerDirections::Down:
                 m_snakeParts.last().setPartBottom(false);
                 break;
             case PlayerDirections::Right:
                 m_snakeParts.last().setPartRight(false);
                 break;
             case PlayerDirections::Left:
                 m_snakeParts.last().setPartLeft(false);
                 break;
             default:
                 break;
         }
         m_snakeParts.last().setPartType(SnakePartType::Body);
         m_snakeParts.last().generateSVGName();
         m_playField->setObjectAt(m_snakeParts.last().getX(), m_snakeParts.last().getY(), m_snakeParts.last());
         
         if (m_playField->getObjectAt(newX, newY)->getObjectType() == ObjectType::Item)
         {
             //qCDebug(KSNAKEDUEL_LOG) << "Boom!";
             Q_EMIT fetchedItem(m_playerNumber, newX, newY);
         }
 
         newHead.generateSVGName();
         m_playField->setObjectAt(newX, newY, newHead);
         m_snakeParts.enqueue(newHead);
     }
 
     if (m_alive && m_enlarge == 0 && Settings::gameType() == Settings::EnumGameType::Snake)
     {
         SnakePart oldTail = m_snakeParts.dequeue();
         
         if (!oldTail.getPartTop())
         {
             m_snakeParts.head().setPartBottom(true);
         }
         else if (!oldTail.getPartBottom())
         {
             m_snakeParts.head().setPartTop(true);
         }
         else if (!oldTail.getPartLeft())
         {
             m_snakeParts.head().setPartRight(true);
         }
         else if (!oldTail.getPartRight())
         {
             m_snakeParts.head().setPartLeft(true);
         }
         
         m_snakeParts.head().setPartType(SnakePartType::Tail);
         m_snakeParts.head().generateSVGName();
         m_playField->setObjectAt(m_snakeParts.head().getX(), m_snakeParts.head().getY(), m_snakeParts.head());
         
         Object emptyObject = Object();
         m_playField->setObjectAt(oldTail.getX(), oldTail.getY(), emptyObject);
     }
     else if (m_enlarge > 0)
     {
         m_enlarge--;
     }
     
     m_blockSwitchDir = false;
 }
 
 //
 // Crash check
 //
 
 bool Player::crashed(int x, int y)
 {
     if (x < 0 || y < 0 || x >= m_playField->getWidth() || y >= m_playField->getHeight())
     {
         return true;
     }
     else
     {
         ObjectType::Type objType = m_playField->getObjectAt(x, y)->getObjectType();
         return (objType != ObjectType::Item && objType != ObjectType::Object);
     }
 }
 
 //
 // Reset
 //
 
 void Player::reset()
 {
     m_alive = true;
     m_accelerated = false;
     m_enlarge = 0;
     m_keyPressed = m_computer;
     m_blockSwitchDir = false;
 }
 
 //
 // Computer powered
 //
 
 bool Player::isComputer() const
 {
     return m_computer;
 }
 
 void Player::setComputer(bool isComputer)
 {
     m_computer = isComputer;
     m_keyPressed = m_computer;
 }
 
 //
 // Acceleration
 //
 
 bool Player::isAccelerated()
 {
     return m_accelerated;
 }
 
 void Player::setAccelerated(bool value)
 {
     m_accelerated = value;
 }
 
 
 //
 // Key pressed
 //
 
 bool Player::hasKeyPressed()
 {
     return m_keyPressed;
 }
 
 void Player::setKeyPressed(bool value)
 {
     m_keyPressed = value;
 }
 
 #include "moc_player.cpp"