public void FarmObjectSale()
{
Spawner._instance.farmObjects.RemoveAt(InputManager.farmObjectIndex);
foreach (FarmObject farmObject in Spawner._instance.farmObjects)
{
if (farmObject.farmObjectIndex >= InputManager.farmObjectIndex)
{
farmObject.farmObjectIndex--;
}
}
for (int i = InputManager.inventorySlotNumber; i < inventorySlotNum; i++)
{
Image invenSlotImage = inventoryContents.transform.GetChild(i).gameObject.GetComponent <Image>();
Image nextInvenSlotImage = inventoryContents.transform.GetChild(i + 1).gameObject.GetComponent <Image>();
invenSlotImage.sprite = nextInvenSlotImage.sprite;
FarmObject invenSlotFarmOb = inventoryContents.transform.GetChild(i).gameObject.GetComponent <FarmObject>();
FarmObject nextInvenSlotFarmOb = inventoryContents.transform.GetChild(i + 1).gameObject.GetComponent <FarmObject>();
invenSlotFarmOb.farmObjectIndex = nextInvenSlotFarmOb.farmObjectIndex;
invenSlotFarmOb.farmObjectNumber = nextInvenSlotFarmOb.farmObjectNumber;
}
inventorySlotNum--;
DataManager._instance.ParseFarmObjectData(Spawner._instance.farmObjects);
MoneyManager.MoneyUP((InputManager.farmObjectNumber + 1) * 5);
saleButton.SetActive(false);
arrangeButton.SetActive(false);
}
public void StoreFarmObject(FarmObject farmObject)
{
Vector3 localPosition = farmObject.gameObject.transform.localPosition;
localPosition.y = 8000f;
farmObject.gameObject.transform.localPosition = localPosition;
}
private bool SetFarmObjectOfEditModeAndDragState(FarmObject farmObject, Vector3 farmObjectPos)
{
FarmObjectSetting component = base.GetComponent <FarmObjectSetting>();
bool flag = component.SetEditFarmObject(farmObject, farmObjectPos);
if (flag && farmObject.isPlaceable)
{
FarmObjectSelect component2 = base.GetComponent <FarmObjectSelect>();
component.ComplatedSetting();
component2.SetSelectObject(farmObject.gameObject);
if (null != FarmRoot.Instance.farmUI && !this.IsExistStoreFacility())
{
FarmRoot.Instance.farmUI.EnableEditSaveButton(true);
}
}
else
{
FarmObjectEdit component3 = base.GetComponent <FarmObjectEdit>();
component3.StartEdit(farmObject);
}
if (null != FarmRoot.Instance.farmUI)
{
FarmRoot.Instance.farmUI.EnableEditStoreButton(true);
}
return(flag);
}
public void SaveResponseToFacilityBuild(int userFacilityID)
{
FarmRoot instance = FarmRoot.Instance;
FarmObjectSetting component = base.GetComponent <FarmObjectSetting>();
instance.ResetSettingMark();
component.farmObject.DisplayFloorObject();
instance.SetActiveNotTouchObject(true);
FarmObject farmObject = component.farmObject;
FarmGrid.GridPosition gridPosition = component.ComplatedSetting();
farmObject.userFacilityID = userFacilityID;
UserFacility facility = this.StartBuild(farmObject, gridPosition);
Singleton <UserDataMng> .Instance.AddUserFacility(facility);
this.farmObjects.Add(farmObject);
FacilityM facilityMaster = FarmDataManager.GetFacilityMaster(farmObject.facilityID);
FarmUtility.PayCost(facilityMaster.buildingAssetCategoryId1, facilityMaster.buildingAssetNum1);
if (0 < int.Parse(facilityMaster.buildingTime) || int.Parse(facilityMaster.autoBuildingFlg) == 0)
{
this.StartConstruction(userFacilityID);
}
else
{
farmObject.BuildComplete();
}
}
private UserFacility StartBuild(FarmObject farmObject, FarmGrid.GridPosition gridPosition)
{
FacilityM facilityMaster = FarmDataManager.GetFacilityMaster(farmObject.facilityID);
int num = int.Parse(facilityMaster.buildingTime);
string text = null;
if (facilityMaster.autoBuildingFlg == "0")
{
text = ServerDateTime.Now.ToString();
}
if (0 < num)
{
DateTime time = ServerDateTime.Now.AddSeconds((double)num + 1.0);
text = FarmUtility.GetDateString(time);
}
return(new UserFacility
{
userFacilityId = farmObject.userFacilityID,
facilityId = farmObject.facilityID,
positionX = gridPosition.x,
positionY = gridPosition.y,
level = ((text != null) ? 0 : 1),
completeTime = text
});
}
void FarmObjectBuy()
{
FarmObject productFarmObject = product.GetComponent <FarmObject>();
FarmObject shopFarmObject;
shopFarmObject = gameObject.GetComponent <FarmObject>();
Debug.Log(shopFarmObject.shopCost);
Debug.Log(DataManager._instance.playerData.money);
if (shopFarmObject.shopCost < DataManager._instance.playerData.money)
{
Debug.Log(gameObject.name);
productImage = GameObject.Find("arrangeImage");
product = gameObject.GetComponent <ShopButtonManager>().product;
ShopButtonManager productImgSBM = productImage.GetComponent <ShopButtonManager>();
productImgSBM.product = product;
image = productImage.GetComponent <Image>();
image.sprite = shopFarmObject.farmObjectSprite;
FarmObject productImageFarmObject = productImage.GetComponent <FarmObject>();
productImageFarmObject.farmObjectNumber = shopFarmObject.farmObjectNumber;
productImageFarmObject.shopCost = shopFarmObject.shopCost;
Drag PIDrag = productImage.GetComponent <Drag>();
PIDrag.PItransformMid();
OKButton.gameObject.SetActive(true);
cancelButton.gameObject.SetActive(true);
shopList.SetActive(false);
shopCloseButton.SetActive(false);
}
}
public void ResetSelectedFarmObject()
{
FarmRoot instance = FarmRoot.Instance;
this.SetFacilityButton(false, instance);
instance.ResetSelectMark();
FarmObjectSetting component = base.GetComponent <FarmObjectSetting>();
if (null != component.farmObject)
{
component.CancelMove();
instance.ResetSettingMark();
this.farmObject.DisplayFloorObject();
if (instance.farmMode == FarmRoot.FarmControlMode.NORMAL)
{
instance.SetActiveNotTouchObject(true);
}
else
{
if (!instance.Scenery.IsExistStoreFacility())
{
instance.farmUI.EnableEditSaveButton(true);
}
instance.farmUI.EnableEditStoreButton(true);
}
}
this.selectUserFacilityID = -1;
this.farmObject = null;
instance.Input.RemoveTouchDragEvent(new Func <InputControll, bool>(this.OnDrag));
this.RemoveTouchDragEventForFriendFarm();
}
public FarmObjectSetting.ExtendBuildPositionSearchResult SearchExtendBuildGrid(FarmObject oneBeforeFarmObject)
{
FarmScenery scenery = FarmRoot.Instance.Scenery;
FarmObjectSetting.PriorityDirection priorityDirection = FarmObjectSetting.PriorityDirection.FRONT;
FarmObject farmObject = null;
if (2 <= scenery.farmObjects.Count)
{
farmObject = scenery.farmObjects[scenery.farmObjects.Count - 2];
}
UserFacility userFacility = Singleton <UserDataMng> .Instance.GetUserFacility(oneBeforeFarmObject.userFacilityID);
if (null != farmObject && farmObject.facilityID == oneBeforeFarmObject.facilityID)
{
UserFacility userFacility2 = Singleton <UserDataMng> .Instance.GetUserFacility(farmObject.userFacilityID);
int num = userFacility2.positionX - userFacility.positionX;
int num2 = userFacility2.positionY - userFacility.positionY;
bool flag = Mathf.Abs(num) > Mathf.Abs(num2);
if (flag)
{
priorityDirection = ((0 <= num) ? FarmObjectSetting.PriorityDirection.LEFT : FarmObjectSetting.PriorityDirection.RIGHT);
}
else
{
priorityDirection = ((0 <= num2) ? FarmObjectSetting.PriorityDirection.REAR : FarmObjectSetting.PriorityDirection.FRONT);
}
}
return(this.GetExtendBuildGrid(oneBeforeFarmObject, userFacility, priorityDirection));
}
void FarmObjectOK()
{
shopList.SetActive(true);
productImage = GameObject.Find("arrangeImage");
int putable = 0;
for (int i = 0; i < farmAnimal.transform.childCount; i++)
{
//Debug.Log("동물" + i + "번 : " + farmAnimal.transform.GetChild(i).transform.position.x);
//Debug.Log("productImage : " + productImage.transform.position.x);
//Debug.Log(i+"번 차이 : "+Mathf.Abs(farmAnimal.transform.GetChild(i).transform.position.x - productImage.transform.position.x));
//Debug.Log(i+"번 차이 : "+ Mathf.Abs(farmAnimal.transform.GetChild(i).transform.position.y - productImage.transform.position.y));
if (Mathf.Abs(farmAnimal.transform.GetChild(i).transform.position.x - productImage.transform.position.x) > 3 || Mathf.Abs(farmAnimal.transform.GetChild(i).transform.position.y - productImage.transform.position.y) > 3)
{
putable++;
}
}
for (int i = 0; i < farmFarmObject.transform.childCount; i++)
{
//Debug.Log("설치물" + i + "번 : " + farmFarmObject.transform.GetChild(i).transform.position.x);
//Debug.Log("productImage : " + productImage.transform.position.x);
//Debug.Log(i + "번 차이 : " + Mathf.Abs(farmFarmObject.transform.GetChild(i).transform.position.x - productImage.transform.position.x));
//Debug.Log(i + "번 차이 : " + Mathf.Abs(farmFarmObject.transform.GetChild(i).transform.position.y - productImage.transform.position.y));
if (Mathf.Abs(farmFarmObject.transform.GetChild(i).transform.position.x - productImage.transform.position.x) > 3 || Mathf.Abs(farmFarmObject.transform.GetChild(i).transform.position.y - productImage.transform.position.y) > 3)
{
putable++;
}
}
//Debug.Log("농장동물"+farmAnimal.transform.childCount+"마리");
//Debug.Log("농장설치물"+farmFarmObject.transform.childCount+"개");
//Debug.Log(putable);
if (putable == farmAnimal.transform.childCount + farmFarmObject.transform.childCount)
{
text.gameObject.SetActive(false);
ShopButtonManager productSBM = productImage.GetComponent <ShopButtonManager>();
product = productSBM.product;
FarmObject productFarmObject = product.GetComponent <FarmObject>();
producted = Instantiate(productSBM.product, new Vector2(productImage.transform.position.x, productImage.transform.position.y), Quaternion.identity);
producted.transform.parent = farmFarmObject.transform;
Drag PIDrag = productImage.GetComponent <Drag>();
PIDrag.PItransformBack();
FarmObject productedObject = producted.GetComponent <FarmObject>();
productedObject.farmObjectIndex = Spawner._instance.farmObjects.Count;
productedObject.isField = true;
OKButton.gameObject.SetActive(false);
cancelButton.gameObject.SetActive(false);
shopCloseButton.SetActive(true);
MoneyManager.money -= productedObject.shopCost;
DataManager._instance.SaveMoney(MoneyManager.money, MoneyManager.heart);
Spawner._instance.BuyNewFarmObject(producted);
DataManager._instance.ParseFarmObjectData(Spawner._instance.farmObjects);
for (int i = 0; i < farmAnimal.transform.childCount; i++)
{
AnimalController animalController = farmAnimal.transform.GetChild(i).GetComponent <AnimalController>();
animalController.pathStart();
}
}
}
private FarmObjectSetting.ExtendBuildPositionSearchResult GetExtendBuildGrid(FarmObject oneBeforeFarmObject, UserFacility oneBeforeUserFacility, FarmObjectSetting.PriorityDirection priorityDirection)
{
FarmGrid.GridPosition gridPosition = new FarmGrid.GridPosition
{
x = oneBeforeUserFacility.positionX,
y = oneBeforeUserFacility.positionY
};
FarmObjectSetting.ExtendBuildPositionSearchInfo extendBuildPositionSearchInfo = new FarmObjectSetting.ExtendBuildPositionSearchInfo
{
farmField = FarmRoot.Instance.Field,
field = FarmRoot.Instance.Field.GetField(),
oneBeforeFarmObject = oneBeforeFarmObject,
aroundCount = 1,
aroundX = oneBeforeFarmObject.sizeX,
aroundY = oneBeforeFarmObject.sizeY,
priorityDirection = priorityDirection,
originGrid = gridPosition,
resultGrid = gridPosition
};
while (!this.SearchExtendBuildGrid(extendBuildPositionSearchInfo))
{
if (extendBuildPositionSearchInfo.isOutsideMap)
{
break;
}
extendBuildPositionSearchInfo.aroundCount++;
extendBuildPositionSearchInfo.aroundX = oneBeforeFarmObject.sizeX + extendBuildPositionSearchInfo.aroundCount;
extendBuildPositionSearchInfo.aroundY = oneBeforeFarmObject.sizeY + extendBuildPositionSearchInfo.aroundCount;
}
return(new FarmObjectSetting.ExtendBuildPositionSearchResult
{
grid = extendBuildPositionSearchInfo.resultGrid,
isOutsideMap = extendBuildPositionSearchInfo.isOutsideMap
});
}
private void OnTouchUp(InputControll inputControll, bool isDraged)
{
if (!isDraged)
{
if (this.farmObject.gameObject != inputControll.rayHitColliderObject)
{
FarmObjectSelect component = base.GetComponent <FarmObjectSelect>();
this.CancelEdit();
component.EnabledTouchedEvent(true);
}
}
else if (this.farmObject.isPlaceable)
{
FarmRoot instance = FarmRoot.Instance;
FarmScenery component2 = base.GetComponent <FarmScenery>();
FarmObjectSelect component3 = base.GetComponent <FarmObjectSelect>();
FarmObjectSetting component4 = base.GetComponent <FarmObjectSetting>();
instance.ResetSettingMark();
this.farmObject.DisplayFloorObject();
component4.ComplatedSetting();
component3.SetSelectObject(this.farmObject.gameObject);
this.farmObject = null;
component3.EnabledTouchedEvent(true);
instance.Input.RemoveTouchEndEvent(new Action <InputControll, bool>(this.OnTouchUp));
if (!component2.IsExistStoreFacility())
{
instance.farmUI.EnableEditSaveButton(true);
}
}
}
public void DragCreate()
{
FarmRoot instance = FarmRoot.Instance;
if (null == instance)
{
global::Debug.LogError("FarmRoot Not Found");
return;
}
if (0 >= this.farmObjects.Count)
{
global::Debug.LogError("0 == this.farmObjects.Count");
return;
}
instance.ClearSettingFarmObject();
FarmObject farmObject = this.farmObjects[0];
Camera componentInChildren = instance.GetComponentInChildren <Camera>();
Vector3 vector = componentInChildren.ScreenToWorldPoint(Input.mousePosition);
FarmEditFacilityList componentInParent = base.GetComponentInParent <FarmEditFacilityList>();
if (!componentInParent.StartSettingAndDragState(farmObject, vector))
{
vector = componentInChildren.ScreenToWorldPoint(Input.mousePosition);
farmObject.transform.position = vector;
}
GUIManager.ResetTouchingCount();
}
public bool BuildFarmObject(int facilityID)
{
FarmObject farmObject = this.FindFarmObjectByFacilityId(facilityID);
FarmObject farmObject2;
if (null == farmObject)
{
farmObject2 = this.LoadFarmObject(facilityID);
}
else
{
farmObject2 = this.DuplicateFarmObject(farmObject);
}
if (null == farmObject2)
{
return(false);
}
farmObject2.facilityID = facilityID;
FarmObjectSetting component = base.GetComponent <FarmObjectSetting>();
bool flag = component.SetFarmObject(farmObject2, this.GetScreenCenterPoint());
if (flag)
{
GUICameraControll component2 = FarmRoot.Instance.Camera.GetComponent <GUICameraControll>();
if (null != component2)
{
Vector3 baseGridPosition3D = component.farmObject.GetBaseGridPosition3D();
base.StartCoroutine(component2.MoveCameraToLookAtPoint(baseGridPosition3D, 0f));
}
}
return(true);
}
public IEnumerator Initialize(FarmResource re)
{
resource = re;
farmObject = resource.origin;
// Set name and location
name = resource.resourceType;
location = farmObject.name;
nameDisplay.text = name;
locationDisplay.text = location;
//print (resource.resourceType);
icon.sprite = sensorDisplayManager.icons [resource.resourceType.ToLower()];
// Create all sensing points
foreach (FarmSensor sensor in resource.sensorsList)
{
foreach (FarmSensingPoint point in sensor.farmSensingPoints)
{
yield return(StartCoroutine("AddSensingPoint", point));
}
}
transform.localScale = new Vector3(1, 1, 1);
yield return(StartCoroutine("UpdateSize"));
yield return(null);
}
private void Start()
{
FarmRoot instance = FarmRoot.Instance;
this.farmObject = instance.SettingObject.farmObject;
this.farmCamera = instance.Camera;
GUIScreenHome.enableBackKeyAndroid = false;
}
public int CountDown(FarmObject farmObject)
{
this.farmObjects.Remove(farmObject);
int count = this.farmObjects.Count;
this.countLabel.text = string.Format(StringMaster.GetString("FarmEditButtonCount"), count.ToString());
return(count);
}
private FarmObject DuplicateFarmObject(FarmObject src)
{
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(src.gameObject);
gameObject.transform.parent = base.transform;
gameObject.transform.localScale = Vector3.one;
gameObject.transform.localEulerAngles = Vector3.zero;
return(gameObject.GetComponent <FarmObject>());
}
public void AddNewFarmObject(GameObject farmObject)
{
FarmObject farmObjectOb = farmObject.GetComponent <FarmObject>();
Rigidbody2D farmObjectRB = farmObject.GetComponent <Rigidbody2D>();
farmObjectOb.posX = farmObjectRB.position.x;
farmObjectOb.posY = farmObjectRB.position.y;
farmObjects.Add(farmObjectOb);
}
public void ArrangeOk()
{
int putable = 0;
for (int i = 0; i < farmAnimal.transform.childCount; i++)
{
if (Mathf.Abs(farmAnimal.transform.GetChild(i).transform.position.x - arrangeImage.transform.position.x) > 3 || Mathf.Abs(farmAnimal.transform.GetChild(i).transform.position.y - arrangeImage.transform.position.y) > 3)
{
putable++;
}
}
for (int i = 0; i < farmObjects.transform.childCount; i++)
{
if (Mathf.Abs(farmObjects.transform.GetChild(i).transform.position.x - arrangeImage.transform.position.x) > 3 || Mathf.Abs(farmObjects.transform.GetChild(i).transform.position.y - arrangeImage.transform.position.y) > 3)
{
putable++;
}
}
if (putable == farmAnimal.transform.childCount + farmObjects.transform.childCount)
{
inventory.SetActive(true);
putButton.SetActive(false);
cancelButton.SetActive(false);
Spawner._instance.farmObjects[InputManager.farmObjectIndex].harvestTime = System.DateTime.Now;
GameObject arranged = Instantiate(invenItems[InputManager.farmObjectNumber], new Vector2(arrangeImage.transform.position.x, arrangeImage.transform.position.y), Quaternion.identity);
FarmObjectController farmObjectController = arranged.GetComponent <FarmObjectController>();
FarmObject farmObject = arranged.GetComponent <FarmObject>();
farmObject.harvestTime = System.DateTime.Now;
farmObjectController.state = FarmObjectController.State.producing;
SpriteRenderer spriteRenderer = farmObjectController.GetComponent <SpriteRenderer>();
spriteRenderer.sprite = farmObjectController.producingSprite;
arranged.transform.parent = farmObjects.transform;
Spawner._instance.farmObjects[InputManager.farmObjectIndex].posX = arrangeImage.transform.position.x;
Spawner._instance.farmObjects[InputManager.farmObjectIndex].posY = arrangeImage.transform.position.y;
Spawner._instance.farmObjects[InputManager.farmObjectIndex].isField = true;
Drag arrangeImageDrag = arrangeImage.GetComponent <Drag>();
arrangeImageDrag.PItransformBack();
DataManager._instance.ParseFarmObjectData(Spawner._instance.farmObjects);
inventorySlotNum--;
for (int i = InputManager.inventorySlotNumber; i <= inventorySlotNum; i++)
{
Image invenSlotImage = inventoryContents.transform.GetChild(i).gameObject.GetComponent <Image>();
Image nextInvenSlotImage = inventoryContents.transform.GetChild(i + 1).gameObject.GetComponent <Image>();
invenSlotImage.sprite = nextInvenSlotImage.sprite;
FarmObject invenSlotFarmOb = inventoryContents.transform.GetChild(i).gameObject.GetComponent <FarmObject>();
FarmObject nextInvenSlotFarmOb = inventoryContents.transform.GetChild(i + 1).gameObject.GetComponent <FarmObject>();
invenSlotFarmOb.farmObjectIndex = nextInvenSlotFarmOb.farmObjectIndex;
invenSlotFarmOb.farmObjectNumber = nextInvenSlotFarmOb.farmObjectNumber;
}
for (int i = 0; i < farmAnimal.transform.childCount; i++)
{
AnimalController animalController = farmAnimal.transform.GetChild(i).GetComponent <AnimalController>();
animalController.pathStart();
}
}
}
public FarmEditFacilityButton GetSamFacilityButton(FarmObject farmObject)
{
FarmEditFacilityButton[] componentsInChildren = base.GetComponentsInChildren <FarmEditFacilityButton>();
if (componentsInChildren == null)
{
global::Debug.LogError(string.Format("FacilityID = {0}, UserFacilityID = {1}", farmObject.facilityID, farmObject.userFacilityID));
return(null);
}
return(componentsInChildren.SingleOrDefault((FarmEditFacilityButton x) => x.IsSame(farmObject)));
}
public void AddStoreFacility(FarmObject addFarmObject)
{
FarmEditFooter componentInChildren = base.GetComponentInChildren <FarmEditFooter>();
if (null == componentInChildren)
{
global::Debug.LogError("FarmEditFooter Not Found");
return;
}
componentInChildren.AddFacilityButton(addFarmObject);
}
public FarmObject GetStoreFacility(FarmObject findFarmObject)
{
FarmEditFooter componentInChildren = base.GetComponentInChildren <FarmEditFooter>();
if (null == componentInChildren)
{
global::Debug.LogError("FarmEditFooter Not Found");
return(null);
}
return(componentInChildren.GetRestStoreFacility(findFarmObject));
}
public FacilityUpgradeConfirm(CMD_UpgradeConfirmation upgradeConfirmationUI, UserFacility userFacility)
{
this.parentUI = upgradeConfirmationUI;
this.userFacility = userFacility;
FarmRoot instance = FarmRoot.Instance;
if (null != instance)
{
this.targetFarmObject = instance.Scenery.farmObjects.SingleOrDefault((FarmObject x) => x.userFacilityID == userFacility.userFacilityId);
}
}
public IEnumerator SaveEdit(Action <bool> completed)
{
FarmRoot farmRoot = FarmRoot.Instance;
FarmField farmField = farmRoot.Field;
List <FacilityPosition> facilityPositions = new List <FacilityPosition>();
for (int i = 0; i < this.farmObjects.Count; i++)
{
FarmObject farmObject = this.farmObjects[i];
FarmGrid.GridPosition gridPosition = farmField.Grid.GetGridPosition(farmObject.GetBaseGridPosition3D());
FacilityPosition item = new FacilityPosition
{
userFacilityId = farmObject.userFacilityID,
positionX = gridPosition.x,
positionY = gridPosition.y
};
facilityPositions.Add(item);
}
RestrictionInput.StartLoad(RestrictionInput.LoadType.LARGE_IMAGE_MASK_ON);
RequestFA_FacilityAllArrangement request = new RequestFA_FacilityAllArrangement
{
SetSendData = delegate(FacilityAllArrangement param)
{
param.userFacilityList = facilityPositions.ToArray();
},
OnReceived = delegate(WebAPI.ResponseData response)
{
for (int j = 0; j < facilityPositions.Count; j++)
{
FacilityPosition facilityPosition = facilityPositions[j];
UserFacility userFacility = Singleton <UserDataMng> .Instance.GetUserFacility(facilityPosition.userFacilityId);
if (userFacility != null)
{
userFacility.positionX = facilityPosition.positionX;
userFacility.positionY = facilityPosition.positionY;
}
}
if (completed != null)
{
completed(true);
}
}
};
RequestBase request2 = request;
if (FarmScenery.< > f__mg$cache0 == null)
{
FarmScenery.< > f__mg$cache0 = new Action(RestrictionInput.EndLoad);
}
yield return(base.StartCoroutine(request2.Run(FarmScenery.< > f__mg$cache0, null, null)));
yield break;
}
public void BuyNewFarmObject(GameObject farmObject)
{
FarmObject farmObjectOb = farmObject.GetComponent <FarmObject>();
Rigidbody2D farmObjectRB = farmObject.GetComponent <Rigidbody2D>();
farmObjectOb.posX = farmObjectRB.position.x;
farmObjectOb.posY = farmObjectRB.position.y;
farmObjectOb.harvestTime = System.DateTime.Now;
farmObjects.Add(farmObjectOb);
print(farmObjects[farmObjects.Count - 1].posX);
}
public void CreateResource(string url, FarmObject origin)
{
GameObject resource = Instantiate (resourcePrefab) as GameObject;
FarmResource script = resource.GetComponent<FarmResource> ();
resource.transform.SetParent (transform);
origin.resourceList.Add (script);
script.origin = origin;
script.StartCoroutine ("Initialize", url);
}
public void CreateResource(string url, FarmObject origin)
{
GameObject resource = Instantiate(resourcePrefab) as GameObject;
FarmResource script = resource.GetComponent <FarmResource> ();
resource.transform.SetParent(transform);
origin.resourceList.Add(script);
script.origin = origin;
script.StartCoroutine("Initialize", url);
}
public void StartSetting(FarmObject farmObject)
{
FarmRoot instance = FarmRoot.Instance;
if (null == instance)
{
global::Debug.LogError("FarmRoot Not Found");
return;
}
this.DecrementFacilityCount(farmObject);
instance.Scenery.RelocationOfStoreFarmObject(farmObject);
}
public bool StartSettingAndDragState(FarmObject farmObject, Vector3 mousePosition)
{
FarmRoot instance = FarmRoot.Instance;
if (null == instance)
{
global::Debug.LogError("FarmRoot Not Found");
return(false);
}
this.DecrementFacilityCount(farmObject);
return(instance.Scenery.RelocationOfStoreFarmObjectAndDragState(farmObject, mousePosition));
}
public void Init()
{
InputManager.oneTapMoney = 1;
PathFinder forInstantiate = new PathFinder();
MoneyManager.money = DataManager._instance.playerData.money;
MoneyManager.heart = DataManager._instance.playerData.heart;
foreach (FarmObjectData farmObjectData in DataManager._instance.playerData.farmObjectDatas)
{
if (farmObjectData.isField == true)
{
GameObject newFarmObject = Instantiate(farmObjectPrefabs[farmObjectData.index], new Vector2((float)farmObjectData.posX, (float)farmObjectData.posY), Quaternion.identity);
FarmObject farmObject = newFarmObject.GetComponent <FarmObject>();
farmObject.posX = (float)farmObjectData.posX;
farmObject.posY = (float)farmObjectData.posY;
farmObject.harvestTime = farmObjectData.harvestTime;
farmObject.isField = farmObjectData.isField;
newFarmObject.transform.parent = farmFarmObject.transform;
farmObject.farmObjectIndex = farmObjects.Count;
AddNewFarmObject(newFarmObject);
}
if (farmObjectData.isField != true)
{
GameObject newFarmObject = Instantiate(farmObjectPrefabs[farmObjectData.index], new Vector2((float)farmObjectData.posX, (float)farmObjectData.posY), Quaternion.identity);
FarmObject farmObject = newFarmObject.GetComponent <FarmObject>();
farmObject.posX = (float)farmObjectData.posX;
farmObject.posY = (float)farmObjectData.posY;
farmObject.harvestTime = farmObjectData.harvestTime;
farmObject.isField = farmObjectData.isField;
newFarmObject.transform.parent = farmFarmObject.transform;
farmObject.farmObjectIndex = farmObjects.Count;
AddNewFarmObject(newFarmObject);
Destroy(newFarmObject);
}
}
forInstantiate.NodeSetting();
foreach (AnimalData animalData in DataManager._instance.playerData.animalDatas)
{
GameObject newAnimal = Instantiate(animalPrefabs[animalData.index], forInstantiate.RandomSpawnSetting(), Quaternion.identity);
Animal newanimal = newAnimal.GetComponent <Animal>();
newanimal.exp = animalData.exp;
newanimal.animalName = animalData.animalName;
//print(temp.animalIdx);
newAnimal.transform.parent = farmAnimal.transform;
AddNewAnimal(newAnimal);
//idx따라 Animal 생성
}
}
public void EndSetting(bool deleteFarmObject)
{
if (deleteFarmObject)
{
UnityEngine.Object.Destroy(this.farmObject.gameObject);
}
this.farmObject = null;
this.settingMode = FarmObjectSetting.SettingMode.NONE;
FarmRoot instance = FarmRoot.Instance;
instance.Input.RemoveTouchDragEvent(new Func <InputControll, bool>(this.OnDrag));
}
public IEnumerator Initialize(FarmResource re)
{
resource = re;
farmObject = resource.origin;
// Set name and location
name = resource.resourceType;
location = farmObject.name;
nameDisplay.text = name;
locationDisplay.text = location;
//print (resource.resourceType);
icon.sprite = sensorDisplayManager.icons [resource.resourceType.ToLower()];
// Create all sensing points
foreach (FarmSensor sensor in resource.sensorsList)
{
foreach (FarmSensingPoint point in sensor.farmSensingPoints)
{
yield return StartCoroutine("AddSensingPoint", point);
}
}
transform.localScale = new Vector3 (1,1,1);
yield return StartCoroutine ("UpdateSize");
yield return null;
}
