source: code/branches/OrxoBlox_FS19/src/modules/OrxoBlox/TempData/OrxoBloxBall.cc @ 12248

//TODO: Sounds (all the sounds are still from the OrxoBlox module...)
//TODO: Blocks (the Ball-Block comunication is based on how the blocks are implemented)
//TODO: The bottom boundary/ the Ball collecter
//TODO: Ability to shoot the ball (the ball is still constructed like the OrxoBlox ball)

/*
 *   ORXONOX - the hottest 3D action shooter ever to exist
 *                    > www.orxonox.net <
 *
 *
 *   License notice:
 *
 *   This program is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public License
 *   as published by the Free Software Foundation; either version 2
 *   of the License, or (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 *   Author:
 *      Fabian 'x3n' Landau
 *   Co-authors:
 *      ...
 *
 */

/**
    @file OrxoBloxBall.cc
    @brief Implementation of the OrxoBloxBall class.
*/

#include "OrxoBloxBall.h"

#include "core/CoreIncludes.h"
#include "core/GameMode.h"

#include "gametypes/Gametype.h"

#include "OrxoBloxBlocks.h"

#include "sound/WorldSound.h"
#include "core/XMLPort.h"

namespace orxonox
{
    RegisterClass(OrxoBloxBall);

    const float OrxoBloxBall::MAX_REL_Z_VELOCITY = 1.5;

    /**
    @brief
        Constructor. Registers and initializes the object.
    */
    OrxoBloxBall::OrxoBloxBall(Context* context)
        : MovableEntity(context)
    {
        RegisterObject(OrxoBloxBall);

        this->speed_ = 0;
        //NUMBER OF BLOCKS IS A CONSTANT AT THE MOMENT, DYNAMICAL IMPLEMENTATION WOULD BE NICE
        this->nblocks_ = 20;                                            //number of blocks on the field
        this->blocks_ = new OrxoBloxStone[this.nblocks_];               //the blocks in a block array
        this->fieldWidth_ = 100;
        this->fieldHeight_ = 100;

        this->registerVariables();

        //initialize sound
        if (GameMode::isMaster())
             {
                 this->defBoundarySound_ = new WorldSound(this->getContext());
                 this->defBoundarySound_->setVolume(0.5f);
             }
             else
             {
                 this->defBoundarySound_ = nullptr;
             }
    }

    /**
    @brief
        Destructor.
    */
    OrxoBloxBall::~OrxoBloxBall()
    {
        this.destroy();
    }

    //xml port for loading sounds
    void OrxoBloxBall::XMLPort(Element& xmlelement, XMLPort::Mode mode)
    {
        SUPER(OrxoBloxBall, XMLPort, xmlelement, mode);
        XMLPortParam(OrxoBloxBall, "defBoundarySound",  setDefBoundarySound,  getDefBoundarySound,  xmlelement, mode);
    }

    /**
    @brief
        Register variables to synchronize over the network.
    */
    void OrxoBloxBall::registerVariables()
    {
        registerVariable( this->fieldWidth_ );
        registerVariable( this->fieldHeight_ );
        registerVariable( this->speed_ );
        registerVariable( this->nblocks_ );
        registerVariable( this->blocks_ );
    }

