Ammo.cpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.fr
//
// 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 3 of the License, or
// (at your option) any later version.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// 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.
//
//-----------------------------------------------------------------------------------

#include <PVLE/Config.h>
#include <PVLE/Entity/Ammo.h>
#include <PVLE/Physics/Contact.h>
#include <PVLE/Physics/Body.h>
#include <PVLE/Physics/World.h>
#include <PVLE/Game/PVLEGame.h>
#include <PVLE/Game/Simulation.h>
#include <algorithm>


class Dummy3DPhy : public C3DPhy {
public:
    Dummy3DPhy(C3DPhy * pV) : C3DPhy(*pV, COPY_PHYSICS), pInit3DPhy(pV) { ASSERT(pV); }
    virtual void step(dReal) { onTTLZero(); }

    virtual bool hitBefore(Physics::Contact * pContacts, unsigned int nbContacts, Physics::Contact * pMaxEnergyContact, Physics::Geom & thisGeom, Physics::Geom & otherGeom, Physics::Body *& inout_pThisBody, Physics::Body *& inout_pOtherBody) {
        IGeomCollisionContainer * pContainer = otherGeom.getCollisionContainer();
        if (!pContainer) return true;
        return (pInit3DPhy != pContainer->as3DPhy());
    }

protected:
    const C3DPhy * pInit3DPhy;
};

// ------------------------------------------------------------------------------------


const float perforationToCinetik = 0.1f;        // Should be low (or the ammo will "perfore and push" the geom, so that perforation will last "forever")


Ammo::Ammo(osg::MatrixTransform * pModel, Physics::Geom * pGeom, C3DPhy::EInitOptions options, const C3DPhy * pInheritTeamAndPlayer) :
    C3DPhy(pModel, pGeom, options, pInheritTeamAndPlayer), canBeDeletedOnNextFrame(false), minSpeed2(-1), minCollisionCineticToDestroy(0), lastPerforationEnergy(0)
{
    std::fill(vParams, vParams+WeaponEnergy::MAX_WEAPON_ENERGY, 0.f);
}

Ammo::Ammo(const C3DPhy & v, UINT copyOpts) : C3DPhy(v, copyOpts), canBeDeletedOnNextFrame(false), minSpeed2(-1), minCollisionCineticToDestroy(0), lastPerforationEnergy(0)
{
    std::fill(vParams, vParams+WeaponEnergy::MAX_WEAPON_ENERGY, 0.f);
}

Ammo::Ammo(const Ammo & v, UINT copyOpts) : C3DPhy(v, copyOpts), canBeDeletedOnNextFrame(false), minSpeed2(v.minSpeed2), minCollisionCineticToDestroy(v.minCollisionCineticToDestroy), lastPerforationEnergy(0)
{
    memcpy(vParams, v.vParams, sizeof(float) * WeaponEnergy::MAX_WEAPON_ENERGY);        // Could use std::copy()...
}

//Ammo::Ammo() :
//  C3DPhy(), canBeDeletedOnNextFrame(false), minSpeed2(-1), minCollisionCineticToDestroy(0)
//{
//  std::fill(vParams, vParams+WeaponEnergy::MAX_WEAPON_ENERGY, 0.f);
//}


void Ammo::step(dReal stepSize) {
    ASSERT(vGeoms.size()>0 && vGeoms[0]->getBody());        // Ammo must have a body

    C3DPhy::step(stepSize);     // Updates TTL
    // Destroys ammo if not enough absolute speed (relative speed to each other geom would need to much computation !)
    if (ttl>=0 && minSpeed2>0 && dBodyGetLinearVelV(*(vGeoms[0]->getBody())).length2() < minSpeed2) onTTLZero();
}


