/**********************************************************************************/
// добавляем нового босса на карту
//
/**********************************************************************************/
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;
}
/**********************************************************************************************/
// устанавливаем новые значения для диалога
//
/**********************************************************************************************/
public void SetDialog(Base.GO_TYPE icoForType, string textKey, string NameKey)
{
m_dialogTextCtr.SetNewKey(textKey);
// определяемся с иконкой
if (icoForType == Base.GO_TYPE.PLAYER)
{
if (GameManager.GetInstance().GetPlayer().playerId == PLAYER.PL1)
{
Sprite spriteToSet = Player1Ico;
DialogIco.sprite = spriteToSet;
NameKey += "_1";
}
else
{
Sprite spriteToSet = Player2Ico;
DialogIco.sprite = spriteToSet;
NameKey += "_2";
}
}
else
{
Sprite spriteToSet = m_icoDictionary[icoForType];
DialogIco.sprite = spriteToSet;
}
m_nameTextCtr.SetNewKey(NameKey);
// активируем диалог, если он был спрятан
gameObject.SetActive(true);
}
public DropItemDescriptorEditor(DropItemDescriptor desc)
{
this.DropType = Base.StringToGOType(desc.DropType);
this.DropWeight = desc.DropWeight;
this.MaxNumOfDrop = desc.MaxNumOfDrop;
this.TimeForDropStart = desc.TimeForDropStart;
}
/**********************************************************************************/
// функция устанавливает
//
/**********************************************************************************/
protected void ShowNextDialogPage()
{
string levelKey = "mission_" + m_levelNumber + m_dialogKey;
DialogData dialogs = m_dialogDataCollection[levelKey];
if (dialogs.pairs.Length > m_dialogPage)
{
DialogPair currentDialogPage = dialogs.pairs[m_dialogPage];
Base.GO_TYPE goIconType = (Base.GO_TYPE)Enum.Parse(typeof(Base.GO_TYPE), currentDialogPage.IconType);
UIController.GetInstance().SetDialog(goIconType, currentDialogPage.textKey, currentDialogPage.NameKey);
// взводим таймер блокировки
m_controllerBlockTimer = m_controllerBlockTimerLimit;
m_dialogPage++;
}
else
{
Debug.Log("Dialog complited");
// скрываем диалог и переходим к игре
m_state = CDM_STATE.READY;
UIController.GetInstance().HideDialog();
GameManager.SetPauseState(false, true);
}
}
/**********************************************************************************/
// функция захвата строения
// здесь определяется сменит ли здание владельца и устанавливается тип производимых юнитов
//
/**********************************************************************************/
public virtual void Capture(CaptureData cdata)
{
if (m_ownerId != cdata.OwnweID)
{
m_currentVirusStamina -= cdata.CapturePower;
if (m_currentVirusStamina <= 0)
{
m_ownerId = cdata.OwnweID;
Debug.Log("Building was captured by pl# " + m_ownerId.ToString());
m_animator.SetInteger("ownerID", m_ownerId);
m_animator.SetTrigger("isCuptured");
if (m_IIFlAnimator != null)
{
m_IIFlAnimator.SetInteger("ownerID", m_ownerId);
m_IIFlAnimator.SetTrigger("isCuptured");
}
// выбираем юнита для производства
if (m_ownerId == (int)PLAYER.PL1)
{
m_unitProdactionType = UnitToProduce_Pl1;
}
else if (m_ownerId == (int)PLAYER.PL2)
{
m_unitProdactionType = UnitToProduce_Pl2;
}
else
{
m_unitProdactionType = UnitToProduce_Neutral;
}
// при захвате обновляем счётчик производства, чтобы не воровать чужих юнитов
m_currentProductionTime = RateOfProduction;
// выставляем новую сопротивляемость
if (m_ownerId == (int)PLAYER.NEUTRAL)
{
m_currentVirusStamina = NeutralVirusStamina;
}
else
{
m_currentVirusStamina = MaxVirusStamina;
}
// увеличиваем счётчик очков за захват
GameManager.GetInstance().IncreasePlayerScopeBuildingCuptured((PLAYER)m_ownerId, CuptureScope);
m_virusMarker.SetOwner((PLAYER)m_ownerId);
m_createdUnitIDs.Clear();
// помечаем здание как разрушенное - больше оно не будет производить нейтральных юнитов
m_isDestroyed = true;
}
m_virusMarker.SetStamina(m_currentVirusStamina);
}
}
/**********************************************************************************/
// функция возвращает префаб по типу
//
/**********************************************************************************/
public GameObject GetPrefab(Base.GO_TYPE type)
{
if (!m_prefabsCollection.ContainsKey(type))
{
Debug.LogError("We have no prefabs for " + type.ToString() + " !!!");
return(null);
}
return(m_prefabsCollection[type]);
}
/**********************************************************************************/
// выбираем тип бонуса бонус
//
/**********************************************************************************/
private Base.GO_TYPE ChoseDropType()
{
int weightOfDropSet = 0;
// формируем список допустимого дропа
List <DropItemDescriptorEditor> avalibleDrop = new List <DropItemDescriptorEditor>();
foreach (var possibleDrop in m_dropDescriptor)
{
Base.GO_TYPE type = possibleDrop.DropType;
// отсекаем тех, с кем мы работать не можем
// по количеству
if (m_deploedDrops[type] <= 0)
{
continue;
}
// по времени
if (possibleDrop.TimeForDropStart > m_levelTimer)
{
continue;
}
// подсчитываем суммарынй вес всего дропа
weightOfDropSet += possibleDrop.DropWeight;
avalibleDrop.Add(possibleDrop);
}
// проверочка
if (avalibleDrop.Count == 0)
{
Debug.LogError("avalibleDrop is empty!");
return(Base.GO_TYPE.NONE_TYPE);
}
// определяем бонус для дропа
int randomDropIndex = Random.Range(1, weightOfDropSet + 1);
Base.GO_TYPE bonusType = Base.GO_TYPE.NONE_TYPE;
int growingWeight = 0;
int itemIndex = 0;
do
{
DropItemDescriptorEditor potantialDrop = avalibleDrop[itemIndex];
bonusType = potantialDrop.DropType;
growingWeight += potantialDrop.DropWeight;
itemIndex++;
}while (growingWeight < randomDropIndex && itemIndex < avalibleDrop.Count);
return(bonusType);
}
/**********************************************************************************/
// функция возврата игровых объектов в кеш
//
/**********************************************************************************/
public void ReturnObjectToCash(GameObject objectInstance, Base.GO_TYPE objectType)
{
if (!m_objectColection.ContainsKey(objectType))
{
m_objectColection[objectType] = new LinkedList <GameObject>();
}
LinkedList <GameObject> cash = m_objectColection[objectType];
cash.AddLast(objectInstance);
}
/**********************************************************************************/
// функция создания игровых объектов
// создаём новый объект
/**********************************************************************************/
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);
}
/**********************************************************************************/
// функция инициализации здания
//
/**********************************************************************************/
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 GameObject CreateGObject(Vector2 from, Base.DIREC direction, Base.GO_TYPE objectType, bool useOffset = true)
{
GameObject instance = null;
// пробуем получить объект из кеша
instance = GetGObjectFromCash(from, direction, objectType, useOffset);
// если в кеше ничего нет, создаём новые объект
if (instance == null)
{
instance = GetNewGObjectInstance(from, direction, objectType, useOffset);
}
if (instance == null)
{
Debug.Log("CreateGObject:: MAIN ERROR!");
}
return(instance);
}
/**********************************************************************************/
// дропаем рандомный бонус
//
/**********************************************************************************/
protected void DeployRandomBonus()
{
if (m_dropDescriptor.Count == 0)
{
Debug.LogError("m_dropDescriptor is empty!");
return;
}
Base.GO_TYPE bonusType = ChoseDropType();
// определяем место дропа
// выбираем рандомную позицию и проверяем её на доступность
int xMapSize = MapGenerator.GetInstance().MapSizeX;
int yMapSize = MapGenerator.GetInstance().MapSizeY;
Point positionToDrope = new Point(-1, -1);
while (!PathFinder.GetInstance().ValidatePathCell(positionToDrope))
{
positionToDrope.x = Random.Range(0, xMapSize);
positionToDrope.y = Random.Range(0, yMapSize);
}
// создаём дроп под
Vector2 positionOutsideTheMap = new Vector2(-100, -100);
GameObject dropPod = ObjectFactory.GetInstance().CreateGObject(positionOutsideTheMap, Base.DIREC.DOWN, Base.GO_TYPE.DROP_POD, false);
DropPodCtr podeCtr = dropPod.GetComponent <DropPodCtr>();
if (podeCtr == null)
{
Debug.LogError("podeCtr is null!");
return;
}
// загружаем под полезной нагрузкой и отправляем
podeCtr.SetDropType(bonusType);
podeCtr.DropInPosition(positionToDrope);
m_currentNumberOfDroppedBonus++;
}
/**********************************************************************************/
// функция проверяет наличие возможного дропа с юнита
//
/**********************************************************************************/
private void CheckUnitDrop()
{
// проверяем дроп
if (Drop != null)
{
if (Drop.Length > 0)
{
// получаем общий вес набора потенциального лута
int weightOfSet = 0;
for (int i = 0; i < Drop.Length; i++)
{
weightOfSet += Drop[i].Weight;
}
// выбираем объект для дропа
int random = Random.Range(0, weightOfSet + 1);
Base.GO_TYPE typeOfDrop = Base.GO_TYPE.NONE_TYPE;
weightOfSet = 0;
for (int i = 0; i < Drop.Length; i++)
{
weightOfSet += Drop[i].Weight;
typeOfDrop = Drop[i].Drop;
if (weightOfSet >= random)
{
break;
}
}
// создаём дроп
if (typeOfDrop != Base.GO_TYPE.NONE_TYPE)
{
Vector2 dropPosition = GetGlobalPosition().GetUnityPoint() + new Vector2(Base.HALF_OF_CELL, Base.HALF_OF_CELL);
GameObject production = ObjectFactory.GetInstance().CreateGObject(dropPosition, Base.DIREC.DOWN, typeOfDrop, false);
}
}
}
}
/**********************************************************************************/
// извещаем менеджер, что бонус был подобран
//
/**********************************************************************************/
public void BonusWasTaked(Base.GO_TYPE bonusType)
{
// в отношении бонусов прибывших не с орбиты - ничего не предпринимаем - они не в юрисдикции DropManager
if (!m_deploedDrops.ContainsKey(bonusType))
{
Debug.Log("Bonus ignored: " + bonusType.ToString());
return;
}
m_currentNumberOfDroppedBonus--;
// увеличиваем счётчик одновременно присутствующих бонусов
if (m_deploedDrops[bonusType] != (int)DropItemDescriptorEditor.DROP_MARKER.UNLIMITED)
{
m_deploedDrops[bonusType]++;
}
// корректируем общий счётчик бонусов
if (m_currentNumberOfDroppedBonus < m_maxNumberOfDroppedBonus)
{
m_state = DM_STATE.WAIT_FOR_DEPLAY;
m_currentTimerToNextDrop = Random.Range(TimeBetweenDropMin, TimeBetweenDropMax);
}
}
/**********************************************************************************/
// функция создания игровых объектов
// пытаемся найти объект в кеше
/**********************************************************************************/
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);
}
/**********************************************************************************/
// функция выбиарет здание(ия) для генерации на карте.
//
/**********************************************************************************/
virtual protected List <GameObject> GetBuildingToInstance(BlockSettings settings)
{
/*****************/
// определяем кол-во зданий, которые необходимо будет выбрать для генерации
int numOfBuildings = 0;
int maxGenWeight = 0;
foreach (var numVariant in settings.NumOfBuildings)
{
maxGenWeight += numVariant.y;
}
int randomWeight = Random.Range(1, maxGenWeight + 1);
int currentGenWeight = 0;
for (int i = 0; i < settings.NumOfBuildings.Length; i++)
{
numOfBuildings = settings.NumOfBuildings[i].x; // количество зданий для генерации
currentGenWeight += settings.NumOfBuildings[i].y; // веса для данного варианта кол-ва зданий
// если достигли или перешагнули значение случайного веса - выходим из цикла и используем последнее выбранное здание
if (currentGenWeight >= randomWeight)
{
break;
}
}
/*****************/
// выбираем здания для генерации
List <GameObject> toInstantiate = new List <GameObject>();
// подсчитываем сумму всех весов в списке потенциальных зданий
maxGenWeight = 0;
foreach (var building in settings.Buildings)
{
maxGenWeight += building.Weight;
}
// собираем коллекцию префабов для дальнейшей генерации
ObjectLibrary objLib = ObjectLibrary.GetInstance();
for (; numOfBuildings > 0; numOfBuildings--)
{
randomWeight = Random.Range(1, maxGenWeight + 1);
int currentBuildingWeight = 0;
Base.GO_TYPE buildingType = Base.GO_TYPE.NONE_TYPE;
for (int i = 0; i < settings.Buildings.Length; i++)
{
buildingType = settings.Buildings[i].BuildingType;
currentBuildingWeight += settings.Buildings[i].Weight;
// если достигли или перешагнули значение случайного веса - выходим из цикла и используем последнее выбранное здание
if (currentBuildingWeight >= randomWeight)
{
break;
}
}
GameObject prefab = objLib.GetPrefab(buildingType);
toInstantiate.Add(prefab);
}
return(toInstantiate);
}
/**********************************************************************************************/
// отображаем диалог на экране
//
/**********************************************************************************************/
public void SetDialog(Base.GO_TYPE icoForType, string textKey, string NameKey)
{
DialogController ctr = DialogPanel.GetComponent <DialogController>();
ctr.SetDialog(icoForType, textKey, NameKey);
}
/**********************************************************************************/
// устанавливаем тип сбрасываемого дропа
//
/**********************************************************************************/
public void SetDropType(Base.GO_TYPE dropType)
{
m_dropType = dropType;
}