    /**
    @brief
        Is called every tick.
        Handles the movement of the ball and its interaction with the boundaries and blocks.
    @param dt
        The time since the last tick.
    */
    void OrxoBloxBall::tick(float dt)
    {
        SUPER(OrxoBloxBall, tick, dt);

        // Get the current position, velocity and acceleration of the ball.
        Vector3 position = this->getPosition();
        Vector3 velocity = this->getVelocity();
        Vector3 acceleration = this->getAcceleration();

        // If the ball has hit the boundaries on either the right side or the left 
        if (position.x > this->fieldWidth_  || position.x < 0)
        {
            defBoundarySound_->play(); //play boundary sound
            // Its velocity in x-direction is inverted (i.e. it bounces off).
            velocity.x = -velocity.x;
            // And its position is set as to not overstep the boundary it has just crossed.
            if (position.x > this->fieldWidth_)
                position.x = this->fieldWidth_;
            else if (position.x < 0)
                position.x = 0;

            this->fireEvent();
        }

           // If the ball has hit the boundary on the top
        if (position.y > this->fieldHeight_)
        {
            defBoundarySound_->play(); //play boundary sound
            // Its velocity in z-direction is inverted (i.e. it bounces off).
            velocity.y = -velocity.y;
            // And its position is set as to not overstep the boundary it has just crossed.
            position.y = this->fieldHeight_;

            this->fireEvent();
        }

        //If the ball collides with a block
        for (int i = 0; i < this.nblocks_ ; i++) {

            if (
                (-position.x + this->blocks[i]_.getLeft())      < 0 ||
                (position.x - this->blocks[i]_.getRight())      < 0 ||
                (-position.y + this->blocks[i]_.getBottom())    < 0 ||
                (position.y - this->blocks[i]_.getTop())        < 0
            ) {
                int dist_left = position.x - this->blocks[i]_.getLeft();
                int dist_right = -position.x + this->blocks[i]_.getRight();
                int dist_bot = position.y - this->blocks[i]_.getBottom();
                int dist top = -position.y + this->blocks[i]_.getTop();

                if (dist_left < dist_right){
                    if(dist_left < dist_top && dist_left < dist_bot) {
                        defBoundarySound_->play();
                        velocity.x = -velocity.x;
                        position.x = this->blocks[i]_.getLeft();

                    }
                    else if(dist_left == dist_top) {
                        defBoundarySound_->play();
                        velocity.x = -velocity.x;
                        velocity.y = -velocity.y;
                        position.x = this->blocks[i]_.getLeft();
                        position.y = this->blocks[i]_.getTop();
                    }
                    else if(dist_left == dist_bot) {
                        defBoundarySound_->play();
                        velocity.x = -velocity.x;
                        velocity.y = -velocity.y;
                        position.x = this->blocks[i]_.getLeft();
                        position.y = this->blocks[i]_.getBot();
                    }
                }
                else if (dist_right < dist_left){
                    if(dist_right < dist_top && dist_left < dist_bot) {
                        defBoundarySound_->play();
                        velocity.x = -velocity.x;
                        position.x = this->blocks[i]_.getRight();

                    }
                    else if(dist_right == dist_top) {
                        defBoundarySound_->play();
                        velocity.x = -velocity.x;
                        velocity.y = -velocity.y;
                        position.x = this->blocks[i]_.getRight();
                        position.y = this->blocks[i]_.getTop();
                    }
                    else if(dist_right == dist_bot) {
                        defBoundarySound_->play();
                        velocity.x = -velocity.x;
                        velocity.y = -velocity.y;
                        position.x = this->blocks[i]_.getRight();
                        position.y = this->blocks[i]_.getBot();
                    }
                }
                else if (dist_bot < dist_top){
                    if(dist_bot < dist_left && dist_bot < dist_right) {
                        defBoundarySound_->play();
                        velocity.y = -velocity.y;
                        position.y = this->blocks[i]_.getBot();

                    }
                    else if(dist_bot == dist_left) {
                        defBoundarySound_->play();
                        velocity.x = -velocity.x;
                        velocity.y = -velocity.y;
                        position.x = this->blocks[i]_.getLeft();
                        position.y = this->blocks[i]_.getBot();
                    }
                    else if(dist_bot == dist_right) {
                        defBoundarySound_->play();
                        velocity.x = -velocity.x;
                        velocity.y = -velocity.y;
                        position.x = this->blocks[i]_.getRight();
                        position.y = this->blocks[i]_.getBot();
                    }
                }
                else if (dist_top bot){
                    if(dist_top < dist_left && dist_top < dist_right) {
                        defBoundarySound_->play();
                        velocity.y = -velocity.y;
                        position.y = this->blocks[i]_.getBot();

                    }
                    else if(dist_top == dist_left) {
                        defBoundarySound_->play();
                        velocity.x = -velocity.x;
                        velocity.y = -velocity.y;
                        position.x = this->blocks[i]_.getLeft();
                        position.y = this->blocks[i]_.getTop();
                    }
                    else if(dist_top == dist_right) {
                        defBoundarySound_->play();
                        velocity.x = -velocity.x;
                        velocity.y = -velocity.y;
                        position.x = this->blocks[i]_.getRight();
                        position.y = this->blocks[i]_.getTop();
                    }
                }
                this->blocks[i]_.gotHit()
                this->fireEvent();
            }
        } 

        // If the ball has crossed the bottom boundary
        if (position.y < 0)
        {
            ~OrxoBloxBall();
        //TODO: THE BALLS NEED TO BE COLLECTED, DESTROYED AND COUNTED... NEW SHOOTING POSITION NEEDS TO BE SET
        }

        // Set the position, velocity and acceleration of the ball, if they have changed.
        if (acceleration != this->getAcceleration())
            this->setAcceleration(acceleration);
        if (velocity != this->getVelocity())
            this->setVelocity(velocity);
        if (position != this->getPosition())
            this->setPosition(position);
    }

    /**
    @brief
        Set the speed of the ball (in x,y-direction).
    @param speed
        The speed to be set.
    */
    void OrxoBloxBall::setSpeed(float speed)
    {
        if (speed != this->speed_) // If the speed changes
        {
            this->speed_ = speed;

            // Set the speed in the direction of the balls current velocity.
            Vector3 velocity = this->getVelocity();
            if (velocity.y != 0)
                velocity.y = sgn(velocity.y) * this->speed_;
            else // If the balls current velocity is zero, the speed is set in a random direction.
                velocity.y = this->speed_ * sgn(rnd(-1,1));

            if (velocity.x != 0)
                velocity.x = sgn(velocity.x) * this->speed_;
            else // If the balls current velocity is zero, the speed is set in a random direction.
                velocity.x = this->speed_ * sgn(rnd(-1,1));

            this->setVelocity(velocity);
        }
    }

    /**
    @brief
        Set the blocks for the ball.
    @param bats
        An array (of size n (n=#Blocks) of weak pointers, to be set as the new blocks.
    */
    void OrxoBloxBall::setBlock(OrxoBloxStone[] blocks, int n)
    {
        if(n > this.nblocks_) {
            this.nblocks = n;
            delete this.blocks_;
            this.nblocks_ = new OrxoBloxStone[this.nblocks_];
        } 
           for (int i = 0; i < n; i++) {
                this->blocks_[i] = blocks[i];
           }
    }

    void OrxoBloxBall::setDefBoundarySound(const std::string &OrxoBloxSound)
    {
        if( defBoundarySound_ )
            defBoundarySound_->setSource(OrxoBloxSound);
        else
            assert(0); // This should never happen, because soundpointer is only available on master
    }

    const std::string& OrxoBloxBall::getDefBoundarySound()
    {
        if( defBoundarySound_ )
            return defBoundarySound_->getSource();
        else
            assert(0);
        return BLANKSTRING;
    }
}