bool Ammo::hitBefore(Physics::Contact * pContacts, unsigned int nbContacts, Physics::Contact * pMaxEnergyContact, Physics::Geom & thisGeom, Physics::Geom & otherGeom, Physics::Body *& inout_pThisBody, Physics::Body *& inout_pOtherBody) {
    // Technique for this method is to let ammo go thru the geom, and compute perforation on each step. This will do as if the length of the perforation is computed.
    // As ammo go thru, it's nonsense to create a contact joint between ammo and geom. For this reason, a dummy 3DPhy that represents the ammo si created on collision. A contact joint will be created with that dummy object, so that geom will take cinecic energy.

    lastPerforationEnergy = 0;      // Reset

    // Life points removal
    C3DPhy * pOther3DPhy = NULL;
    IGeomCollisionContainer * pContainer = otherGeom.getCollisionContainer();
    if (pContainer) pOther3DPhy = pContainer->as3DPhy();
    bool collision = true;      // Can be set to "false" if ammo goes thru and no dummy is created.

    if (pOther3DPhy) {          // Do not perform life points removal if hit object is not a 3D-Phy
        ASSERT(vGeoms.size()>0 && vGeoms[0]->getBody());        // Ammo must have a body
        Physics::Body * pBody = vGeoms[0]->getBody();

        // Assert ammunition is not perforant AND radiant (impossible, or let's say disabled because difficult to compute a perforation/reflexion/refraction/absorption)
        ASSERT(vParams[WeaponEnergy::PERFORANT] <=0 || vParams[WeaponEnergy::RADIANT] <=0);

        // Compute perforation
        if (vParams[WeaponEnergy::PERFORANT] >0) {
            // perforationEnergy must not be dependant of the step size : if step is short, perforation will occur more times for the same situation, so it's multiplied by the step size.
            float perforationEnergy = vParams[WeaponEnergy::PERFORANT] * otherGeom.getGameplayDensity() * SimulationHolder::instance().get()->getCurPhyStep();
            ASSERT(perforationEnergy>=0);

            // Remove perforation energy to cinetic energy (until 0 ! => adjust perforation energy if necessary), by adjusting velocity
            osg::Vec3 vel = dBodyGetLinearVelV(*pBody);
            osg::Vec3 velNormalized(vel);       velNormalized.normalize();

            float mass = pBody->getMassData().getMass();
            float currentCineticEnergy = vel.length2() * mass * .5f;
            float newCineticEnergy = currentCineticEnergy - perforationEnergy;
            if (newCineticEnergy <= 0) {
                canBeDeletedOnNextFrame = true;
                perforationEnergy = currentCineticEnergy;   // Adjust perforation energy
                newCineticEnergy = 0;
                dBodySetLinearVel(*pBody, 0,0,0);
            } else {
                // Set new velocity (normalize, and multiply according to cinetic)
                dBodySetLinearVel(*pBody, velNormalized * sqrtf(newCineticEnergy / mass * 2.f));
            }
LOG_ALWAYS << "Perforation : Ammo new speed = " << sqrtf(newCineticEnergy / mass * 2.f) << "(" << vel.length() << ")" << std::endl;

            // Split perforation energy into two : pure perforation damage, and cinetic energy that will be transferred to otherGeom

            // Transfer "pure perforation" energy to the other geom
LOG_ALWAYS << "  Perforant damage (without firendly fire factor) = " << perforationEnergy * (1-perforationToCinetik) << std::endl;
            // Don't call isHitByPerforant() here, but in hitAfter.
            //pOther3DPhy->isHitByPerforant(perforationEnergy * (1-perforationToCinetik) * friendlyFireCoef, pMaxEnergyContact->getPos());
            lastPerforationEnergy = perforationEnergy * (1-perforationToCinetik);       // Will be used by hitAfter(), which is guaranteed to be called after this method.

            // Transfer cinetic energy of perforation (only if other has a body !).
            // Do not create a contact joint directly, but another 3D-Phy that will do the job "as if".
            if (inout_pOtherBody) {
                // Create a 3D-Phy that will destroy itself after 1 step
                // Dummy3DPhy ensures that no collision will happen between original & dummy
                Dummy3DPhy * pDummyAmmo = new Dummy3DPhy(this);
                p3DPhyOwner->addInScene(pDummyAmmo);                // BROKEN FEATURE : connot add a geom during a world step
                // Set correct body for collision
                inout_pThisBody = pDummyAmmo->getGeom(0)->getBody();
                // Set speed of the dummy
                // Dev Note : if ammo has more than one body, this will be a problem...
                dBodySetLinearVel(*inout_pThisBody, velNormalized * sqrtf((perforationEnergy * perforationToCinetik) / mass * 2.f));
LOG_ALWAYS << "  Dummy ammo speed = " << sqrtf((perforationEnergy * perforationToCinetik) / mass * 2.f) << std::endl;
            } else collision = false;       // Disable collision if no dummy exists (no collision between original ammo and other geom)
        }
    }

    // Delete ammunition on next frame, only if a contact joint is created (set only a flag)
    // Ammo is also checked against collision angle : it should not be destroyed if "just touching". Collision energy depends on the angle : if pMaxEnergyContact->arithmeticCineticEnergy is low, then ammo should bounce intead of being destroyed.
    if (pMaxEnergyContact->arithmeticCineticEnergy > minCollisionCineticToDestroy) canBeDeletedOnNextFrame = true;

    // Create a contact, even if destroyed (transfer cinetic energy)
    return collision;
}


