/**********************************************************************************/ // функция добавляет новые экста цели для уничтожения // может быть использована для регистрации боссов, что прибывают с волнами или специальные стационарыне объекты // /**********************************************************************************/ 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); }