/**********************************************************************************/
// функция добавляет новые экста цели для уничтожения
// может быть использована для регистрации боссов, что прибывают с волнами или специальные стационарыне объекты
//
/**********************************************************************************/
public void RegistrAsExtraNPCTarget(GameObject targetToRegistr)
{
// сохраняем объект как цель уровня
CIGameObject gmo = targetToRegistr.GetComponent <CIGameObject>();
m_npcTarget[gmo.ID] = targetToRegistr;
}
/**********************************************************************************/
// функция дерегестрирует цель
// производится проверка выигрыша игрока
//
/**********************************************************************************/
public void TargetIsDead(GameObject target)
{
if (GameManager.GetInstance().GameMode == GameManager.GAME_MODE.SINGLE)
{
CIGameObject gmo = target.GetComponent <CIGameObject>();
if (gmo.GOType == Base.GO_TYPE.PLAYER)
{
CompanyManager.GetInstance().OnGoalsFailed();
}
else
{
m_npcTarget.Remove(gmo.ID);
// обновляем текущую сложность
int bossWeight = m_bossWeights[gmo.GOType.ToString()];
m_currentDifficulties -= bossWeight;
UpdateNPCTargets();
if (m_npcTarget.Count == 0)
{
CompanyManager.GetInstance().OnGoalsAchieved();
}
}
}
else
{
PlayerController pc = target.GetComponent <PlayerController>();
DuelManager.GetInstance().OnGoalAchived(pc.playerId);
}
}
/**********************************************************************************/
// функция стрельбы
//
/**********************************************************************************/
protected virtual void FireWeapon(Vector2 position, Base.DIREC direction)
{
GameObject bulletObj = ObjectFactory.GetInstance().CreateGObject(position, direction, BulletType);
Bullet bulletCtr = bulletObj.GetComponent <Bullet>();
if (bulletCtr != null)
{
bulletCtr.Owner = m_ownerID;
bulletCtr.OwnerUnitID = m_unitID;
}
else
{
// некоторые типы оружия используют других существ в качестве снаряда
// в этом случае используем GMovingObject
CIGameObject gmo = bulletObj.GetComponent <CIGameObject>();
gmo.Owner = m_ownerID;
}
m_currentNumOfFiredBullets++;
if (m_currentNumOfFiredBullets >= NumberOfBullet)
{
m_state = WEAPON_STATE.RECHARGE;
m_currentRechargeTimer = FireRechargeTime;
}
}
/**********************************************************************************/
// процессинг строения, производство юнитов
//
/**********************************************************************************/
private void FixedUpdate()
{
// стопим все процессы, если игра поставлена на паузу
if (GameManager.GamePaused)
{
return;
}
if (IsInitialized() && m_unitProdactionType != Base.GO_TYPE.NONE_TYPE)
{
// разрушенные и незахваченные здания ничего не производят
if (m_isDestroyed && m_ownerId == (int)PLAYER.NEUTRAL)
{
return;
}
// блокируем производство если у здания уже есть достигли предела по количеству существ
if (m_createdUnitIDs.Count >= MaxNumberOfProd)
{
return;
}
// рассчитываем текущий прогресс производства
m_currentProductionTime -= Time.deltaTime;
if (m_currentProductionTime <= 0)
{
GameObject production = ObjectFactory.GetInstance().CreateGObject(m_productionPosition, Base.DIREC.DOWN, m_unitProdactionType, false);
// бонусы - недвижимые объекты, потому GMovingObject не имеют
if (production.tag != "Bonus")
{
CIGameObject gmo = production.GetComponent <CIGameObject>();
gmo.Owner = m_ownerId;
m_createdUnitIDs.Add(gmo.ID);
gmo.ProductionBase = this;
}
else
{
BonusCtr bctr = production.GetComponent <BonusCtr>();
bctr.ProductionBase = this;
}
if (m_ownerId == (int)PLAYER.NEUTRAL)
{
// устанавливаем ранодное стартовое значение для того, чтобы нейтральные войска выходили не в один момент
m_currentProductionTime += RateOfProductionNeutral;
}
else
{
m_currentProductionTime += RateOfProduction;
}
// увеличиваем счётчик очков за производство
// TODO: производство пока приносит строго 1 очко, подумать над этим на досуге
GameManager.GetInstance().IncreasePlayerScopeUnitProduction((PLAYER)m_ownerId, 1);
}
}
}
/**********************************************************************************/
// обновляем цель
//
/**********************************************************************************/
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);
}
}
public DamageData(int Damage, DAMAGE_TYPE type, CIGameObject Damager, RESPONSE ExpectResponce)
{
this.Damage = Damage;
this.DamageType = type;
this.Damager = Damager;
this.ExpectResponce = ExpectResponce;
}
public EffectDescriptor(UnitEffect.EFFECT_TYPE type, int value, CIGameObject producer, EffectResponsibility responsibility)
{
Type = type;
Responsibility = responsibility;
Value = value;
EffectProducer = producer;
}
/**********************************************************************************/
// функция убирающая юнита с карты, к примеру в случае смерти
//
/**********************************************************************************/
public void ReleaseUnitFromMap(CIGameObject unitCtr)
{
Point position = unitCtr.GetGlobalPosition();
int unitID = unitCtr.ID;
Dictionary <int, CIGameObject> listOfUnits;
// проверяем - работали ли мы уже с этим юнитом
// если нет - выходим, ничего больше делать не надо, так как мы его и не учитывали
if (!m_UnitToPoint.ContainsKey(unitID))
{
Debug.LogWarning("UnitMapController unregistred unit was released at " + position);
return;
}
// убираем все данные о юните
listOfUnits = GetListOfUnitInPosition(m_UnitToPoint[unitID]);
if (!listOfUnits.ContainsKey(unitID))
{
Debug.LogWarning("UnitMapController! something wrong with inner structures! for unit at " + position);
return;
}
listOfUnits.Remove(unitID);
m_UnitToPoint.Remove(unitID);
}
/**********************************************************************************/
// добавляем нового босса на карту
//
/**********************************************************************************/
void AddNewBoss(string bossType)
{
// преобразовываем строку к типу юнита
Base.GO_TYPE bossGOType = (Base.GO_TYPE)Enum.Parse(typeof(Base.GO_TYPE), bossType);
// создаем экземпляр юнита
GameObject bossObject = ObjectFactory.GetInstance().CreateGObject(new Vector2(0, 0), Base.DIREC.DOWN, bossGOType);
// устанавливаем владельца
CIGameObject gmo = bossObject.GetComponent <CIGameObject>();
gmo.Owner = (int)PLAYER.NEUTRAL;
// выбираем рандомную позицию для юнита
MapGenerator mg = MapGenerator.GetInstance();
int xMapSizeInBlocks = mg.MapSizeX / mg.SizeOfBlocks;
int yMapSizeInBlocks = mg.MapSizeY / mg.SizeOfBlocks;
int x = Random.Range(0, xMapSizeInBlocks);
int y = Random.Range(0, yMapSizeInBlocks);
// помещаем юнита в блок
mg.PlaceObjectInBlock(x, y, bossObject);
// сохраняем объект как цель уровня
m_npcTarget[gmo.ID] = bossObject;
}
/**********************************************************************************/
// производим поиск цели
// в случае обнаружения произвойдёт 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;
}
}
/**********************************************************************************/
// производим поиск цели
// в случае обнаружения произвойдёт 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;
}
}
/**********************************************************************************/
// функция создания игровых объектов
// создаём новый объект
/**********************************************************************************/
protected GameObject GetNewGObjectInstance(Vector2 from, Base.DIREC direction, Base.GO_TYPE objectType, bool useOffset)
{
GameObject instance = null;
GameObject toInstantiate = ObjectLibrary.GetInstance().GetPrefab(objectType);
if (toInstantiate == null)
{
Debug.LogError("ObjectFactory::GetNewGObjectInstance: toInstantiate is null!!!");
return(null);
}
float OffsetSize = offset;
if (!useOffset)
{
OffsetSize = 0;
}
Vector2 objectDirection = new Vector2(0f, 0f);
switch (direction)
{
case Base.DIREC.DOWN:
instance = Instantiate(toInstantiate, new Vector3(from.x, from.y - OffsetSize, 0f), Quaternion.identity) as GameObject;
objectDirection.y = -1f;
break;
case Base.DIREC.UP:
instance = Instantiate(toInstantiate, new Vector3(from.x, from.y + OffsetSize, 0f), Quaternion.identity) as GameObject;
objectDirection.y = 1f;
break;
case Base.DIREC.LEFT:
instance = Instantiate(toInstantiate, new Vector3(from.x - OffsetSize, from.y, 0f), Quaternion.identity) as GameObject;
objectDirection.x = -1f;
break;
case Base.DIREC.RIGHT:
instance = Instantiate(toInstantiate, new Vector3(from.x + OffsetSize, from.y, 0f), Quaternion.identity) as GameObject;
objectDirection.x = 1f;
break;
}
// бонусы у нас недвижимые объекты и контроллер у них соответсвенно свой
if (instance.tag != "Bonus")
{
CIGameObject ctr = instance.GetComponent <CIGameObject>();
ctr.ID = GetUnitID();
ctr.SetDirection(objectDirection);
}
return(instance);
}
/**********************************************************************************/
// строим объект
//
/**********************************************************************************/
protected void BuildObject()
{
Vector2 positionToBuild = GetGlobalPositionCenter_Unity();
GameObject production = ObjectFactory.GetInstance().CreateGObject(positionToBuild, Base.DIREC.DOWN, ObjectToBuild, false);
// бонусы - недвижимые объекты, потому CIObject не имеют
if (production.tag != "Bonus")
{
CIGameObject gmo = production.GetComponent <CIGameObject>();
gmo.Owner = Owner;
}
// отключаемся после строительства
BurnBullet();
}
/**********************************************************************************/
// Функция возвращает главного противника для указанного игрока (противник данному игроку)
//
/**********************************************************************************/
public GameObject GetTarget(PLAYER unitOwnerId, Point unitPosition)
{
GameManager gm = GameManager.GetInstance();
// если играется дуэль - возвращаем в качестве цели "противного" инопланетянина
if (gm.GameMode == GameManager.GAME_MODE.DUEL)
{
if (unitOwnerId == PLAYER.PL1)
{
return(gm.GetPlayersObject(PLAYER.PL2));
}
else
{
return(gm.GetPlayersObject(PLAYER.PL1));
}
}
// если играется компания - пробуем определить ближайшего противника
else if (gm.GameMode == GameManager.GAME_MODE.SINGLE)
{
GameObject closestTarget = null;
int closestDist = 9999;
// перебираем все актуальные цели и ищем ближайшую к нам
foreach (var targetPair in m_npcTarget)
{
GameObject potantialTarget = targetPair.Value;
CIGameObject gmo = potantialTarget.GetComponent <CIGameObject>();
Point tPosition = gmo.GetGlobalPosition();
Point dist = unitPosition - tPosition;
int potDist = dist.GetSimpleLength();
// запоминаем новую ближайшую цель
if (potDist < closestDist)
{
closestTarget = potantialTarget;
closestDist = potDist;
}
}
return(closestTarget);
}
Debug.LogError("Wrong GameMode!");
return(null);
}
/**********************************************************************************/
// создаём таблицу объектов
//
/**********************************************************************************/
void Start()
{
// обрабатываем все GMovingObject по одному
// юниты игроков
CIGameObject gmo = null;
for (int i = 0; i < Units.Length; i++)
{
gmo = Units[i].GetComponent <CIGameObject>();
m_prefabsCollection[gmo.GOType] = gmo.gameObject;
}
// нейтральные юниты
for (int i = 0; i < NeutralUnits.Length; i++)
{
gmo = NeutralUnits[i].GetComponent <CIGameObject>();
m_prefabsCollection[gmo.GOType] = gmo.gameObject;
}
// снаряды
for (int i = 0; i < Shots.Length; i++)
{
gmo = Shots[i].GetComponent <CIGameObject>();
m_prefabsCollection[gmo.GOType] = gmo.gameObject;
}
// здания
BuildingController bCtr = null;
for (int i = 0; i < Buildings.Length; i++)
{
bCtr = Buildings[i].GetComponent <BuildingController>();
m_prefabsCollection[bCtr.BuildingType] = bCtr.gameObject;
}
// обрабатываем все бонусы
BonusCtr bonus = null;
for (int i = 0; i < Bonuses.Length; i++)
{
bonus = Bonuses[i].GetComponent <BonusCtr>();
m_prefabsCollection[(Base.GO_TYPE)bonus.BonusType] = bonus.gameObject;
}
}
/**********************************************************************************/
// функция проверки столкновения
// если цель игрок, юнит или здание/препятствие - происходит взрыв снаряда
//
/**********************************************************************************/
virtual protected void CheckBulletBurn(Collision2D coll)
{
if (m_state == BULLET_STATE.FLY)
{
string otherObjTag = coll.gameObject.tag;
if (otherObjTag == "Player" || otherObjTag == "wall" || otherObjTag == "Building" || otherObjTag == "Unit")
{
bool unitStateCheck = true;
// проверяем, живая ли цель, мёртвых атоковать не будем
if (otherObjTag == "Unit")
{
Unit collidedUnit = coll.gameObject.GetComponent <Unit>();
if (collidedUnit == null)
{
Debug.LogError("CheckMonsterAttack: unit have no 'unit' controller!");
return;
}
// проверяем состояние юнита + добавляет защиту от самострела (когда снаряд сталкивается с самим стрелком)
unitStateCheck = collidedUnit.State == Unit.UNIT_STATE.ACTIVE && OwnerUnitID != collidedUnit.ID;
}
else if (otherObjTag == "Player")
{
// отключаем нанесение урона самому себе
CIGameObject collidedUnit = coll.gameObject.GetComponent <CIGameObject>();
if (Owner == collidedUnit.Owner)
{
unitStateCheck = false;
}
}
// если цель пригодна для анигиляции - наносим урон ^_^
if (unitStateCheck)
{
ApplyBilletEffect(coll);
BurnBullet();
// отключаем коллайдер и зануляем скорость
m_collider.enabled = false;
speed = 0.0f;
m_rb2d.velocity = new Vector2(0, 0);
}
}
}
}
/**********************************************************************************/
// создаём поражающий элемент
//
/**********************************************************************************/
protected virtual void CreateBullet(Vector2 position, Base.DIREC direction)
{
GameObject bulletObj = ObjectFactory.GetInstance().CreateGObject(position, direction, BulletType);
Bullet bulletCtr = bulletObj.GetComponent <Bullet>();
if (bulletCtr != null)
{
bulletCtr.Owner = m_ownerID;
bulletCtr.OwnerUnitID = m_unitID;
}
else
{
// некоторые типы оружия используют других существ в качестве снаряда
// в этом случае используем GMovingObject
CIGameObject gmo = bulletObj.GetComponent <CIGameObject>();
gmo.Owner = m_ownerID;
}
}
/**********************************************************************************/
// функция обновляет таблицы позиций юнитов
// возвращает true, если координата была обновлена
//
/**********************************************************************************/
public bool UpdateUnitPosition(CIGameObject unitCtr)
{
Point position = unitCtr.GetGlobalPosition();
int unitID = unitCtr.ID;
Dictionary <int, CIGameObject> listOfUnits;
// проверяем - работали ли мы уже с этим юнитом
// если нет - добавляем всё необходимое и выходим
if (!m_UnitToPoint.ContainsKey(unitID))
{
m_UnitToPoint[unitID] = position;
listOfUnits = GetListOfUnitInPosition(position);
listOfUnits[unitID] = unitCtr;
return(true);
}
// проверяем, "изменилась ли координата?"
// если нет - выходим
Point oldPosition = m_UnitToPoint[unitID];
if (oldPosition.IsSamePoint(position))
{
return(false);
}
// в противном случае перемещаем объект из старой позиции в новую
// обновляем и перезаписываем позицию объекта
// удаляем старые записи
listOfUnits = GetListOfUnitInPosition(oldPosition);
listOfUnits.Remove(unitID);
// добавляем новые
listOfUnits = GetListOfUnitInPosition(position);
listOfUnits[unitID] = unitCtr;
m_UnitToPoint[unitID] = position;
return(true);
}
/**********************************************************************************/
// функция производит поиск противников в заданном радиусе
//
/**********************************************************************************/
public List <CIGameObject> SearchEnemiesInRadius(Point position, int radius, PLAYER ownerId, bool closest = true)
{
List <CIGameObject> listOfUnits = new List <CIGameObject>();
// начинаем поиск объектов от самого ближайшего
for (int searchingRadius = 0; searchingRadius <= radius; searchingRadius++)
{
List <Point> pointsToCheck = m_pointsToSearch[searchingRadius];
foreach (Point point in pointsToCheck)
{
Point pointToCheck = point + position;
// проверяем точку на валидность
if (pointToCheck.x < 0 || pointToCheck.x >= m_xMapSize || pointToCheck.y < 0 || pointToCheck.y > m_yMapSize)
{
continue; // если точка за границей карты - уходим на сл. итерацию
}
Dictionary <int, CIGameObject> listOfUnit = GetListOfUnitInPosition(pointToCheck);
foreach (var unit in listOfUnit)
{
// если нашли юнита другого игрока, добавляем его к списку
CIGameObject unitCtr = unit.Value;
if (unitCtr.Owner != (int)ownerId)
{
listOfUnits.Add(unitCtr);
}
}
}
// если мы ищем ближайшего противника, в случае нахождения таковых, сразу же возвращаем список найденых
// в противном случае продолжаем поиск до максимального радиуса
if (closest && listOfUnits.Count > 0)
{
return(listOfUnits);
}
}
return(listOfUnits);
}
/**********************************************************************************/
// основная функция движения к заданному объекту
//
/**********************************************************************************/
protected virtual void MoveToGObject(GameObject target)
{
// проверяем цель, если целей больше нет - останавливаемся
if (target == null)
{
return;
}
// получаем и проверяем контроллер цели
CIGameObject gmoTarget = target.GetComponent <CIGameObject>();
if (gmoTarget == null)
{
Debug.LogError("Wrong target! GMovingObject is NULL!");
return;
}
// двигаемся к намеченной цели
Point pointToAchive = gmoTarget.GetGlobalPosition();
MoveToPoint(pointToAchive);
}
/**********************************************************************************/
// создаём поражающий элемент
//
/**********************************************************************************/
protected override void CreateBullet(Vector2 position, Base.DIREC direction)
{
// определяем направления запуска снаряда
Point targetPosition = m_target.GetComponent <CIGameObject>().GetGlobalPosition();
Point unitPosition = new Point((int)(position.x / Base.SIZE_OF_CELL), (int)(position.y / Base.SIZE_OF_CELL));
LinkedList <Point> pathToTarget = PathFinder.GetInstance().GetWay(unitPosition, targetPosition);
// если объект находится не в той же клетке, что и цель, используем вторую точку пути, так как она находится в направлении движения
if (pathToTarget.Count > 1)
{
pathToTarget.RemoveLast();
Point launcherPoint = pathToTarget.Last.Value;
direction = (launcherPoint - unitPosition).ToDirection();
}
GameObject bulletObj = ObjectFactory.GetInstance().CreateGObject(position, direction, BulletType);
Bullet bulletCtr = bulletObj.GetComponent <Bullet>();
if (bulletCtr != null)
{
bulletCtr.Owner = m_ownerID;
bulletCtr.OwnerUnitID = m_unitID;
}
else
{
// некоторые типы оружия используют других существ в качестве снаряда
// в этом случае используем GMovingObject
CIGameObject gmo = bulletObj.GetComponent <CIGameObject>();
gmo.Owner = m_ownerID;
ScarabCtr scarabCtr = bulletObj.GetComponent <ScarabCtr>();
if (scarabCtr != null)
{
scarabCtr.SetTarget(m_target);
}
}
}
/**********************************************************************************/
// функция применения оружия ближнего боя
//
/**********************************************************************************/
public void UseCloseWeapon(CIGameObject target, bool response)
{
if (!m_isActive)
{
return;
}
// если монстр не умеет атаковать в ближнем бою - скипаем процесс
// проверяем боеготовность
CloseWeaponController closeWeapon = m_weapons[WeaponSlot.CLOSE_WEAPON] as CloseWeaponController;
if (closeWeapon == null)
{
return;
}
if (closeWeapon.Damage == 0 || closeWeapon.State == WeaponController.WEAPON_STATE.RECHARGE)
{
return;
}
DamageData.RESPONSE expectation = DamageData.RESPONSE.EXPECTED;
if (!response)
{
expectation = DamageData.RESPONSE.NOT_EXPECTED;
}
closeWeapon.Fire();
target.ApplyDamage(new DamageData(closeWeapon.Damage, DamageData.DAMAGE_TYPE.PHYSICAL, m_unitWithWeapon, expectation));
// если оружие предполагает саморазрушение юнита/объекта после использования - наносим себе ультимативный урон
if (closeWeapon.SelfDamaged)
{
m_unitWithWeapon.ApplyDamage(new DamageData(100, DamageData.DAMAGE_TYPE.PHYSICAL, m_unitWithWeapon, DamageData.RESPONSE.NOT_EXPECTED));
}
}
/**********************************************************************************/
// функция применения оружия ближнего боя
// используется в случае нападения при столкновении с игровым объектом
// отличие от другой UseCloseWeapon ф-ции заключается в том, что мы изначально не знаем на кого/что наткнулись
// и можем ли вообще применить оружие к этому объекту
//
/**********************************************************************************/
public void UseCloseWeapon(GameObject target)
{
if (!m_isActive)
{
return;
}
string otherObjTag = target.tag;
if (otherObjTag == "Player" || otherObjTag == "Unit")
{
bool unitStateCheck = true;
// проверяем, живая ли цель, мёртвых атоковать не будем
if (otherObjTag == "Unit")
{
Unit collidedUnit = target.GetComponent <Unit>();
if (collidedUnit == null)
{
Debug.LogError("UseCloseWeapon: unit have no 'unit' controller!");
return;
}
unitStateCheck = collidedUnit.State == Unit.UNIT_STATE.ACTIVE;
}
CIGameObject objectUnderAttackCtr = target.GetComponent <CIGameObject>();
int collidedGOOwner = objectUnderAttackCtr.Owner;
// если объект жив и принадлежит врагу, атакуем его
if (unitStateCheck && m_unitWithWeapon.Owner != collidedGOOwner)
{
// наносим урон врагу
UseCloseWeapon(objectUnderAttackCtr, true);
}
}
}
/**********************************************************************************/
// функция создания игровых объектов
// пытаемся найти объект в кеше
/**********************************************************************************/
protected GameObject GetGObjectFromCash(Vector2 from, Base.DIREC direction, Base.GO_TYPE objectType, bool useOffset)
{
GameObject instance = null;
Vector2 objectDirection = new Vector2(0f, 0f);
Vector2 newPosition = new Vector2(0f, 0f);
// проверяем кеш объектов
// если он у нас уже имеется - реиспользуем
if (m_objectColection.ContainsKey(objectType))
{
LinkedList <GameObject> objectPull = m_objectColection[objectType];
if (objectPull.Count > 0)
{
instance = objectPull.First.Value;
objectPull.RemoveFirst();
float OffsetSize = offset;
if (!useOffset)
{
OffsetSize = 0;
}
switch (direction)
{
case Base.DIREC.DOWN:
newPosition = new Vector2(from.x, from.y - OffsetSize);
objectDirection.y = -1f;
break;
case Base.DIREC.UP:
newPosition = new Vector2(from.x, from.y + OffsetSize);
objectDirection.y = 1f;
break;
case Base.DIREC.LEFT:
newPosition = new Vector2(from.x - OffsetSize, from.y);
objectDirection.x = -1f;
break;
case Base.DIREC.RIGHT:
newPosition = new Vector2(from.x + OffsetSize, from.y);
objectDirection.x = 1f;
break;
}
}
}
else
{
// если это первое создание объекта - создаем так же для него LinkedList для последующего хранения
m_objectColection[objectType] = new LinkedList <GameObject>();
}
// если нашёлся объект - устанавливаем ему направление
if (instance != null)
{
Transform objTransform = instance.GetComponent <Transform>();
objTransform.position = new Vector3(newPosition.x, newPosition.y, 0);
if (instance.tag != "Bonus")
{
CIGameObject ctr = instance.GetComponent <CIGameObject>();
ctr.SetDirection(objectDirection);
instance.GetComponent <CIGameObject>().ResetGObject();
}
else
{
BonusCtr ctr = instance.GetComponent <BonusCtr>();
ctr.ResetBonus();
}
}
return(instance);
}