void Ammo::hitAfter(Physics::Contact * pContacts, unsigned int nbContacts, Physics::Contact * pMaxEnergyContact, Physics::Geom & thisGeom, Physics::Geom & otherGeom, bool contactJointCreated) {
    if (contactJointCreated) {
        // -- Energy transfer for 3DPhys --
        // For perforation energy, we need the data from the perforation computed in hitBefore().
        // For all other energies, we simply transfer (for maximized cinetic energy contact).
        IGeomCollisionContainer * pContainer = otherGeom.getCollisionContainer();
        if (pContainer) {
            C3DPhy * pOther3DPhy = pContainer->as3DPhy();
            if (pOther3DPhy) {
                // Test for friendly fire
                float friendlyFireCoef;
                if (pTeam && pTeam == pOther3DPhy->getTeam()) {
                    // Transfer energies with a coefficient, which is a Game parameter.
                    // Note that collision cinetic energy is not multiplied by a coef (Or it would be done on every collision); but "fake" (written in vParams[]) cinetic energy is.
                    friendlyFireCoef = PVLEGameHolder::instance().get()->getFriendlyFire();
                } else friendlyFireCoef = 1;

                for(int it=0; it!=WeaponEnergy::MAX_WEAPON_ENERGY; ++it) {
                    pOther3DPhy->isHitBy(static_cast<WeaponEnergy::EEneryType>(it),
                        (it == WeaponEnergy::PERFORANT ? lastPerforationEnergy : vParams[it]) * friendlyFireCoef,
                        pMaxEnergyContact->getPos());
                }
            }
        }
    }

    if (canBeDeletedOnNextFrame) {
        if (contactJointCreated) onTTLZero();       // Never modify geom or model after this call (See C3DPhyOwner documentation)
        else canBeDeletedOnNextFrame = false;
    }
}


#ifdef PVLE_NETWORKING
//TNL::U32 Ammo::packUpdate(TNL::GhostConnection * pConnection, TNL::U32 mask, TNL::BitStream * pStream) {
//  if (pStream->writeFlag((mask & INITIAL_MASK)!=0)) {
//      BOOST_FOREACH(float f, vParams) pStream->write(f);
//      pStream->write(minSpeed2);
//      pStream->write(minCollisionCineticToDestroy);
//  }
//
//  C3DPhy::packUpdate(pConnection, mask, pStream);
//  return 0;
//}
//
//void Ammo::unpackUpdate(TNL::GhostConnection * pConnection, TNL::BitStream * pStream) {
//  // INITIAL_MASK
//  if (pStream->readFlag()) {
//      BOOST_FOREACH(float & f, vParams) pStream->read(&f);
//      pStream->read(&minSpeed2);
//      pStream->read(&minCollisionCineticToDestroy);
//
//      //Game * pGame = PVLEGameHolder::instance().get<Game>();
//      PVLEGame * pGame = PVLEGameHolder::instance().get();
//      //pPhyWorld = pGame->getPhyWorld();
//      //createGeom(pPhyWorld, osg::Vec3(0,0,0));
//      //bind();
//      pGame->addInScene(this);
//  }
//
//  C3DPhy::unpackUpdate(pConnection, pStream);
//}
#endif


// --------------------------------------------------------------------------------------------------------
//
//#include "PVLE/Physics/Geom.h"
//#include "PVLE/Physics/Body.h"
//#include "PVLE/Physics/CommonSurfaceParams.h"
//#include "PVLE/Physics/Utility.h"
//
//#include <PVLE/3D/Commons.h>
//
//
//C3DPhy * createBullet(Physics::World * pPhyWorld, const osg::Matrix & matrixWTL, const osg::Vec3 & velocity, double ttl, const C3DPhy * pInheritTeamAndPlayer) {
//  const double radius = 1;
//  //const float mass = 0.009f;        // 7.62 ammo mass
//  const float mass = 0.5f;
//  Physics::Geom * pGeom = Physics::createCanonicalSphere(pPhyWorld, radius, mass, Physics::Materials::METAL);
//  Physics::Body * pBody = pGeom->getBody();
//  pBody->setMatrix(matrixWTL);                    // Set position and rotation
//  pBody->setLinearVel(velocity);
//
//  // 3D representation of the object
//  osg::MatrixTransform * pPhyDrivenMat = createShapeGeodeSphere(radius);
//  setColor(pPhyDrivenMat, osg::Vec4f(1,1,0,1));
//
//  float velLen2 = velocity.length2();
//  Ammo * pRes = new Ammo(pPhyDrivenMat, pGeom, C3DPhy::INIT_AUTO_BIND, pInheritTeamAndPlayer);
//  pRes->setTTL(ttl);
//  pRes->setMinSpeed2(velLen2/10);                             // Destroy ammo if velocity is 1/10th of the initial velocity
//  //pRes->setMinCollisionCineticToDestroy(velLen2*mass*.5f);  // Destroy ammo if it hits a geom with this ammount of energy (= equivalent to cinetic energy against a body of 1 kg)
//  //pRes->setMinCollisionCineticToDestroy(1e20);              // Never destroy ammo on collision
//  pRes->setMinCollisionCineticToDestroy(1e3);
//  pRes->setParam(WeaponEnergy::THERMAL, 2000);
//  //pRes->setParam(WeaponEnergy::PERFORANT, 30);
//  return pRes;
//}

---