/**********************************************************************************/
// обновляем цель
//
/**********************************************************************************/
protected override void UpdateTarget()
{
List <CIGameObject> units = GameObjectMapController.GetInstance().SearchEnemiesInRadius(m_currentPosition, m_searchingRadius, m_owner);
if (units.Count == 0)
{
m_locedTarget = null;
}
else
{
// если есть цели - выбираем одну случайно
CIGameObject targetCtr = units[Random.Range(0, units.Count)];
m_locedTarget = targetCtr.gameObject;
}
// извещаем всех заинтересованных
if (TargetToMove != null)
{
TargetToMove(m_locedTarget);
}
if (RadarUpdate != null)
{
RadarData data = new RadarData();
data.DetectedEnemy.Add(m_locedTarget);
RadarUpdate(data);
}
}
/**********************************************************************************/
// взрываем гранату
//
/**********************************************************************************/
protected virtual void BlowUpGrenade()
{
Point position = GetGlobalPosition();
List <CIGameObject> unitsInExplosion = GameObjectMapController.GetInstance().SearchEnemiesInRadius(position, ExplosionRadius, PLAYER.NO_PLAYER, false);
DamageData dd = new DamageData(damage, DamageData.DAMAGE_TYPE.PHYSICAL, this, DamageData.RESPONSE.NOT_EXPECTED);
// наносим урон всем причастным
foreach (CIGameObject gmo in unitsInExplosion)
{
gmo.ApplyDamage(dd);
}
List <GeneratedEnvironmentCtr> envInExplosion = GameObjectMapController.GetInstance().SearchEnvironmentInRadius(position, ExplosionRadius, false);
// наносим урон всем причастным
foreach (CIGameObject env in envInExplosion)
{
env.ApplyDamage(dd);
}
// проверяем игроков
foreach (CIGameObject plObject in m_players)
{
Point plPosition = plObject.GetGlobalPosition();
Point diff = position - plPosition;
if (diff.GetSimpleLength() <= ExplosionRadius)
{
plObject.ApplyDamage(dd);
}
}
// трясём камеру
CameraControllerDuelMode.ShakeCamera(ShakePower);
}
/**********************************************************************************/
// производим поиск цели
// в случае обнаружения, функция сгенерирует
//
/**********************************************************************************/
protected override void UpdateTarget()
{
// если ещё не начали никуда двигаться, стрелять тоже не будем
// защита от дурака
Base.DIREC direction = m_unitWithRadar.MoveDirection;
if (direction == Base.DIREC.NO_DIRECTION)
{
m_targetCheckTimer += m_targetCheckTimerLimit;
return;
}
// получаем список впомогательных точек для поиска
List <Point> pointsToCheck = m_cachePoints[(int)direction];
foreach (Point specPoint in pointsToCheck)
{
Point realPointToCheck = specPoint + m_currentPosition;
List <BuildingController> buildingsInPoint = GameObjectMapController.GetInstance().SearchEnemiesBuildingInRadius(realPointToCheck, 0, m_owner);
if (buildingsInPoint.Count > 0)
{
BuildingController targetCtr = buildingsInPoint[Random.Range(0, buildingsInPoint.Count)];
if (RadarUpdate != null)
{
RadarData data = new RadarData();
data.EnemyDirection.Add(direction);
data.DetectedEnemy.Add(targetCtr.gameObject);
RadarUpdate(data);
}
}
m_targetCheckTimer += m_targetCheckTimerLimit;
}
}
/**********************************************************************************/
// обработчик смерти
// может переопределяться для специальной обработки смерти, к примеру боссами
// данная функция должна быть подключена к m_armor компоненту
//
/**********************************************************************************/
protected virtual void OnDead(DamageData finalStrikeData)
{
m_state = UNIT_STATE.FAILING;
foreach (var animator in m_animators)
{
animator.SetTrigger("isFailing");
}
// сообщаем котроллеру о том, что нас можно не учитывать
GameObjectMapController.GetInstance().ReleaseUnitFromMap(this);
// сообщаем зданию производившему это существо о том, что юнит погиб и оно может производить следующий объект
if (m_productionBase != null)
{
m_productionBase.ReleaseProduction(m_unitID);
}
// проверяем дроп
CheckUnitDrop();
// увеличиваем счётчик очков игрока за убийство
int killerID = finalStrikeData.Damager.Owner;
if (killerID != Owner)
{
GameManager.GetInstance().IncreasePlayerScoreUnitLose((PLAYER)killerID, scoreCost);
}
}
/**********************************************************************************/
// GetInstance
//
/**********************************************************************************/
static public GameObjectMapController GetInstance()
{
if (s_instance == null)
{
s_instance = new GameObjectMapController();
}
return(s_instance);
}
/**********************************************************************************/
// производим поиск цели
// в случае обнаружения произвойдёт RadarUpdate эвент
//
/**********************************************************************************/
protected override void UpdateTarget()
{
if (m_targetCheckTimer <= 0)
{
// если ещё не начали никуда двигаться, стрелять тоже не будем
// защита от дурака
Base.DIREC direction = m_unitWithRadar.MoveDirection;
if (direction == Base.DIREC.NO_DIRECTION)
{
m_targetCheckTimer += m_targetCheckTimerLimit;
return;
}
// получаем список впомогательных точек для поиска врагов
// и проводим поиск целей для стрельбы
List <Point> pointsToCheck = m_cachePoints[(int)direction];
foreach (Point specPoint in pointsToCheck)
{
Point realPointToCheck = specPoint + m_currentPosition;
List <CIGameObject> unitsInPoint = GameObjectMapController.GetInstance().SearchEnemiesInRadius(realPointToCheck, 0, m_owner);
if (unitsInPoint.Count > 0)
{
CIGameObject targetCtr = unitsInPoint[Random.Range(0, unitsInPoint.Count)];
if (RadarUpdate != null)
{
RadarData data = new RadarData();
data.EnemyDirection.Add(direction);
data.DetectedEnemy.Add(targetCtr.gameObject);
RadarUpdate(data);
}
}
else
{
// проверяем игроков
foreach (CIGameObject plObject in m_players)
{
if (plObject.Owner == (int)m_owner)
{
continue;
}
if (plObject.GetGlobalPosition().IsSamePoint(realPointToCheck))
{
RadarData data = new RadarData();
data.EnemyDirection.Add(direction);
data.DetectedEnemy.Add(plObject.gameObject);
RadarUpdate(data);
}
}
}
}
m_targetCheckTimer += m_targetCheckTimerLimit;
}
}
/**********************************************************************************/
// производим поиск цели
// в случае обнаружения произвойдёт RadarUpdate эвент
//
/**********************************************************************************/
protected override void UpdateTarget()
{
if (m_targetCheckTimer <= 0)
{
// если ещё не начали никуда двигаться, стрелять тоже не будем
// защита от дурака
Base.DIREC direction = m_unitWithRadar.MoveDirection;
if (direction == Base.DIREC.NO_DIRECTION)
{
m_targetCheckTimer += m_targetCheckTimerLimit;
return;
}
// получаем список впомогательных точек для поиска врагов
// и проводим поиск целей для стрельбы
List <Point> pointsToCheck = m_cachePoints[(int)direction];
foreach (Point specPoint in pointsToCheck)
{
Point realPointToCheck = specPoint + m_currentPosition;
List <CIGameObject> unitsInPoint = GameObjectMapController.GetInstance().SearchEnemiesInRadius(realPointToCheck, m_scaningAreaRadius, m_owner);
if (unitsInPoint.Count > 0)
{
CIGameObject targetCtr = unitsInPoint[Random.Range(0, unitsInPoint.Count)];
if (RadarUpdate != null)
{
RadarData data = new RadarData();
data.EnemyDirection.Add(direction);
data.DetectedEnemy.Add(targetCtr.gameObject);
RadarUpdate(data);
}
}
else
{
// проверяем игроков
foreach (CIGameObject plObject in m_players)
{
// считаем расстояние от точки метания снаряда до игроков
// если расстояние меньше m_scaningAreaRadius - вызываем RadarUpdate эвент
Point playerPosition = plObject.GetGlobalPosition();
Point positionDiff = playerPosition - realPointToCheck;
if (positionDiff.GetSimpleLength() < m_scaningAreaRadius)
{
RadarData data = new RadarData();
data.EnemyDirection.Add(direction);
data.DetectedEnemy.Add(plObject.gameObject);
RadarUpdate(data);
}
}
}
}
m_targetCheckTimer += m_targetCheckTimerLimit;
}
}
/**********************************************************************************/
// инициализация, расширенная
//
/**********************************************************************************/
public override void InitializeUnit()
{
base.InitializeUnit();
// так как объект создаётся не стандартным путём (производства в здании), а как элемент окружения,
// то некому установить им m_unitID, выдаём его им принудительно
m_unitID = ObjectFactory.GetInstance().GetUnitID();
// регистрируем элемент окружения в контроллере
GameObjectMapController.GetInstance().RegistEnvironment(this);
}
/**********************************************************************************/
// функция обновления игровой позиции юнита
// если координата изменилась - сообщаем об этом всем заинтересованным
//
/**********************************************************************************/
protected void UpdateGamePosition()
{
// обновляем координаты в UnitMapController-е
bool positionWasUpdated = GameObjectMapController.GetInstance().UpdateUnitPosition(m_unitToDrive);
// если координата изменилась - оповещаем всех заинтересованных
if (positionWasUpdated && PositionUpdate != null)
{
Point position = m_unitToDrive.GetGlobalPosition();
PositionUpdate(position);
}
}
/**********************************************************************************/
// функция инициализации здания
//
/**********************************************************************************/
void InitializeBuilding()
{
if (!m_isInitialized)
{
m_animator = GetComponent <Animator>();
m_rb2d = GetComponent <Rigidbody2D>();
// ставим дефолтного юнита на производство
m_unitProdactionType = UnitToProduce_Neutral;
if (m_ownerId == (int)PLAYER.NEUTRAL)
{
// устанавливаем ранодное стартовое значение для того, чтобы нейтральные войска выходили не в один момент
m_currentProductionTime = Random.Range(1.0f, RateOfProductionNeutral);
}
else
{
m_currentProductionTime = RateOfProduction;
}
// получаем контроллер маркеров
Transform[] allChildren = GetComponentsInChildren <Transform>();
for (int ind = 0; ind < allChildren.Length; ind++)
{
GameObject component = allChildren[ind].gameObject;
if (component.tag == "VirusStaminaMarker")
{
m_virusMarker = component.GetComponent <BuildingStaminaMarker>();
if (m_virusMarker == null)
{
Debug.LogError("We have a problem with Virus Marker!");
}
}
// получаем аниматор 2 этажа для контроля
if (component.tag == "II_Floor")
{
m_IIFlAnimator = component.GetComponent <Animator>();
}
}
CalculateProductionPoint();
m_currentVirusStamina = NeutralVirusStamina;
m_virusMarker.SetStamina(m_currentVirusStamina);
m_virusMarker.SetOwner(PLAYER.NEUTRAL);
m_isInitialized = true;
// регистрируем здание в контроллере
GameObjectMapController.GetInstance().RegistBuilding(this);
}
}
/**********************************************************************************/
// функция запускающая генерацию карты
//
/**********************************************************************************/
public void GenerateMap(MapGeneratorSettings settings)
{
MapSizeX = settings.MapXSize;
MapSizeY = settings.MapYSize;
m_availableBlocks = settings.AvalibleBlocks;
// подготавливаемся к работе
InitializeGenertorСash();
// генерируем карту
GenerateMap(MapSizeX, MapSizeY);
// Инициализируем юнит-карта контроллер
GameObjectMapController.GetInstance().InitController(MapSizeX, MapSizeY);
}
/**********************************************************************************/
// процессинговая функция
// сообщаем нашему объекту где мы находимся, но только на первой итерации
//
/**********************************************************************************/
public override void Update()
{
if (m_firstIteration == true)
{
if (PositionUpdate != null)
{
Point position = m_unitToStay.GetGlobalPosition();
PositionUpdate(position);
GameObjectMapController.GetInstance().UpdateUnitPosition(m_unitToStay);
m_firstIteration = false;
}
}
if (m_switchinIsActive)
{
SwitchDirection();
}
UpdateTimers();
}
