source: orxonox.OLD/trunk/src/ai/ai_team.cc @ 10662

/*
   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: Thomas Fahrni
   co-programmer:
*/
#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_AI
#include "ai_team.h"
#include "swarm_gorel.h"
#include "swarm_module.h"
#include "swarm_wait.h"
#include "swarm_attack.h"
#include "debug.h"
#include "player.h"
#include "playable.h"
#include "state.h"

void AITeam::process(float dt)
{
        std::map<int,SwarmModule*>::iterator it;
        for (it= swarms.begin(); it!= swarms.end(); it++ ){

                if(it->second->taskDone()){
                        //std::cout << "Swarm Task Complete!\n";

                        if(enemyList->size()==0){
                                changeSwarmModule(it, new SwarmWait);
                                it->second->orderMaxTime(2);    //sleep 2 seconds..
                                it->second->process(dt);
                                continue;
                        }

                        Vector position=it->second->getPosition();
                        Vector newPosition;
                        WorldEntity* target=enemyList->at(0);

                        //check if enemy is the player..
                        bool isPlayer=(State::getPlayer()->getPlayable()==target);
                        float speed;
                        float maxTime=10;


                        //find new Position
                        if(isPlayer){
                                float attackDistance=it->second->getAttackDistance();

                                Vector targetPos=target->getAbsCoor();
                                float distanceToPlayer=(targetPos-position).len();

                                int zNorm=(position.z>targetPos.z)?1:-1;

                                if(distanceToPlayer<attackDistance+60){ //### change wakeup distance here
                                        std::cout << "AI Sleeps \n";
                                        changeSwarmModule(it, new SwarmWait);
                                        maxTime=1000;   //sleep 2 seconds..
                                }else{
                                /*if((position.z-targetPos.z)*zNorm>60){        //go to start position
                                        std::cout << "Go Start Position\n";
                                        changeSwarmModule(it, new SwarmGoRel);
                                        zNorm=1-(rand()%2)*2;   //1 or -1
                                        newPosition=Vector(attackDistance+60,0,zNorm*10);
                                        speed=60;
                                }else if(position.x > targetPos.x+attackDistance+40){   //go to attack position
                                        std::cout << "Go Attack Position\n";
                                        changeSwarmModule(it, new SwarmGoRel);
                                        newPosition=Vector(attackDistance+30,0,0)
                                        speed=60;
                                }else if(position.x > targetPos.x+attackDistance+20){   //go to attack mode;
                                        std::cout << "Go Attack Mode \n";*/
                                        std::cout << "AI Attacks \n";
                                        changeSwarmModule(it, new SwarmAttack);
                                        newPosition=Vector(attackDistance,0,0);
                                        speed=60;
                                        maxTime=(1000);//rand()%11)+4;//4-14 Sekunden
                                /*}else{                                                                                                //go to fallback point
                                        std::cout << "Go  Fallback Point\n";
                                        changeSwarmModule(it, new SwarmGoRel);
                                        newPosition=Vector(80,0,zNorm*90);
                                        speed=80;*/
                                }
                        //}else{

                        }

                        speed=0;

                        if(enemyList->size()>0){
                                it->second->setEnemyList(enemyList);
                                it->second->orderRelObject(target);
                                it->second->orderRelPos(newPosition);
                                it->second->orderSpeed(speed);
                                //it->second->orderView(Vector(0,0,1));
                                it->second->orderMaxTime(maxTime); //5-10
                                //it->second->newOrder();
                        }
                }
                it->second->process(dt);
        }
}

void AITeam::changeSwarmModule(std::map<int,SwarmModule*>::iterator it,SwarmModule* newAI)
{
                        SwarmModule* oldAI = it->second;
                        newAI->getAttributesFrom(oldAI);
                        it->second=newAI;
                        delete oldAI;
}


void AITeam::addAI(int swarmNumber, WorldEntity* npc, float maxSpeed, float attackDistance)
{
        std::pair<std::map<int,SwarmModule*>::iterator,bool> p;
        SwarmModule* newSwarm=new SwarmGoRel();
        p=swarms.insert(std::make_pair(swarmNumber,newSwarm));
        if(!p.second)delete newSwarm;
        p.first->second->addAI(npc, maxSpeed, attackDistance);
}


void AITeam::removeAI(int swarmNumber, WorldEntity* npc)
{
        std::map<int,SwarmModule*>::iterator it = swarms.find(swarmNumber);
        if(it==swarms.end())return;
        it->second->removeAI(npc);
        if(it->second->getSwarmSize()==0){
                delete it->second;
                swarms.erase(it);
        }
}