//--------------------------- Render -------------------------------------
//
//------------------------------------------------------------------------
void Raven_Bot::Render()                                         
{
  //when a bot is hit by a projectile this value is set to a constant user
  //defined value which dictates how long the bot should have a thick red
  //circle drawn around it (to indicate it's been hit) The circle is drawn
  //as long as this value is positive. (see Render)
  m_iNumUpdatesHitPersistant--;


  if (isDead() || isSpawning()) return;
  
  gdi->BluePen();
  
  m_vecBotVBTrans = WorldTransform(m_vecBotVB,
                                   Pos(),
                                   Facing(),
                                   Facing().Perp(),
                                   Scale());

  gdi->ClosedShape(m_vecBotVBTrans);
  
  //draw the head
  (gdi->*(m_pTeam->GetPen()))();
  gdi->Circle(Pos(), 6.0 * Scale().x);


  //render the bot's weapon
  m_pWeaponSys->RenderCurrentWeapon();

  //render a thick red circle if the bot gets hit by a weapon
  if (m_bHit)
  {
    gdi->ThickRedPen();
    gdi->HollowBrush();
    gdi->Circle(m_vPosition, BRadius()+1);

    if (m_iNumUpdatesHitPersistant <= 0)
    {
      m_bHit = false;
    }
  }

  gdi->TransparentText();
  gdi->TextColor(0,255,0);

  if (UserOptions->m_bShowBotIDs)
  {
    gdi->TextAtPos(Pos().x -10, Pos().y-20, ttos(ID()));
  }

  if (UserOptions->m_bShowBotHealth)
  {
    gdi->TextAtPos(Pos().x-40, Pos().y-5, "H:"+ ttos(Health()));
  }

  if (UserOptions->m_bShowScore)
  {
    gdi->TextAtPos(Pos().x-40, Pos().y+10, "Scr:"+ ttos(Score()));
  }    
}
Beispiel #2
0
//------------------------------ Render ----------------------------------
//------------------------------------------------------------------------
bool SoccerPitch::Render()
{
  //draw the grass
  gdi->DarkGreenPen();
  gdi->DarkGreenBrush();
  gdi->Rect(0,0,m_cxClient, m_cyClient);

  //render regions
  if (Prm.bRegions)
  {   
    for (unsigned int r=0; r<m_Regions.size(); ++r)
    {
      m_Regions[r]->Render(true);
    }
  }
  
  //render the goals
  gdi->HollowBrush();
  gdi->RedPen();
  gdi->Rect(m_pPlayingArea->Left(), (m_cyClient-Prm.GoalWidth)/2, m_pPlayingArea->Left()+40, m_cyClient - (m_cyClient-Prm.GoalWidth)/2);

  gdi->BluePen();
  gdi->Rect(m_pPlayingArea->Right(), (m_cyClient-Prm.GoalWidth)/2, m_pPlayingArea->Right()-40, m_cyClient - (m_cyClient-Prm.GoalWidth)/2);
  
  //render the pitch markings
  gdi->WhitePen();
  gdi->Circle(m_pPlayingArea->Center(), m_pPlayingArea->Width() * 0.125);
  gdi->Line(m_pPlayingArea->Center().x, m_pPlayingArea->Top(), m_pPlayingArea->Center().x, m_pPlayingArea->Bottom());
  gdi->WhiteBrush();
  gdi->Circle(m_pPlayingArea->Center(), 2.0);


  //the ball
  gdi->WhitePen();
  gdi->WhiteBrush();
  m_pBall->Render();
  
  //Render the teams
  m_pRedTeam->Render();
  m_pBlueTeam->Render(); 

  //render the walls
  gdi->WhitePen();
  for (unsigned int w=0; w<m_vecWalls.size(); ++w)
  {
    m_vecWalls[w].Render();
  }

  //show the score
  gdi->TextColor(Cgdi::red);
  gdi->TextAtPos((m_cxClient/2)-300, m_cyClient-18, m_pRedTeam->Name() + "(Red): " 
	  + ttos(m_pBlueGoal->NumGoalsScored()));

  gdi->TextColor(Cgdi::blue);
  gdi->TextAtPos((m_cxClient/2)+10, m_cyClient-18, m_pBlueTeam->Name() + "(Blue): " 
	  + ttos(m_pRedGoal->NumGoalsScored()));

  return true;  
}
//-------------------------- RenderInfo ---------------------------------------
//-----------------------------------------------------------------------------
void AttackTargetGoal_Evaluator::RenderInfo(Vector2D Position, Raven_Bot* pBot)
{
  gdi->TextAtPos(Position, "AT: " + ttos(CalculateDesirability(pBot), 2));
  return;
    
  std::string s = ttos(Raven_Feature::Health(pBot)) + ", " + ttos(Raven_Feature::TotalWeaponStrength(pBot));
  gdi->TextAtPos(Position+Vector2D(0,12), s);
}
//-------------------------- RenderInfo ---------------------------------------
//-----------------------------------------------------------------------------
void GetHealthGoal_Evaluator::RenderInfo(Vector2D Position, Raven_Bot* pBot)
{
  gdi->TextAtPos(Position, "H: " + ttos(CalculateDesirability(pBot), 2));
  return;
  
  std::string s = ttos(1-Raven_Feature::Health(pBot)) + ", " + ttos(Raven_Feature::DistanceToItem(pBot, type_health));
  gdi->TextAtPos(Position+Vector2D(0,15), s);
}
void Raven_WeaponSystem::RenderDesirabilities()const
{
	Vector2D p = m_pOwner->Pos();

	int num = 0;

	WeaponMap::const_iterator curWeap;
	for (curWeap = m_WeaponMap.begin(); curWeap != m_WeaponMap.end(); ++curWeap)
	{
		if (curWeap->second) num++;
	}

	int offset = 15 * num;

	for (curWeap = m_WeaponMap.begin(); curWeap != m_WeaponMap.end(); ++curWeap)
	{
		if (curWeap->second)
		{
			double score = curWeap->second->GetLastDesirabilityScore();
			std::string type = GetNameOfType(curWeap->second->GetType());

			gdi->TextAtPos(p.x + 10.0, p.y - offset, ttos(score) + " " + type);

			offset += 15;
		}
	}
}
//--------------------------- Render -------------------------------------
//
//------------------------------------------------------------------------
void GoalKeeper::Render()                                         
{
  if (Team()->Color() == SoccerTeam::blue) 
    gdi->BluePen();
  else 
    gdi->RedPen();
  
  m_vecPlayerVBTrans = WorldTransform(m_vecPlayerVB,
                                       Pos(),
                                       m_vLookAt,
                                       m_vLookAt.Perp(),
                                       Scale());

  gdi->ClosedShape(m_vecPlayerVBTrans);
  
  //draw the head
  gdi->BrownBrush();
  gdi->Circle(Pos(), 6);

  //draw the ID
  if (Prm.bIDs)
  {
    gdi->TextColor(0, 170, 0);;
    gdi->TextAtPos(Pos().x-20, Pos().y-20, ttos(ID()));
  }

  //draw the state
  if (Prm.bStates)
  { 
    gdi->TextColor(0, 170, 0); 
    gdi->TransparentText(); 
    gdi->TextAtPos(m_vPosition.x, m_vPosition.y -20, std::string(m_pStateMachine->GetNameOfCurrentState()));
  }
}
Beispiel #7
0
//-------------------------- AddBots --------------------------------------
//
//  Adds a bot and switches on the default steering behavior
//-----------------------------------------------------------------------------
void Raven_Game::AddBots(unsigned int NumBotsToAdd)
{ 
  while (NumBotsToAdd--)
  {
    //create a bot. (its position is irrelevant at this point because it will
    //not be rendered until it is spawned)
    Raven_Bot* rb = new Raven_Bot(this, Vector2D());

	m_lastTeamSpawned = (m_lastTeamSpawned == 1) ? 2 : 1; 
	rb->SetTeamId(m_lastTeamSpawned);

    //switch the default steering behaviors on
    rb->GetSteering()->WallAvoidanceOn();
    rb->GetSteering()->SeparationOn();

    m_Bots.push_back(rb);

    //register the bot with the entity manager
    EntityMgr->RegisterEntity(rb);

    
#ifdef LOG_CREATIONAL_STUFF
  debug_con << "Adding bot with ID " << ttos(rb->ID()) << "";
#endif
  }
}
Beispiel #8
0
void SoccerPitch::Render()
{
  ngdi->TransparentText();
  ngdi->HollowBrush();
  //畫草地
  ngdi->DarkGreenPen();
  ngdi->DarkGreenBrush();
  ngdi->Rect(V2D(0,0),V2D(m_cxClient, m_cyClient));
  //畫球門
  ngdi->HollowBrush();
  ngdi->RedPen();
  ngdi->Rect(V2D(m_pPlayingArea->Left(), (m_cyClient-m_pBlueGoal->GoalWidth())/2), V2D(m_pPlayingArea->Left()+40, m_cyClient - (m_cyClient-m_pBlueGoal->GoalWidth())/2));
  ngdi->BluePen();
  ngdi->Rect(V2D(m_pPlayingArea->Right(), (m_cyClient-m_pRedGoal->GoalWidth())/2), V2D(m_pPlayingArea->Right()-40, m_cyClient - (m_cyClient-m_pRedGoal->GoalWidth())/2)); 
  //render the pitch markings
  //畫球場中間圓線
  ngdi->WhitePen();
  ngdi->Circle(m_pPlayingArea->Center(), m_pPlayingArea->Width() * 0.125);
  //畫球場中線
  ngdi->Line(V2D(m_pPlayingArea->Center().x, m_pPlayingArea->Top()), V2D(m_pPlayingArea->Center().x, m_pPlayingArea->Bottom()));
  ngdi->WhiteBrush();
  //畫球場中間小圓
  ngdi->Circle(m_pPlayingArea->Center(), 2.0);
  //the ball
  //gdi->WhitePen();
  //gdi->WhiteBrush();
  //m_pBall->Render();
  //Render the teams
  //m_pRedTeam->Render();
  //m_pBlueTeam->Render(); 

  //render the walls
  ngdi->WhitePen();
  for (unsigned int w=0; w<m_vecWalls.size(); ++w)
  {
    m_vecWalls[w].Render();
  }

  //show the score
  ngdi->TextColor(NEOgdi::red);
  //gdi->TextAtPos((m_cxClient/2)-50, m_cyClient-18, "Red: " + ttos(m_pBlueGoal->NumGoalsScored()));
  ngdi->TextAtPos((m_cxClient/2)-50, m_cyClient-18, L"Red: " + ttos(99));

  ngdi->TextColor(NEOgdi::blue);
  //ngdi->TextAtPos((m_cxClient/2)+10, m_cyClient-18, "Blue: " + ttos(m_pRedGoal->NumGoalsScored())); 
  ngdi->TextAtPos((m_cxClient/2)+10, m_cyClient-18, L"Blue: " + ttos(99));
}
//--------------------- CheckBufferLength --------------------------------
//
//  this is a replacement for the StringCchLength function found in the 
//  platform SDK. See MSDN for details. Only ever used for checking toolbar
//  strings
//------------------------------------------------------------------------
bool CheckBufferLength(char* buff, int MaxLength, int& BufferLength)
{
  std::string s = ttos(buff);

  BufferLength = s.length();

  if (BufferLength > MaxLength)
  {
    BufferLength = 0; return false;
  }  

  return true;
}
//-------------------------- RenderInfo ---------------------------------------
//-----------------------------------------------------------------------------
void GetWeaponGoal_Evaluator::RenderInfo(Vector2D Position, Raven_Bot* pBot)
{
  std::string s;
  switch(m_iWeaponType)
  {
  case type_rail_gun:
    s="RG: ";break;
  case type_rocket_launcher:
    s="RL: "; break;
  case type_shotgun:
    s="SG: "; break;
  }
  
  gdi->TextAtPos(Position, s + ttos(CalculateDesirability(pBot), 2));
}
Beispiel #11
0
//-------------------------- AddBots --------------------------------------
//
//  Adds a bot and switches on the default steering behavior
//-----------------------------------------------------------------------------
void Raven_Game::AddBot(std::string botClassName)
{ 
    //create a bot. (its position is irrelevant at this point because it will
    //not be rendered until it is spawned)
    //Raven_Bot* rb = new Raven_Bot(this, Vector2D());
	 AbstRaven_Bot* rb;
	rb = (AbstRaven_Bot*) BotMaker::newBot(botClassName, this, Vector2D());


    //switch the default steering behaviors on
    rb->GetSteering()->WallAvoidanceOn();
    rb->GetSteering()->SeparationOn();

    m_Bots.push_back(rb);

    //register the bot with the entity manager
    EntityMgr->RegisterEntity(rb);

    
#ifdef LOG_CREATIONAL_STUFF
  debug_con << "Adding bot of class " << botClassName << " with ID " << ttos(rb->ID()) << "";
#endif

}
//-------------------------- RenderInfo ---------------------------------------
//-----------------------------------------------------------------------------
void ExploreGoal_Evaluator::RenderInfo(Vector2D Position, AbstRaven_Bot* pBot)
{
  gdi->TextAtPos(Position, "EX: " + ttos(CalculateDesirability(pBot), 2));
}
void GameLearn::learn()
{
    learnInvisible();
    /* */
    enemies.push_back(model);
    ShipEnemy* body = &enemies.back();

    std::vector<ShipEvolutive> evo;
    for(int i=0;i<NB_INDIVIDUALS;i++){
        std::string str = "P"+ttos(i);
        evo.push_back(ShipEvolutive(body,str));
    }
    for(unsigned int i=0;i<evo.size();i++){
        evo[i].setBulletPlayer(&bulletPlayer);
    }
    int current = 0;
    float bestTime = 0.f;

    /* */
    bool end=false;
    window.setFramerateLimit(FR_LIMIT);
    initPlayer();

    sf::Clock telapsed;
    txt_time.setPosition(window.getSize().x-200,10);
    dt = 1.f/FR_LIMIT;
    static const float offsetsecurity = body->getVelocity()*dt*1.2f+10.f;

    while (window.isOpen() && !end)
    {
        while (window.pollEvent(event)){
            if (event.type == sf::Event::Closed)
                window.close();

                if (event.type == sf::Event::KeyPressed){
                    if (event.key.code == sf::Keyboard::Escape)
                        end = true;

                    if (event.key.code == sf::Keyboard::Right)
                        player.setVx(player.getVelocity());
                    if (event.key.code == sf::Keyboard::Left)
                        player.setVx(-player.getVelocity());
                    if (event.key.code == sf::Keyboard::Down)
                        player.setVy(player.getVelocity());
                    if (event.key.code == sf::Keyboard::Up)
                        player.setVy(-player.getVelocity());

                }
                if (event.type == sf::Event::KeyReleased){
                    if (event.key.code == sf::Keyboard::Right && player.getV().x>0.f)
                        player.setVx(0.f);
                    if (event.key.code == sf::Keyboard::Left && player.getV().x<0.f)
                        player.setVx(0.f);
                    if (event.key.code == sf::Keyboard::Down && player.getV().y>0.f)
                        player.setVy(0.f);
                    if (event.key.code == sf::Keyboard::Up && player.getV().y<0.f)
                        player.setVy(0.f);
                }


        }

        // update data

        layer_game.clear();

        if(body->getLives()<=LIFE_SECURITY-LIFE_INDIVIDUALS){
            current++;
            if(current >= (int)evo.size()){
                current = 0;
                bestTime = ShipEvolutive::reproduction(evo);
            }
            body->addLife(LIFE_SECURITY-body->getLives());
            body->setPosition(layer_game.getSize().x/2.f,100.f);
            body->setV(0.f,0.f);

            //ennemies.push_back(model3);
            //body = &ennemies.back();

            evo[current].reset();
        }
        if(body->getSprite().getPosition().x < offsetsecurity)
            body->setPosition(offsetsecurity,body->getSprite().getPosition().y);
        if(body->getSprite().getPosition().y < offsetsecurity)
            body->setPosition(body->getSprite().getPosition().x,offsetsecurity);
        if(body->getSprite().getPosition().x > layer_game.getSize().x-offsetsecurity)
            body->setPosition(layer_game.getSize().x-offsetsecurity,body->getSprite().getPosition().y);
        if(body->getSprite().getPosition().y > layer_game.getSize().y-offsetsecurity)
            body->setPosition(body->getSprite().getPosition().x,layer_game.getSize().y-offsetsecurity);
        evo[current].update(dt);

        // move the player
        if(sf::Keyboard::isKeyPressed(sf::Keyboard::Space))
            player.update(2.5f*dt);
        else
            player.update(dt);
        layer_game.draw(player);

        for (std::list<ShipEnemy>::iterator it=enemies.begin(); it != enemies.end(); ++it){
            it->update(dt);
            layer_game.draw(*it);
            // out of screen
            if(it->getSprite().getGlobalBounds().top > layer_game.getSize().y){
                //it = ennemies.erase(it);
            }
        }
        // detect bullet collisions
        manageBulletCollision();
        std::string info("");
        for(unsigned int i=0;i<evo.size();i++)
            info += evo[i].getName()+">"+ttos(evo[i].getTime())+"\n";
        txt_time.setString("Temps écoulé: "+ttos(telapsed.getElapsedTime().asSeconds())
                       +"\nVies: "+ttos(player.getLives())
                        +"\nfps: "+ttos(getFrameRate())
                           +"\n ENT: "+evo[current].getName()
                           +"\n GEN: "+ttos(evo[current].getGeneration())
                           +"\n BestTile: "+ttos(bestTime)
                            +"\n"+info
                           );
        for(int i=(int)bulletPlayer.size()-1;i>=0;i--){
            bulletPlayer[i].update(dt);
            layer_game.draw(bulletPlayer[i]);
        }

        if(bullet.size() > 0)
            for(int i=(int)(bullet.size())-1;i>=0;i--){
                bullet[i].update(dt);
                layer_game.draw(bullet[i]);
            }
        layer_game.display();
        window.clear();
        window.draw(sf::Sprite(layer_game.getTexture()));

        window.draw(txt_time);
        window.display();
    }

    for(unsigned int i=0;i<evo.size();++i){
        evo[i].writeGenome();
    }

}
void GameLearn::learnInvisible()
{
    const unsigned int TIME_WAITING = 60.f; // in sec

    window.setFramerateLimit(0);

    enemies.push_back(model);
    Ship* body = &enemies.back();

    std::vector<ShipEvolutive> evo;
    for(int i=0;i<NB_INDIVIDUALS;i++){
        std::string str = "P"+ttos(i);
        evo.push_back(ShipEvolutive(body,str));
    }
    for(unsigned int i=0;i<evo.size();i++){
        evo[i].setBulletPlayer(&bulletPlayer);
    }
    int current = 0;
    float bestTime = 0.f;
    float bestTimeCumul = 0.f;

    dt = 1.f/FR_LIMIT;

    sf::Text info;
    info.setFont(*FontManager::getFont("ressources/Symtext.ttf"));
    info.setCharacterSize(12);
    info.setPosition(window.getSize().x/2,10);

    static const float offsetsecurity = body->getVelocity()*dt*1.2f+10.f;
    float tcounter = -2.f;
    int gencounter = 1; // generation counter
    int ncounter = 0;
    bool end = false;

    initPlayer();

    sf::Clock telapsed;
    while (window.isOpen() && !end && telapsed.getElapsedTime().asSeconds() < TIME_WAITING){
        while (window.pollEvent(event)){
            if (event.type == sf::Event::Closed)
                window.close();

            if (event.type == sf::Event::KeyPressed){
                if (event.key.code == sf::Keyboard::Escape)
                    end = true;
            }
        }

        // update data

        if(body->getLives() <= LIFE_SECURITY-LIFE_INDIVIDUALS){
            // next individual
            current++;
            if(current >= (int)evo.size()){
                current = 0;
                bestTime = ShipEvolutive::reproduction(evo);
                bestTimeCumul += bestTime;
                gencounter++;
            }

            body->addLife(LIFE_SECURITY-body->getLives());
            body->setPosition(layer_game.getSize().x/2.f,100.f);
            body->setV(0.f,0.f);

            //ennemies.push_back(model3);
            //body = &ennemies.back();

            evo[current].reset();
        }
        if(body->getSprite().getPosition().x < offsetsecurity)
            body->setPosition(offsetsecurity,body->getSprite().getPosition().y);
        if(body->getSprite().getPosition().y < offsetsecurity)
            body->setPosition(body->getSprite().getPosition().x,offsetsecurity);
        if(body->getSprite().getPosition().x > layer_game.getSize().x-offsetsecurity)
            body->setPosition(layer_game.getSize().x-offsetsecurity,body->getSprite().getPosition().y);
        if(body->getSprite().getPosition().y > layer_game.getSize().y-offsetsecurity)
            body->setPosition(body->getSprite().getPosition().x,layer_game.getSize().y-offsetsecurity);
        evo[current].update(dt);

        // move the player
        player.update(dt);

        for (std::list<ShipEnemy>::iterator it=enemies.begin(); it != enemies.end(); ++it){
            it->update(dt);
            // out of screen
            if(it->getSprite().getGlobalBounds().top > layer_game.getSize().y){
                //it = ennemies.erase(it);
            }
        }
        // detect bullet collisions
        manageBulletCollision();

        for(int i=(int)bulletPlayer.size()-1;i>=0;i--){
            bulletPlayer[i].update(dt);
        }

        if(bullet.size() > 0)
            for(int i=(int)(bullet.size())-1;i>=0;i--){
                bullet[i].update(dt);
            }


        if(elapsed.getElapsedTime().asSeconds()-tcounter > 1.f){
            window.clear();

            // snapshot
            layer_game.clear();
            layer_game.draw(player);
            for (std::list<ShipEnemy>::iterator it=enemies.begin(); it != enemies.end(); ++it){
                layer_game.draw(*it);
            }

            for(int i=(int)bulletPlayer.size()-1;i>=0;i--){
                layer_game.draw(bulletPlayer[i]);
            }

            if(bullet.size() > 0)
                for(int i=(int)(bullet.size())-1;i>=0;i--){
                    layer_game.draw(bullet[i]);
                }

            layer_game.display();
            window.draw(sf::Sprite(layer_game.getTexture()));
            // ---

            std::string info2("");
            for(unsigned int i=0;i<evo.size();i++)
                info2 += evo[i].getName()+">"+ttos(evo[i].getTime())+"\n";
            info.setString("Temps : "+ttos(telapsed.getElapsedTime().asSeconds())+"\n"+
                            "Step : "+ttos(ncounter)+"\n"+
                           "Generation Max : "+ttos(gencounter)+
                           "\nBestTime : "+ttos(bestTime)+
                           "\nAvg : "+ttos(bestTimeCumul/(float)gencounter)
                           //+"\nfps : "+ttos(getFrameRate())+"\n---\n"+info2
                           );
            window.draw(info);
            window.display();
            tcounter = elapsed.getElapsedTime().asSeconds();
        }else
            getFrameRate();
        ncounter++;
    }

    for(unsigned int i=0;i<evo.size();++i){
        evo[i].writeGenome();
    }
    clear();
    enemies.clear();
}
Beispiel #15
0
	PsimagLite::String filenameForThread(SizeType thread) const
	{
		return params_.logroot + ttos(thread) + ".txt";
	}
