source: orxonox.OLD/branches/adm/src/world_entities/npcs/adm_turret.cc @ 10666

/*
* orxonox - the future of 3D-vertical-scrollers
*
* Copyright (C) 2004 orx
*
* 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, or (at your option)
* any later version.
*
*     ### File Specific:
*     main-programmer: Reto Luechinger
*/


#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WORLD_ENTITY
#include "adm_turret.h"
#include "weapons/weapon_manager.h"
#include "weapons/weapon.h"
#include "lib/util/loading/factory.h"
#include "world_entities/projectiles/projectile.h"
#include "loading/load_param.h"
#include "debug.h"

ObjectListDefinition(AdmTurret);
CREATE_FACTORY(AdmTurret);


/**
*  Standard constructor
*/
AdmTurret::AdmTurret ()
{
        this->init();
}

/**
* destructs the turret, deletes allocated memory
*/
AdmTurret::~AdmTurret ()
{
          // will be deleted
}

/**
* Constructor with XML Element
*/
AdmTurret::AdmTurret (const  TiXmlElement* root)
{
        this->init();
        if (root != NULL)
        {
                this->loadParams(root);
        }
}

void AdmTurret::init()
{
        this->registerObject(this, AdmTurret::_objectList);

        // load the 3 parts of the turret
        // this-> loadModel ("...", , )
        // this-> loadModel ("...", , )
        // this-> loadModel ("...", , )

        //Cannon Node: 2 Cannons fixed left and right of the main turret
        this->cannonNode.addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
        this->cannonNode.addNodeFlags(PNODE_PROHIBIT_CHILD_DELETE);
        this->cannonNode.setParent(this);
        // this->cannonNode.setRelCoor( , , )

        //Sensor Node: Sensor rotating independently from main turret (like Radar)
        this->sensorNode.addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
        this->sensorNode.addNodeFlags(PNODE_PROHIBIT_CHILD_DELETE);
        this->sensorNode.setParent(this);
        // this->sensorNode.setRelCoor( , , )

        // initialise Weapons here
}

void AdmTurret::loadParams(const TiXmlElement* root)
{
        if (root != NULL)
        {
                WorldEntity::loadParams(root);

                LoadParam(root, "target", this, AdmTurret, setTarget)
                        .describe("the filename of the World Entity, that is to be shot at")
                        .defaultValues("");
        }
}

void AdmTurret::tick(float dt)
{
}

void AdmTurret::draw() const
{
}

void AdmTurret::collidesWith(WorldEntity* entity, const Vector& location)
{
}

void AdmTurret::activate()
{
}

void AdmTurret::deactivate()
{
}

void AdmTurret::setTarget(const std::string& target)
{
        WorldEntity* targetEntity = WorldEntity::objectList().getObject(target);
        if (targetEntity != NULL) 
        {
                this->myTarget = targetEntity;
        }
        else
        {
                PRINTF(2)("ERROR ADMTURRET : Target %s does not exist\n", target.c_str());
        }
}

bool AdmTurret::isVisible(const WorldEntity myTarget)
{
return true;
}

float AdmTurret::aim(const WorldEntity Target)
{
return 0;
}

void AdmTurret::fire()
{
        // Projectile* pj =  this->getProjectile();
        // if (pj == NULL) return;

        //pj->setOwner(this->getOwner());
        //pj->setParent(PNode::getNullParent());
        //pj->setVelocity(this->getAbsDir().apply(Vector( , , )) );
        //pj->setAbsCoor(this->getEmissionPoint());
        //pj->setAbsDir(this->getAbsDir());
        //pj->activate();
}