private void selector(BUILDING_TYPE findBuilding)
{
for(int i=0; i< amountOfStates; i++)
{
//materialSelected[i] = newMesh[i];
}
}
public void NewBuilding(BUILDING_TYPE _type)
{
newBuildings++;
switch (_type)
{
case BUILDING_TYPE.MILITARY:
unitProductionCapacity += 3;
break;
case BUILDING_TYPE.DEFENSIVE:
defensiveCapacity += 1;
break;
case BUILDING_TYPE.ECONOMY:
incomeCapacity += 2;
break;
case BUILDING_TYPE.POPULATION:
populationCapacity += 1;
break;
case BUILDING_TYPE.TECHNOLOGY:
researchCapacity += 4;
break;
}
}
private void selector(BUILDING_TYPE findBuilding)
{
for (int i = 0; i < amountOfStates; i++)
{
//materialSelected[i] = newMesh[i];
}
}
/// <summary>
/// Method used to create a building game object based on the type of building.
/// Allows one method call to decide which type of building model shall be loaded
/// </summary>
/// <param name="penumBuildingType"></param>
/// <param name="penumGodType"></param>
/// <returns></returns>
private GameObject CreateBuildingObject(BUILDING_TYPE penumBuildingType, Faction.GodType penumGodType)
{
GameObject uniBuildingGameObject = null;
string strResourceKey = "Buildings/" + penumGodType.ToString() + penumBuildingType.ToString() + UpgradeLevel.ToString();
// Load the building model from memory
if (mdictBuildingResources.ContainsKey(strResourceKey) && mdictBuildingResources[strResourceKey] != null)
{
uniBuildingGameObject = (GameObject)GameObject.Instantiate(
mdictBuildingResources[strResourceKey]);
}
else
{
#if DEBUG
// Model was not found in resources folder, this should not occur as all models have been created now
#endif
}
// Check to ensure a game model was found when creating
if (uniBuildingGameObject != null)
{
// Add a linerenderer for outlining, scale based on scene parameters
// Allows for the outlining of buildings when selected or when building other buildings
uniBuildingGameObject.AddComponent <LineRenderer>().positionCount = 0;
uniBuildingGameObject.transform.localScale = new Vector3(ObjectRadius, ObjectRadius, ObjectRadius);
}
return(uniBuildingGameObject);
}
/// <summary>
/// Building contructor for a default building of a certain type
/// Allows creating different types of buildings based on input parameter.
/// </summary>
/// <param name="penumBuildingType">The building type to create.</param>
/// <param name="pmusFactionOwner">The owning faction of the building.</param>
public Building(BUILDING_TYPE penumBuildingType, Faction pmusFactionOwner)
{
MapGameObject = CreateBuildingObject(penumBuildingType, pmusFactionOwner.Type);
BuildingType = penumBuildingType;
OwningFaction = pmusFactionOwner;
BuildingCost = CalculateBuildingCost(penumBuildingType);
ObjectType = MapObjectType.Building;
}
/// <summary>
/// Building constructor for loading a serialized building
/// Allows the removal of duplicate code in places where save states must be loaded
/// </summary>
/// <param name="pmusSavedBuilding">A serialized building.</param>
/// <param name="pmusFactionOwner">The owning faction of the building to be loaded.</param>
public Building(GameInfo.SavedBuilding pmusSavedBuilding, Faction pmusFactionOwner)
{
UpgradeLevel = pmusSavedBuilding.UpgradeLevel;
MapGameObject = CreateBuildingObject(pmusSavedBuilding.BuildingType, pmusFactionOwner.Type);
BuildingType = pmusSavedBuilding.BuildingType;
OwningFaction = pmusFactionOwner;
BuildingCost = CalculateBuildingCost(pmusSavedBuilding.BuildingType);
ObjectType = MapObjectType.Building;
}
public GameObject GetPrefab(BUILDING_TYPE type)
{
int idx = buildingTypes.IndexOf(type);
if (idx >= 0)
{
return(buildings[idx]);
}
return(buildings[0]);
}
public BuildingData GetRandomBuildingOfType(BUILDING_TYPE type)
{
int max = m_BuildingsByType[type].Count;
if (max > 0)
{
return(m_BuildingsByType[type][UnityEngine.Random.Range(0, max)]);
}
return(null);
}
public BuildingInfo GetBuildingInfoNc(BUILDING_TYPE type)
{
List <int> keyList = new List <int>(m_townBuildingCodeDic.Keys);
for (int i = 0; i < keyList.Count; i++)
{
BuildingInfo info = WorldManager.instance.m_dataManager.m_buildingData.
GetBuildingInfo(m_townBuildingCodeDic[keyList[i]]);
if (info.type.Equals(type))
{
return(info);
}
}
return(null);
}
private BUILDING_TYPE findBuildingType(BUILDING_TYPE buildingChanged, string checkingEntity)
{
switch(checkingEntity)
{
case "50m":
average = 40f;
lowest = 20f;
return BUILDING_TYPE.small;
case "100m":
average = 60f;
lowest = 20f;
return BUILDING_TYPE.medium;
case "150m":
average = 90f;
lowest = 40f;
return BUILDING_TYPE.large;
case "Building":
return BUILDING_TYPE.aqaduct;
}
return buildingChanged;
}
// TYPE: Culture, Science , Health
// Use this for initialization
void Start()
{
m_BuildingType = BUILDING_TYPE.BUILDING_TYPE_CULTURE;
m_CurrentLevel = BUILDING_LEVEL.BUILDING_LEVEL_LV01;
/// Init the TextUI
GameObject go = new GameObject("Text_Building_"+ this.name);
UI_StatusText = (GUIText)go.AddComponent( typeof(GUIText) );
UI_StatusText.transform.parent = transform;
Font BroadwayFont = (Font)Resources.Load("Fonts/Arial");
UI_StatusText.font = BroadwayFont;
UI_StatusText.text = "Building_Level1";
UI_StatusText.fontSize=16;
UI_StatusText.material.color = Color.blue;
// GText.material.color = Color.Green;
UI_StatusText.transform.position=new Vector3(0,0,0);
TextCoords = new Vector3(0,0,0);
GameObject CoreGame = GameObject.Find("coreGame");
UI_StatusText.enabled = ( CoreGame.GetComponent("MainGameWorld") as MainGameWorld).bDebugShowMsg_Building;
}
private void UpdateCapacity(BUILDING_TYPE build)
{
switch (build)
{
case BUILDING_TYPE.HOUSE:
currentCapacity = building[PlayerScript.housesLevel].capacity;
break;
case BUILDING_TYPE.REPRODUCTION:
currentCapacity = building[PlayerScript.reproductionHouseLevel].capacity;
break;
case BUILDING_TYPE.FOOD:
currentCapacity = building[PlayerScript.foodBuildingLevel].capacity;
break;
case BUILDING_TYPE.L_DOOR:
currentCapacity = building[PlayerScript.leftDoorLevel].capacity;
break;
case BUILDING_TYPE.R_DOOR:
currentCapacity = building[PlayerScript.rightDoorLevel].capacity;
break;
case BUILDING_TYPE.CHAMAN: // TODO QUE CUESTE SACRIFICIO HUMANO
currentCapacity = building[PlayerScript.chamanLevel].capacity;
break;
case BUILDING_TYPE.SACERDOTE:
currentCapacity = building[PlayerScript.sacerdoteLevel].capacity;
break;
case BUILDING_TYPE.MERCADER:
currentCapacity = building[PlayerScript.mercaderLevel].capacity;
break;
}
return;
}
private BUILDING_TYPE findBuildingType(BUILDING_TYPE buildingChanged, string checkingEntity)
{
switch (checkingEntity)
{
case "50m":
average = 40f;
lowest = 20f;
return(BUILDING_TYPE.small);
case "100m":
average = 60f;
lowest = 20f;
return(BUILDING_TYPE.medium);
case "150m":
average = 90f;
lowest = 40f;
return(BUILDING_TYPE.large);
case "Building":
return(BUILDING_TYPE.aqaduct);
}
return(buildingChanged);
}
//壊れた建物のタイプに応じての処理-----------------------------------------------------
void CrashJudge(BUILDING_TYPE type)
{
if (_crash)
{
return; //一回も壊していなかったら壊す
}
switch (type)
{
case BUILDING_TYPE.SMALL_TYPE_1:
_score_manager.AddScore(ScoreManager.SCORE_TYPE.BUILDING_SMALL_TYPE_1);
break;
case BUILDING_TYPE.SMALL_TYPE_2:
_score_manager.AddScore(ScoreManager.SCORE_TYPE.BUILDING_SMALL_TYPE_2);
break;
case BUILDING_TYPE.BIG_TYPE_1:
_score_manager.AddScore(ScoreManager.SCORE_TYPE.BUILDING_BIG_TYPE_1);
break;
case BUILDING_TYPE.BIG_TYPE_2:
_score_manager.AddScore(ScoreManager.SCORE_TYPE.BUILDING_BIG_TYPE_2);
break;
case BUILDING_TYPE.BIG_TYPE_3:
_score_manager.AddScore(ScoreManager.SCORE_TYPE.BUILDING_BIG_TYPE_3);
break;
default:
break;
}
BuildingCrash( );
_crash = true; //一回壊したらフラグを立てる
}
protected void SetBuildingType(BUILDING_TYPE newBuildingType)
{
buildingType = newBuildingType;
}
public MineBuilding(BUILDING_TYPE penumBuildingType, Faction pmusOwningFaction)
: base(penumBuildingType, pmusOwningFaction)
{
Miners = 0;
MinerCap = mcintInitialMinerCap;
}
public bool CanSupportBuildingType(BUILDING_TYPE type)
{
return(buildingTypeCount[type] < GameManager.instance.maxBuildingTypesDict[type]);
}
public int GetBuildingTypeCount(BUILDING_TYPE type)
{
return(buildingTypeCount[type]);
}