Beispiel #16
0
//--------------------------- Render ------------------------------------------
//-----------------------------------------------------------------------------
void Raven_Game::Render()
{
  m_pGraveMarkers->Render();
  
  //render the map
  m_pMap->Render();

  time_t min = gameTimeMin();
  time_t sec = gameTimeSec();
  std::string timeString = ttos(min) + ":";
  if (sec < 10)
	  timeString += "0";
  timeString += ttos(sec);
  gdi->TextColor(0,0,0);
  gdi->TextAtPos(360, 12, timeString); 


  //render all the bots unless the user has selected the option to only 
  //render those bots that are in the fov of the selected bot
  if (m_pSelectedBot && UserOptions->m_bOnlyShowBotsInTargetsFOV)
  {
    std::vector<AbstRaven_Bot*> 
    VisibleBots = GetAllBotsInFOV(m_pSelectedBot);

    std::vector<AbstRaven_Bot*>::const_iterator it = VisibleBots.begin();
    for (it; it != VisibleBots.end(); ++it) (*it)->Render();

    if (m_pSelectedBot) m_pSelectedBot->Render();
  }

  else
  {
    //render all the entities
    std::list<AbstRaven_Bot*>::const_iterator curBot = m_Bots.begin();
    for (curBot; curBot != m_Bots.end(); ++curBot)
    {
      if ((*curBot)->isAlive())
      {
        (*curBot)->Render();
      }
    }
  }
  
  //render any projectiles
  std::list<Raven_Projectile*>::const_iterator curW = m_Projectiles.begin();
  for (curW; curW != m_Projectiles.end(); ++curW)
  {
    (*curW)->Render();
  }

 // gdi->TextAtPos(300, WindowHeight - 70, "Num Current Searches: " + ttos(m_pPathManager->GetNumActiveSearches()));

  //render a red circle around the selected bot (blue if possessed)
  if (m_pSelectedBot)
  {
    if (m_pSelectedBot->isPossessed())
    {
      gdi->BluePen(); gdi->HollowBrush();
      gdi->Circle(m_pSelectedBot->Pos(), m_pSelectedBot->BRadius()+1);
    }
    else
    {
      gdi->RedPen(); gdi->HollowBrush();
      gdi->Circle(m_pSelectedBot->Pos(), m_pSelectedBot->BRadius()+1);
    }


    if (UserOptions->m_bShowOpponentsSensedBySelectedBot)
    {
      m_pSelectedBot->GetSensoryMem()->RenderBoxesAroundRecentlySensed();
    }

    //render a square around the bot's target
    if (UserOptions->m_bShowTargetOfSelectedBot && m_pSelectedBot->GetTargetBot())
    {  
      
      gdi->ThickRedPen();

      Vector2D p = m_pSelectedBot->GetTargetBot()->Pos();
      double   b = m_pSelectedBot->GetTargetBot()->BRadius();
      
      gdi->Line(p.x-b, p.y-b, p.x+b, p.y-b);
      gdi->Line(p.x+b, p.y-b, p.x+b, p.y+b);
      gdi->Line(p.x+b, p.y+b, p.x-b, p.y+b);
      gdi->Line(p.x-b, p.y+b, p.x-b, p.y-b);
    }



    //render the path of the bot
    if (UserOptions->m_bShowPathOfSelectedBot)
    {
      m_pSelectedBot->GetBrain()->Render();
    }  
    
    //display the bot's goal stack
    if (UserOptions->m_bShowGoalsOfSelectedBot)
    {
      Vector2D p(m_pSelectedBot->Pos().x -50, m_pSelectedBot->Pos().y);

      m_pSelectedBot->GetBrain()->RenderAtPos(p, GoalTypeToString::Instance());
    }

    if (UserOptions->m_bShowGoalAppraisals)
    {
      m_pSelectedBot->GetBrain()->RenderEvaluations(5, 415);
    } 
    
    if (UserOptions->m_bShowWeaponAppraisals)
    {
      m_pSelectedBot->GetWeaponSys()->RenderDesirabilities();
    }

   if (IS_KEY_PRESSED('Q') && m_pSelectedBot->isPossessed())
    {
      gdi->TextColor(255,0,0);
      gdi->TextAtPos(GetClientCursorPosition(), "Queuing");
    }
  }
}