source: orxonox.OLD/branches/ai/src/ai/ai_team.cc @ 10249

/*
   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 "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;
                        
                        //find new Position
                        if(isPlayer){
                                float x=(target->getAbsCoor()).x;
                                float z=(target->getAbsCoor()).z;
                                int zNorm=(position.z>z)?1:-1;
                                
                                if(x+100 > position.x && x+20 < position.x){
                                        newPosition=Vector(0,0,zNorm*80);               //just go away
                                        speed=80;
                                }else if(x+100 < position.x){
                                        newPosition=Vector(80,0,zNorm*30);      //attack
                                        speed=70;
                                }else{
                                        zNorm=1-2*(rand()%2); //-1 or 1
                                        newPosition=Vector(200,0,zNorm*80);     //go to attack position
                                        speed=100;
                                }
                        }else{
                        
                        }

                        changeSwarmModule(it, new SwarmGoRel);
                
                        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((rand()%6)+5); //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)
{
        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);
}


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);
        }
}