source: code/branches/OrxoBlox_FS19/src/modules/weapons/projectiles/BallProjectile.cc @ 12400

#include "BallProjectile.h"
#include "gametypes/Gametype.h"


#include <OgreParticleEmitter.h>
#include "core/CoreIncludes.h"
#include "tools/ParticleInterface.h"
#include "Scene.h"
#include "core/command/Executor.h"
#include "util/Convert.h"
#include <bullet/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h>
#include <bullet/LinearMath/btVector3.h>

namespace orxonox
{
    RegisterClass(BallProjectile);

    BallProjectile::BallProjectile(Context* context) : BillboardProjectile(context)
    {
        RegisterObject(BallProjectile);
        this->textureIndex_ = 1;
        this->setMass(0.1f);
        this->maxTextureIndex_ = 8;
        this->setDestroyAfterCollision(false); //I want the ball to bounce, not to be destroyed
        this->fieldWidth_ = 46;
        this->fieldHeight_ =  49;
        this->orxoblox_ = this->getOrxoBlox();
        this->setCollisionShapeRadius(2.5);
        this->setDamage(1000);
        orxoblox_->count();
        //setEffect("Orxonox/sparks2");
    }

    void BallProjectile::registerVariables()
    {
        registerVariable(this->materialBase_);
        registerVariable( this->speed_ );
    }

    /**
    @brief
        Set the material.
    @param material
        The name of the material. Material names with 1 to 8 appended must exist.
    */
    void BallProjectile::setMaterial(const std::string& material)
    {
        this->materialBase_ = material;

        BillboardProjectile::setMaterial(material + multi_cast<std::string>(this->textureIndex_));
    }

    /**
    @brief
        Change the texture.
    */
    void BallProjectile::changeTexture()
    {
        this->textureIndex_++;
        if (this->textureIndex_ > this->maxTextureIndex_)
            this->textureIndex_ = 1;

        this->setMaterial(this->materialBase_);
    }



    void BallProjectile::Bounce(WorldEntity* otherObject, btManifoldPoint& contactPoint, const btCollisionShape* cs) {

        Vector3 velocity = this->getVelocity();
        Vector3 myPosition = otherObject->getPosition();
        btVector3 positionOtherObject = contactPoint.getPositionWorldOnA();
        
            int distance_X = positionOtherObject.getX() - myPosition.x;
            int distance_Z = positionOtherObject.getZ() - myPosition.z;

            if (distance_X < 0)
                distance_X = -distance_X;
    

            if (distance_Z < 0)
                distance_Z = -distance_Z;

            if (distance_X < distance_Z) {
                velocity.z = -velocity.z;
            }
            if (distance_Z < distance_X) {
                velocity.x = -velocity.x;
            }
            else {
                velocity.x = -velocity.x;
                velocity.z = -velocity.z;
            }
            this->setVelocity(velocity);
    }

    
    bool BallProjectile::processCollision(WorldEntity* otherObject, btManifoldPoint& contactPoint, const btCollisionShape* cs)
    {
        bool result = BasicProjectile::processCollision(otherObject, contactPoint, cs);
        if (result == true) {
            if (otherObject->isA(Class(OrxoBloxStones))) {
                Bounce(otherObject, contactPoint, cs);
                
            }
        }
        return result;
    }


    
    OrxoBlox* BallProjectile::getOrxoBlox()
    {
        if (this->getGametype() != nullptr && this->getGametype()->isA(Class(OrxoBlox)))
        {
            OrxoBlox* orxobloxGametype = orxonox_cast<OrxoBlox*>(this->getGametype());
            return orxobloxGametype;
        }
        else orxout()<<"There is no Gametype for OrxoBlox! ask Anna"<< endl;
        return nullptr;
    }
    


    void BallProjectile::tick(float dt)
    {
        SUPER(BallProjectile, tick, dt);

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

        velocity.y = 0;
        position.y = 0;

        // If the ball has gone over the top or bottom boundary of the playing field (i.e. the ball has hit the top or bottom delimiters).
        if (position.z > this->fieldHeight_ || position.z < -this->fieldHeight_)
        {

            velocity.z = -velocity.z;
            // And its position is set as to not overstep the boundary it has just crossed. Remember z axis is reverted!!!
            if (position.z > this->fieldHeight_){
                // Set the ball to be exactly at the boundary.
                position.z = this-> fieldHeight_;
                
                suicidal = true;
                
            }
            if (position.z < -this->fieldHeight_){
                position.z = -this->fieldHeight_;
                
            }

            this->fireEvent();
        }
        
        //Ball hits the right or left wall and should bounce back.
        // If the ball has crossed the left or right boundary of the playing field.
        if (position.x > this->fieldWidth_ || position.x < -this->fieldWidth_)
        {
            //Ball hits the right Wall
            if (position.x > this->fieldWidth_)
                {
                    // Set the ball to be exactly at the boundary.
                    position.x = this->fieldWidth_;
                    // Invert its velocity in x-direction (i.e. it bounces off).
                    velocity.x = -velocity.x;
                    this->fireEvent();
                    }

            //Ball hits the left wall
            else if (position.x < -this->fieldWidth_)
                {
                        // Set the ball to be exactly at the boundary.
                        position.x = -this->fieldWidth_;
                        // Invert its velocity in x-direction (i.e. it bounces off).
                        velocity.x = -velocity.x;
                        this->fireEvent();
                    }
        }

        // 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);
        //this->Collides((this->orxoblox_->CheckForCollision(this)));
        if (suicidal == true) {
            this->destroy();
        }

    }



    void BallProjectile::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.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);
        }
    }


    //This is an override to prevent getting killed by the program
    void BallProjectile::destroyObject(void)
    {
        if(GameMode::isMaster()) {
        }
    }



}