private void UpdateMesh(BuildingBlueprint plannedBlueprint)
{
if (!this.filter)
{
return;
}
if (!this.meshRenderer)
{
return;
}
GameObject gObj = PrefabLoader.GetPrefab <GameObject>(plannedBlueprint.PrefabPath);
if (gObj == null)
{
logger.Log("Unable to load prefab " + plannedBlueprint.PrefabPath, LogLevel.Warning);
return;
}
MeshFilter filter = Helpers.GetComponent <MeshFilter>(gObj, logger);
if (!filter)
{
return;
}
this.filter.mesh = filter.sharedMesh;
MeshRenderer renderer = Helpers.GetComponent <MeshRenderer>(gObj, logger);
if (!renderer)
{
return;
}
this.meshRenderer.material = renderer.sharedMaterial;
}
private void OnFindBuildPosition(Vector2 pos)
{
BuildingBlueprint building = registry.BuildingRegistry[selectedBuilding];
Instantiate(building, blueprintTransform.transform.position, Quaternion.identity).Initialize();
StopBuildMode();
}
private Dictionary <ResourceType, Dictionary <ResourceType, int> > allHiddenRequirementsCache; // To cache old work
public HiddenRequirement()
{
this.allRequirements = new Dictionary <ResourceType, BuildingRequirements>();
this.allHiddenRequirementsCache = new Dictionary <ResourceType, Dictionary <ResourceType, int> >();
foreach (KeyValuePair <BuildingType, BuildingBlueprint> kvp in BuildingFactory.allBluePrints)
{
// Go through all the buildings
BuildingType bt = kvp.Key;
BuildingBlueprint bluePrint = kvp.Value;
foreach (IResourceProducer buildingOutput in bluePrint.outputResourceProduction)
{
// Consider every output to this building
ResourceType outputResourceType = buildingOutput.targetResource();
if (!allRequirements.ContainsKey(outputResourceType))
{
allRequirements[outputResourceType] = new BuildingRequirements();
}
// the inputs to this building are a "hidden" extra requirement to the outputs so count them
allRequirements[outputResourceType].merge(bluePrint.inputResourceCosts);
}
}
}
public void AddCompletedBuildingToPanel(BuildingBlueprint completedBuilding)
{
GameObject completedBuildingItem = Instantiate(CompletedBuildingItemPrefab);
completedBuildingItem.GetComponent <CompletedBuildingItem>().SetBuilding(completedBuilding);
completedBuildingItem.transform.SetParent(buildingsPanel.transform);
}
static void LoadBuildingBlueprints()
{
// Maybe from an XML file?
BuildingBlueprint bb;
int id = 0;
bb = new BuildingBlueprint(
id,
"Barracks"
);
buildings.Add(id++, bb);
bb = new BuildingBlueprint(
id,
"Granary"
);
buildings.Add(id++, bb);
bb = new BuildingBlueprint(
id,
"Monument"
);
buildings.Add(id++, bb);
bb = new BuildingBlueprint(
id,
"Library"
);
buildings.Add(id++, bb);
}
void OnMouseExit()
{
Debug.Log("Exit");
if (IsPointerOverUIObject())
{
Debug.Log("OPINTUI");
return;
}
if (Input.touchCount > 0)
{
touchPosWorld = Camera.main.ScreenToWorldPoint(Input.GetTouch(0).position);
Vector2 touchPosWorld2D = new Vector2(touchPosWorld.x, touchPosWorld.y);
RaycastHit2D hitInformation = Physics2D.Raycast(touchPosWorld2D, Camera.main.transform.forward);
if (hitInformation.collider != null)
{
Debug.Log(hitInformation.collider.name);
if (hitInformation.collider.name == "Obstacle" | hitInformation.collider.tag == "Building" | hitInformation.collider.tag == "Tree")
{
return;
}
}
}
// if(buildingmanager.GetPositionError() & Building != null)
// return;
if (TempBuilding != null)
{
Debug.Log("---------------------------------------");
Destroy(TempBuilding);
}
if (PreBuilding != null)
{
Debug.Log("Destroy" + PreBuilding.name);
Destroy(PreBuilding);
}
if (Building != null & BuildingManager.isEditMode)
{
Debug.Log("================");
if (BuildingBlueprint == buildingmanager.GetBuilding())
{
Debug.Log("-------------");
if (isNowPointNode)
{
BuildingBlueprint = null;
Destroy(Building);
Debug.Log("Reset" + Building.name);
isNowPointNode = false;
}
}
}
// Debug.Log("!!!");
}
public void SelectBuild(BuildingBase building)
{
if (instantiatedBlueprint)
{
instantiatedBlueprint.DestroySelf();
}
instantiatedBlueprint = Instantiate(blueprintPrefab);
instantiatedBlueprint.SetupBlueprint(building);
}
public static BuildingSite InstantiateNew(BuildingBlueprint blueprint)
{
GameObject prefab = PrefabLoader.GetPrefab <GameObject>(prefabPath);
GameObject gObj = Instantiate(prefab) as GameObject;
BuildingSite site = gObj.GetComponent <BuildingSite>();
site.data.blueprint = blueprint;
return(site);
}
public override void OnStart()
{
builder = baseModule.GetModule <BuilderModule>(ModuleID.Builder);
if (builder != null)
{
Blueprint = builder.TargetBlueprint;
abortTrigger.Value = !builder.TryStartProcess(OnCompleteCallback);
complete = false;
}
}
// Create levels from the floor plan.
public static List <Mesh> CreateBuilding(BuildingBlueprint floorPlan)
{
List <Mesh> levels = new List <Mesh>();
foreach (BuildingBlueprint.Level levelPlan in floorPlan._levels)
{
Mesh level = CreateLevelMesh(levelPlan);
levels.Add(level);
}
return(levels);
}
public void SelectNode(Node node)
{
if (selectedNode == node)
{
DeselectNode();
return;
}
selectedNode = node;
newBuilding = null;
nodeUi.SetTarget(node);
}
public void UpdateCompletedBuildings()
{
ClearCompletedBuildingsPanel();
List <int> completedBuildingIDs = currentCity.GetCompletedBuildings();
foreach (int id in completedBuildingIDs)
{
BuildingBlueprint building = BuildingDatabase.GetBuildingByID(id);
if (building != null)
{
AddCompletedBuildingToPanel(building);
}
}
}
public void OnClick()
{
//todo - get current city production
if (thisBuildingJob == null)
{
BuildingJob buildingJob = null;
if (BuildingBlueprint != null)
{
buildingJob = new BuildingJob(
BuildingBlueprint.name,
BuildingBlueprint.productionCost,
0,
() => {
BuildingBlueprint.OnBuildingComplete(MyCity);
Destroy(gameObject);
},
null
);
}
else if (UnitBlueprint != null)
{
buildingJob = new BuildingJob(
UnitBlueprint.name,
UnitBlueprint.productionCost,
0,
() => {
UnitBlueprint.OnUnitComplete(MyCity);
MyCityScreen.RemoveCompletedUnitFromInProgress(UnitBlueprint, MyCity);
},
null
);
}
thisBuildingJob = buildingJob;
}
MyCity.SetCurrentBuildingJob(thisBuildingJob);
if (MyCityScreen)
{
MyCityScreen.UpdateCurrentProductionText();
}
}
public void Initialize(BuildMenuUI menuUI, BuildingBlueprint blueprint, int id)
{
selected = false;
CloseTooltip();
buildingID = id;
this.menuUI = menuUI;
if (button == null)
{
button = GetComponent <Button>();
}
buildingNameText.text = blueprint.buildingName;
descriptionText.text = blueprint.description;
costText.text = blueprint.costString;
button.onClick.RemoveAllListeners();
button.onClick.AddListener(() =>
{
menuUI.SelectBuildingToBuild(this, buildingID);
});
}
static void LoadBuildingBlueprints()
{
//could possibly load from xml file
BuildingBlueprint bb;
BuildingYieldChange yield;
int id = 0;
//culture test
bb = new BuildingBlueprint(id, "Monument");
yield = new BuildingYieldChange(BuildingYieldChange.YieldType.YIELD_CULTURE, 2);
bb.AddYieldChange(yield);
buildings.Add(id++, bb);
//food test
bb = new BuildingBlueprint(id, "Granary");
yield = new BuildingYieldChange(BuildingYieldChange.YieldType.YIELD_FOOD, 2);
bb.AddYieldChange(yield);
buildings.Add(id++, bb);
//gold test
bb = new BuildingBlueprint(id, "Market");
yield = new BuildingYieldChange(BuildingYieldChange.YieldType.YIELD_GOLD, 2);
bb.AddYieldChange(yield);
yield = new BuildingYieldChange(BuildingYieldChange.YieldType.YIELD_GOLD_PERCENT, .50f);
bb.AddYieldChange(yield);
buildings.Add(id++, bb);
//science test
bb = new BuildingBlueprint(id, "Library");
yield = new BuildingYieldChange(BuildingYieldChange.YieldType.YIELD_SCIENCE, 2);
bb.AddYieldChange(yield);
buildings.Add(id++, bb);
//production test
bb = new BuildingBlueprint(id, "Workshop");
yield = new BuildingYieldChange(BuildingYieldChange.YieldType.YIELD_PRODUCTION, 2);
bb.AddYieldChange(yield);
buildings.Add(id++, bb);
}
void SetBuildNodeInfo(GameObject B, BuildingBlueprint Bluepirnt)
{
Building BuildScript = B.GetComponent <Building>();
int flip = 0;
if (B.GetComponent <SpriteRenderer>().flipX)
{
flip = 1;
}
else if (B.name == "Canoe(Clone)")
{
BuildScript.Foundations[0].transform.position = BuildScript.CanoeNoFlipFoundationPosition.transform.position;
}
Node.SetActive(true);
foreach (GameObject Foundation in BuildScript.Foundations)
{
Collider2D[] colliders2 = Physics2D.OverlapCircleAll(Foundation.transform.position, 1);
foreach (Collider2D collider in colliders2)
{
if (collider.tag == "BuildNode")
{
BuildNode Node = collider.GetComponent <BuildNode>();
BuildScript.SetNode(Node);
Node.Building = B;
Node.BuildingBlueprint = Bluepirnt;
Node.SetOriginInfo(B.transform.position, Bluepirnt, flip);
}
}
}
Node.SetActive(false);
}
public void Build(BuildingBlueprint buildingBlueprint)
{
this.buildingBlueprint = buildingBlueprint;
building = (GameObject)Instantiate(buildingBlueprint.prefab, GetBuildPosition(), Quaternion.identity);
}
public void SelectBuildingToBuild(BuildingBlueprint building)
{
newBuilding = building;
DeselectNode();
}
public void SetBuilding(BuildingBlueprint newBuilding)
{
this.myBuilding = newBuilding;
nameText.text = newBuilding.name;
}
// Use this for initialization
void Start()
{
newBuilding = null;
}
public static IRequest Request(GameState game, BuildingBlueprint blueprint, PositionedFootprint footprint) => new Implementation(game, blueprint, footprint);
public BlueprintIdPair(int id, BuildingBlueprint blueprint)
{
this.id = id;
this.blueprint = blueprint;
}
public Implementation(GameState game, BuildingBlueprint blueprint, PositionedFootprint footprint)
{
this.game = game;
this.blueprint = blueprint;
this.footprint = footprint;
}
public static IEntity CreateBuilding(int x, int y, BuildingBlueprint blueprint, NamelessGame namelessGame, IWorldProvider worldProvider, InternalRandom random)
{
IEntity building = new Entity();
building.AddComponent(new Description("", ""));
building.AddComponent(new Position(x, y));
Building buildingComponent = new Building();
for (int i = 0; i < blueprint.Matrix.Length; i++)
{
for (int j = 0; j < blueprint.Matrix[i].Length; j++)
{
var tile = worldProvider.GetTile(x + j, y + i);
tile.Terrain = TerrainTypes.Road;
tile.Biome = Biomes.None;
var bluepringCell = blueprint.Matrix[i][j];
switch (bluepringCell)
{
case BlueprintCell.Wall:
{
AddToTileAndGame(tile, TerrainFurnitureFactory.WallEntity, namelessGame);
break;
}
case BlueprintCell.Door:
{
IEntity door = CreateDoor(x + j, y + i);
buildingComponent.getBuildingParts().Add(door);
AddToTileAndGame(tile, door, namelessGame);
break;
}
case BlueprintCell.Window:
{
AddToTileAndGame(tile, TerrainFurnitureFactory.WindowEntity, namelessGame);
break;
}
case BlueprintCell.Bed:
{
AddToTileAndGame(tile, TerrainFurnitureFactory.BedEntity, namelessGame);
break;
}
case BlueprintCell.IndoorsFurniture:
{
AddToTileAndGame(tile, TerrainFurnitureFactory.BedEntity, namelessGame);
break;
}
}
}
}
{
//BSPTree tree = new BSPTree(new Rectangle(x,y,width,height));
//tree.Split(random,3);
//{
// BSPTree child = tree.ChildA;
// for (int i = 0; i < child.Bounds.Width; i++)
// {
// for (int j = 0; j < child.Bounds.Height; j++)
// {
// var tile = worldProvider.GetTile(child.Bounds.X + i, child.Bounds.Y + j);
// tile.Terrain = TerrainLibrary.Terrains[TerrainTypes.Road];
// tile.Biome = BiomesLibrary.Biomes[Biomes.None];
// if (i == 0 || j == 0 || i == child.Bounds.Width - 1 || j == child.Bounds.Height - 1)
// {
// if (i == child.Bounds.Width / 2)
// {
// IEntity door = CreateDoor(child.Bounds.X + i, child.Bounds.Y + j);
// buildingComponent.getBuildingParts().Add(door);
// namelessGame.GetEntities().Add(door);
// tile.getEntitiesOnTile().Add((Entity)door);
// }
// else
// {
// tile.getEntitiesOnTile().Add(TerrainFurnitureFactory.WallEntity);
// }
// }
// }
// }
//}
//{
// BSPTree child = tree.ChildB;
// for (int i = 0; i < child.Bounds.Width; i++)
// {
// for (int j = 0; j < child.Bounds.Height; j++)
// {
// var tile = worldProvider.GetTile(child.Bounds.X + i, child.Bounds.Y + j);
// tile.Terrain = TerrainLibrary.Terrains[TerrainTypes.Road];
// tile.Biome = BiomesLibrary.Biomes[Biomes.None];
// if (i == 0 || j == 0 || i == child.Bounds.Width - 1 || j == child.Bounds.Height - 1)
// {
// if (i == child.Bounds.Width / 2)
// {
// IEntity door = CreateDoor(child.Bounds.X + i, child.Bounds.Y + j);
// buildingComponent.getBuildingParts().Add(door);
// namelessGame.GetEntities().Add(door);
// tile.getEntitiesOnTile().Add((Entity)door);
// }
// else
// {
// tile.getEntitiesOnTile().Add(TerrainFurnitureFactory.WallEntity);
// }
// }
// }
// }
//}
}
building.AddComponent(buildingComponent);
return building;
}
void BuildMemory()
{
if (!isReadyToUpdate)
{
return;
}
/* if(buildingData.CanInsFireCamp == 1)
* {
* FireCampUI.BuildingCanvas.SetActive(false);
* FireCampUI.BuildingUpgradedCanvas.SetActive(true);
* FireIllustrationBlock.SetActive(false);
* if(buildingData.FireCampUnlock == 1)
* FireCampToInstantiate = FireCampUI.BuildingPrefab;
* else
* {
* FireCampUI.BuildingBlock.SetActive(true);
* FireCampToInstantiate = FireCampUI.BuildingUpgradedPrefab;
* }
* Vector3 Fposition = new Vector3(buildingData.FirecampPosX,buildingData.FirecampPosY,buildingData.FirecampPosZ);
* GameObject B = Instantiate(FireCampToInstantiate,Fposition,Quaternion.identity);
* if(buildingData.FireCampFlip == 1)
* B.GetComponent<SpriteRenderer>().flipX = true;
* SetBuildNodeInfo(B,Fposition,FireCampUI.Blueprint);
* FireCampInsed = true;
* }
* buildingData.CanInsFireCamp = 0;*/
if (FireCampLevel1 & !FireCampInsed)
{
IM.UnlockFireIllustration();
FireCampUI.BuildingCanvas.SetActive(false);
FireCampUI.BuildingUpgradedCanvas.SetActive(true);
GameObject B = Instantiate(FireCampToInstantiate, Fposition, Quaternion.identity);
B.GetComponent <Building>().AssignBuildingManager(buildingmanager);
if (FFlip)
{
B.GetComponent <SpriteRenderer>().flipX = true;
}
SetBuildNodeInfo(B, FireCampUI.Blueprint);
FireCampInsed = true;
}
else if (FireCampLevel2 & !FireCampInsed)
{
IM.UnlockLavaIllustration();
FireCampUI.BuildingCanvas.SetActive(false);
FireCampUI.BuildingUpgradedCanvas.SetActive(false);
FireCampUI.BuildingBlock.SetActive(true);
GameObject B = Instantiate(FireCampToInstantiate, Fposition, Quaternion.identity);
B.GetComponent <Building>().AssignBuildingManager(buildingmanager);
if (FFlip)
{
B.GetComponent <SpriteRenderer>().flipX = true;
}
SetBuildNodeInfo(B, FireCampUI.UpBlueprint);
FireCampInsed = true;
}
if (IceHouseLevel1 & !IceHouseInsed)
{
IM.UnlockIceIllustration();
IceHouseUI.BuildingCanvas.SetActive(false);
IceHouseUI.BuildingUpgradedCanvas.SetActive(true);
GameObject B = Instantiate(IceHouseToInstantiate, Iposition, Quaternion.identity);
B.GetComponent <Building>().AssignBuildingManager(buildingmanager);
if (IFlip)
{
B.GetComponent <SpriteRenderer>().flipX = true;
}
SetBuildNodeInfo(B, IceHouseUI.Blueprint);
IceHouseInsed = true;
}
else if (IceHouseLevel2 & !IceHouseInsed)
{
IM.UnlockSnowIllustration();
IceHouseUI.BuildingCanvas.SetActive(false);
IceHouseUI.BuildingUpgradedCanvas.SetActive(false);
IceHouseUI.BuildingBlock.SetActive(true);
GameObject B = Instantiate(IceHouseToInstantiate, Iposition, Quaternion.identity);
B.GetComponent <Building>().AssignBuildingManager(buildingmanager);
if (IFlip)
{
B.GetComponent <SpriteRenderer>().flipX = true;
}
SetBuildNodeInfo(B, IceHouseUI.UpBlueprint);
IceHouseInsed = true;
}
if (HolyChurchLevel1 & !HolyChurchInsed)
{
IM.UnlockHolyIllustration();
HolyChurchUI.BuildingCanvas.SetActive(false);
HolyChurchUI.BuildingUpgradedCanvas.SetActive(true);
GameObject B = Instantiate(HolyChurchToInstantiate, Hposition, Quaternion.identity);
B.GetComponent <Building>().AssignBuildingManager(buildingmanager);
if (HFlip)
{
B.GetComponent <SpriteRenderer>().flipX = true;
}
SetBuildNodeInfo(B, HolyChurchUI.Blueprint);
HolyChurchInsed = true;
}
else if (HolyChurchLevel2 & !HolyChurchInsed)
{
IM.UnlockMoneyIllustration();
HolyChurchUI.BuildingCanvas.SetActive(false);
HolyChurchUI.BuildingUpgradedCanvas.SetActive(false);
HolyChurchUI.BuildingBlock.SetActive(true);
GameObject B = Instantiate(HolyChurchToInstantiate, Hposition, Quaternion.identity);
B.GetComponent <Building>().AssignBuildingManager(buildingmanager);
if (IFlip)
{
B.GetComponent <SpriteRenderer>().flipX = true;
}
SetBuildNodeInfo(B, HolyChurchUI.UpBlueprint);
HolyChurchInsed = true;
}
if (CaveUnlock & !CaveInsed)
{
GameObject B = Instantiate(Cave, Cposition, Quaternion.identity);
CavePop.transform.position = B.transform.position + new Vector3(0, 5, 0);
CavePop.transform.parent = B.transform;
B.GetComponent <Building>().AssignBuildingManager(buildingmanager);
if (CFlip)
{
B.GetComponent <SpriteRenderer>().flipX = true;
}
SetBuildNodeInfo(B, CaveBlueprint);
CaveInsed = true;
}
if (WareHouseUnlock & !WareHouseInsed)
{
GameObject B = Instantiate(WareHouseBlueprint.Building, WareHouseposition, Quaternion.identity);
WareHousePop.transform.position = B.transform.position + new Vector3(0, 5, 0);
WareHousePop.transform.parent = B.transform;
B.GetComponent <Building>().AssignBuildingManager(buildingmanager);
if (WareHouseFlip)
{
B.GetComponent <SpriteRenderer>().flipX = true;
}
SetBuildNodeInfo(B, WareHouseBlueprint);
WareHouseInsed = true;
}
if (CanoeUnlock & !CanoeInsed)
{
GameObject B = Instantiate(CanoeBlueprint.Building, Canoeposition, Quaternion.identity);
CanoePop.transform.position = B.transform.position + new Vector3(0, 5, 0);
CanoePop.transform.parent = B.transform;
B.GetComponent <Building>().AssignBuildingManager(buildingmanager);
if (CanoeFlip)
{
B.GetComponent <SpriteRenderer>().flipX = true;
}
else
{
B.GetComponent <SpriteRenderer>().flipX = false;
}
SetBuildNodeInfo(B, CanoeBlueprint);
CanoeInsed = true;
}
if (HasTree & !TreeInsed)
{
for (int i = 0; i < TreeType.Count; i++)
{
if (TreeType[i] == "\"NormalTree\"")
{
TreeToIns = NormalTree;
TreeBlueprint = NormalTreeBlueprint;
}
else if (TreeType[i] == "\"MintTree\"")
{
TreeToIns = MintTree;
TreeBlueprint = MintTreeBlueprint;
}
else if (TreeType[i] == "\"PinkTree\"")
{
TreeToIns = PinkTree;
TreeBlueprint = PinkTreebBlueprint;
}
else if (TreeType[i] == "\"GrapeTree\"")
{
TreeToIns = GrapeTree;
TreeBlueprint = GrapeTreeBlueprint;
}
else if (TreeType[i] == "\"PuddingTree\"")
{
TreeToIns = PuddingTree;
TreeBlueprint = PuddingTreeBlueprint;
}
else if (TreeType[i] == "\"TrebleTree\"")
{
TreeToIns = TrebleTree;
TreeBlueprint = TrebleTreeBlueprint;
}
else if (TreeType[i] == "\"GreenTree\"")
{
TreeToIns = GreenTree;
TreeBlueprint = GreenTreeBlueprint;
}
else if (TreeType[i] == "\"RustTree\"")
{
TreeToIns = RustTree;
TreeBlueprint = RustTreeBlueprint;
}
else if (TreeType[i] == "\"RustForest\"")
{
TreeToIns = RustForest;
TreeBlueprint = RustForestBlueprint;
}
else if (TreeType[i] == "\"Fir\"")
{
TreeToIns = Fir;
TreeBlueprint = FirBlueprint;
}
else if (TreeType[i] == "\"LittleFirForest\"")
{
TreeToIns = LittleFirForest;
TreeBlueprint = LittleFirForestBlueprint;
}
else if (TreeType[i] == "\"FirForest\"")
{
TreeToIns = FirForest;
TreeBlueprint = FirForestBlueprint;
}
else if (TreeType[i] == "\"DreamForest\"")
{
TreeToIns = DreamForest;
TreeBlueprint = DreamForestBlueprint;
}
else if (TreeType[i] == "\"LittleForest\"")
{
TreeToIns = LittleForest;
TreeBlueprint = LittleForestBlueprint;
}
else if (TreeType[i] == "\"ChristmasTree\"")
{
TreeToIns = ChristmasTree;
TreeBlueprint = ChristmasTreeBlueprint;
}
Vector3 TreePos = new Vector3(TreePosX[i], TreePosY[i], TreePosZ[i]);
GameObject B = Instantiate(TreeToIns, TreePos, Quaternion.identity);
Building BScript = B.GetComponent <Building>();
BScript.AssignBuildingManager(buildingmanager);
BScript.SetTreeType(TreeBlueprint.Building.name);
if (TreeFlip[i] == "1")
{
B.GetComponent <SpriteRenderer>().flipX = true;
}
B.name = TreeName[i];
Vector3 RayCastPos = TreePos;
RayCastPos.y -= 5;
SetBuildNodeInfo(B, TreeBlueprint);
BScript.GetNode().SetOriginTreeName(TreeName[i]);
}
TreeInsed = true;
}
if (CanInsStoredBuildingButton & !StoredBuildingButtonInsed)
{
int SBuildingNum = 0;
foreach (string name in StroedBuildingName)
{
GameObject Button = Instantiate(StoredBuildingButtonPrefab, LastButtonPosition, Quaternion.identity);
Button.transform.parent = Parent.transform;
Button.transform.localScale = new Vector3(1, 1, 1);
Button.GetComponent <RectTransform>().anchoredPosition = new Vector2(-975 + (buildingmanager.GetStoredBuildingButtonsList().Count - 1) * 170, -12);
buildingmanager.SetLastStoredPosition(LastButtonPosition);
LastButtonPosition = Button.GetComponent <RectTransform>().anchoredPosition;
// Button.transform.localPosition = LastButtonPosition;
Vector3 temp = LastButtonPosition;
temp.x += 170;
LastButtonPosition = temp;
StoredBuilding SB = Button.GetComponent <StoredBuilding>();
DM.UpdateButton(name, StoredBuildingNum[SBuildingNum]);
SB.NumberText.text = StoredBuildingNum[SBuildingNum++].ToString();
SB.SetBM(buildingmanager);
buildingmanager.AddStoredBuildingButtons(SB);
SB.SetNumThisEdit();
if (name == "NormalTree")
{
SB.BuildingImg.sprite = NormalTree.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(NormalTree);
SB.SetBlueprint(buildingmanager.NormalTree);
}
else if (name == "MintTree")
{
SB.BuildingImg.sprite = MintTree.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(MintTree);
SB.SetBlueprint(buildingmanager.MintTree);
}
else if (name == "PinkTree")
{
SB.BuildingImg.sprite = PinkTree.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(PinkTree);
SB.SetBlueprint(buildingmanager.PinkTree);
}
else if (name == "GrapeTree")
{
SB.BuildingImg.sprite = GrapeTree.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(GrapeTree);
SB.SetBlueprint(buildingmanager.GrapeTree);
}
else if (name == "PuddingTree")
{
SB.BuildingImg.sprite = PuddingTree.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(PuddingTree);
SB.SetBlueprint(buildingmanager.PuddingTree);
}
else if (name == "TrebleTree")
{
SB.BuildingImg.sprite = TrebleTree.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(TrebleTree);
SB.SetBlueprint(buildingmanager.TrebleTree);
}
else if (name == "GreenTree")
{
SB.BuildingImg.sprite = GreenTree.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(GreenTree);
SB.SetBlueprint(buildingmanager.GreenTree);
}
else if (name == "RustTree")
{
SB.BuildingImg.sprite = RustTree.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(RustTree);
SB.SetBlueprint(buildingmanager.DeadTree);
}
else if (name == "RustForest")
{
SB.BuildingImg.sprite = RustForest.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(RustForest);
SB.SetBlueprint(buildingmanager.DeadTreeFroest);
}
else if (name == "Fir")
{
SB.BuildingImg.sprite = Fir.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(Fir);
SB.SetBlueprint(buildingmanager.Fir);
}
else if (name == "LittleFirForest")
{
SB.BuildingImg.sprite = LittleFirForest.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(LittleFirForest);
SB.SetBlueprint(buildingmanager.LittleFir);
}
else if (name == "FirForest")
{
SB.BuildingImg.sprite = FirForest.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(FirForest);
SB.SetBlueprint(buildingmanager.FirFroest);
}
else if (name == "DreamForest")
{
SB.BuildingImg.sprite = DreamForest.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(DreamForest);
SB.SetBlueprint(buildingmanager.DreamFroest);
}
else if (name == "LittleForest")
{
SB.BuildingImg.sprite = LittleForest.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(LittleForest);
SB.SetBlueprint(buildingmanager.LittleFroest);
}
else if (name == "ChristmasTree")
{
SB.BuildingImg.sprite = ChristmasTree.GetComponent <SpriteRenderer>().sprite;
SB.AssignBuilding(ChristmasTree);
SB.SetBlueprint(buildingmanager.ChristmasTree);
}
SB.SetTreeType();
}
StoredBuildingButtonInsed = true;
}
if (isFinishTutor == 0)
{
Tutor.gameObject.SetActive(true);
if (isFinishEgg == 1)
{
Tutor.EggStart();
}
else
{
Tutor.GoTutor();
}
isFinishTutor = 2;
}
isReadyToUpdate = false;
CancelInvoke();
Debug.Log("Start BM");
PMM.StartAttatchDB();
}
public void SetOriginInfo(Vector3 position, BuildingBlueprint B, int flip)
{
this.flip = flip;
OriginPos = position;
OriginBlueprint = B;
}
public void SetBlueprint(BuildingBlueprint B)
{
Blueprint = B;
}
public void SelectBuildingToBuild(BuildingBlueprint buildingBlueprint)
{
buildingToBuild = buildingBlueprint;
}
public BuildingClickHandler(BuildingBlueprint blueprint)
{
this.blueprint = blueprint;
}
