map_zones.cpp

Go to the documentation of this file.

//            Copyright (C) 2004-2007 by The Allacrost Project
//                         All Rights Reserved
//
// This code is licensed under the GNU GPL version 2. It is free software
// and you may modify it and/or redistribute it under the terms of this license.
// See http://www.gnu.org/copyleft/gpl.html for details.

#include "system.h"

#include "map_zones.h"
#include "map_objects.h"
#include "map_sprites.h"

extern bool MAP_DEBUG;

using namespace std;

using namespace hoa_utils;

namespace hoa_map {

namespace private_map {

// *****************************************************************************
// ************************* MapZone Class Functions ***************************
// *****************************************************************************

void MapZone::AddSection(ZoneSection* section) {
  _sections.push_back(*section);
  delete section;
}



bool MapZone::IsInsideZone(uint16 pos_x, uint16 pos_y) {
  // Verify each section of the zone to make sure the position is in bounds.
  for (std::vector<ZoneSection>::const_iterator i = _sections.begin(); i != _sections.end(); ++i) {
    if (pos_x >= i->start_col && pos_x <= i->end_col &&
      pos_y >= i->start_row && pos_y <= i->end_row )
    {
      return true;
    }
  }
  return false;
}



void MapZone::_RandomPosition(uint16& x, uint16& y) {
  // Select a ZoneSection randomly
  uint16 i = RandomBoundedInteger(0, _sections.size() - 1);

  // Select a position inside that section
  x = RandomBoundedInteger(_sections[i].start_col, _sections[i].end_col);
  y = RandomBoundedInteger(_sections[i].start_row, _sections[i].end_row);
}

// *****************************************************************************
// *********************** EnemyZone Class Functions *************************
// *****************************************************************************

EnemyZone::EnemyZone(uint32 regen_time, bool restrained) :
  _regen_time(regen_time),
  _spawn_timer(0),
  _active_enemies(0),
  _restrained(restrained)
{}



void EnemyZone::AddEnemy(EnemySprite* enemy, MapMode* map, uint8 count) {
  if (count == 0) {
    // NOTE: The EnemySprite pointer passed in is not deleted in this case
    if (MAP_DEBUG)
      cerr << "MAP WARNING: EnemyZone::AddEnemy called with a zero count for the enemy" << endl;
    return;
  }

  // Prepare the first enemy
  enemy->SetZone(this);
  map->_AddGroundObject(enemy);
  _enemies.push_back(enemy);

  // Create any additional copies of the enemy and add them as well
  uint8 remaining = count - 1;
  while (remaining > 0) {
    EnemySprite* copy = new EnemySprite(*enemy);
    copy->SetObjectID(map->_GetGeneratedObjectID() );
    //Add a 10% random margin of error to make enemies look less sync'ed
    copy->SetTimeToChange( (uint32)(copy->GetTimeToChange() * ( 1 + RandomFloat()*10 ) ) );
    copy->Reset();
    map->_AddGroundObject(copy);
    _enemies.push_back(copy);
    remaining--;
  }
}



void EnemyZone::EnemyDead() {
  --_active_enemies;
}



void EnemyZone::Update() {
  // Spawn new enemies only if there is at least one enemy that is not active
  if (_active_enemies == _enemies.size()) {
    return;
  }

  // Return if the regenenration time has not been reached, return
  _spawn_timer += hoa_system::SystemManager->GetUpdateTime();
  if (_spawn_timer < _regen_time) {
    return;
  }

  // Otherwise, select a DEAD enemy to spawn
  uint32 index = 0;
  for (uint32 i = 0; i < _enemies.size(); i++) {
    if (_enemies[i]->IsDead() == true) {
      index = i;
      break;
    }
  }

  // Used to retain random position coordinates in the zone
  uint16 x, y;
  // Number of times to try to place the enemy in the zone (arbitrarly set to 5 tries)
  int8 retries = 5;
  // Holds the result of a collision detection check
  bool collision;

  // Select a random position inside the zone to place the spawning enemy, and make sure that there is no collision
  _enemies[index]->no_collision = false;
  do {
    _RandomPosition(x, y);
    _enemies[index]->SetXPosition(x, 0.0f);
    _enemies[index]->SetYPosition(y, 0.0f);
    collision = MapMode::_current_map->_DetectCollision(_enemies[index]);
  } while (collision && --retries > 0);

  // If there is still a collision, reset the collision info on the enemy and retry on the next frame update
  if (collision) {
    _enemies[index]->no_collision = true;
    return;
  }

  // Otherwise, spawn the enemy and reset the spawn timer
  _spawn_timer = 0;
  _enemies[index]->ChangeStateSpawning();
  _active_enemies++;
} // void EnemyZone::Update()

} // namespace private_map

} // namespace hoa_map

---