public FarmDigimonAI.ActionID ChooseAction()
{
FarmRoot instance = FarmRoot.Instance;
FarmScenery scenery = instance.Scenery;
List <FarmDigimonAI.ActionID> list = new List <FarmDigimonAI.ActionID>();
for (int i = 1; i < Enum.GetNames(typeof(FarmDigimonAI.ActionID)).Length; i++)
{
if (i != 6)
{
list.Add((FarmDigimonAI.ActionID)i);
}
}
if (scenery.farmObjects.Any((FarmObject x) => x.IsConstruction()))
{
list.Remove(FarmDigimonAI.ActionID.CONSTRUCTION);
}
if (!scenery.farmObjects.Any((FarmObject x) => x.facilityID == 1))
{
list.Remove(FarmDigimonAI.ActionID.MEAT_FARM);
}
int index = UnityEngine.Random.Range(0, list.Count);
return(list[index]);
}
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 void Start()
{
FarmRoot instance = FarmRoot.Instance;
if (null == instance)
{
return;
}
this.farmCamera = instance.Camera;
UserFacility userFacility = Singleton <UserDataMng> .Instance.GetUserFacility(this.farmObject.userFacilityID);
if (string.IsNullOrEmpty(userFacility.completeTime))
{
this.complateTime = ServerDateTime.Now;
}
else
{
this.complateTime = DateTime.Parse(userFacility.completeTime);
}
if (userFacility.level == 0 || (userFacility.level == 1 && string.IsNullOrEmpty(userFacility.completeTime)))
{
FacilityM facilityMaster = FarmDataManager.GetFacilityMaster(userFacility.facilityId);
this.totalComplateSeconds = int.Parse(facilityMaster.buildingTime);
}
else
{
FacilityUpgradeM facilityUpgradeMaster = FarmDataManager.GetFacilityUpgradeMaster(userFacility.facilityId, userFacility.level + 1);
this.totalComplateSeconds = int.Parse(facilityUpgradeMaster.upgradeTime);
}
this.OnUpdate();
}
private void CompletedMove()
{
FarmObjectSetting component = base.GetComponent <FarmObjectSetting>();
if (null != component.farmObject && component.farmObject.isPlaceable)
{
FarmRoot instance = FarmRoot.Instance;
if (instance.farmMode == FarmRoot.FarmControlMode.NORMAL)
{
base.StartCoroutine(this.SaveFarmObjectMove());
}
else
{
instance.ResetSettingMark();
this.farmObject.DisplayFloorObject();
component.ComplatedSetting();
instance.isEdit = true;
if (instance.farmMode == FarmRoot.FarmControlMode.EDIT)
{
if (!instance.Scenery.IsExistStoreFacility())
{
instance.farmUI.EnableEditSaveButton(true);
}
instance.farmUI.EnableEditStoreButton(true);
}
}
}
}
private bool OnDrag(InputControll inputControll)
{
if (this.farmObject.gameObject == inputControll.rayHitColliderObject)
{
FarmObjectSetting component = base.GetComponent <FarmObjectSetting>();
if (null == component.farmObject)
{
FarmRoot instance = FarmRoot.Instance;
if (instance.IsVisitFriendFarm)
{
return(false);
}
instance.SetActiveNotTouchObject(false);
this.SetFacilityButton(false, instance);
component.SetMoveFarmObject(this.farmObject);
if (instance.farmMode == FarmRoot.FarmControlMode.EDIT)
{
instance.farmUI.EnableEditSaveButton(false);
}
return(true);
}
}
else
{
this.RemoveTouchDragEventForFriendFarm();
}
return(false);
}
public void DeleteFarmObject(int userFacilityID)
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
instance.ClearSettingFarmObject();
Singleton <UserDataMng> .Instance.DeleteUserFacility(userFacilityID);
bool flag = false;
for (int i = 0; i < this.farmObjects.Count; i++)
{
if (userFacilityID == this.farmObjects[i].userFacilityID)
{
flag = (this.farmObjects[i].facilityID == 11);
GameObject gameObject = this.farmObjects[i].gameObject;
field.SetGridPutFlag(this.farmObjects[i], false);
this.farmObjects.Remove(this.farmObjects[i]);
UnityEngine.Object.Destroy(gameObject);
break;
}
}
if (flag)
{
FarmRoot.Instance.ResetSetteingFence();
}
}
private void Start()
{
FarmRoot instance = FarmRoot.Instance;
Camera component = base.GetComponent <Camera>();
GUICameraControll component2 = base.GetComponent <GUICameraControll>();
component.orthographicSize = component2.CameraOrthographicSizeMax;
float z = 0.1f;
float num = Mathf.Abs(component.ViewportToWorldPoint(new Vector3(0f, 1f, z)).y - instance.transform.position.y);
float num2 = Mathf.Abs(component.ViewportToWorldPoint(new Vector3(0f, 0f, z)).y - instance.transform.position.y);
float f = component.transform.localEulerAngles.x * 0.0174532924f;
float z2 = Mathf.Abs(num / Mathf.Cos(f));
Vector3 b = new Quaternion(component.transform.localRotation.x, 0f, 0f, 1f) * new Vector3(0f, 0f, z2);
Vector3 vector = new Vector3(this.drawAreaClip.size.x / 2f, 0f, this.drawAreaClip.size.z / 2f) - b;
Vector3 vector2 = new Vector3(-this.drawAreaClip.size.x / 2f, 0f, this.drawAreaClip.size.z / 2f) - b;
z2 = Mathf.Abs(num2 / Mathf.Cos(f));
b = new Quaternion(component.transform.localRotation.x, 0f, 0f, 1f) * new Vector3(0f, 0f, z2);
Vector3 vector3 = new Vector3(-this.drawAreaClip.size.x / 2f, 0f, -this.drawAreaClip.size.z / 2f) - b;
this.topLeftX = vector2.x;
this.topLeftZ = vector2.z;
this.topRightX = vector.x;
this.bottomLeftZ = vector3.z;
}
public IEnumerator AppearanceNormal(GameObject digimon, Action completed)
{
FarmRoot farmRoot = FarmRoot.Instance;
FarmField farmField = farmRoot.Field;
int gridIndex = FarmDigimonUtility.GetPassableGridIndex();
if (gridIndex == -1)
{
digimon.SetActive(false);
}
else
{
base.transform.position = farmField.Grid.GetPositionGridCenter(gridIndex, false);
base.transform.localScale = Vector3.zero;
base.transform.localRotation = Quaternion.identity;
Vector3 angles = base.transform.localEulerAngles;
angles.y = farmRoot.Camera.transform.localEulerAngles.y + 180f;
base.transform.localEulerAngles = angles;
float scale = 0.99f;
while (1f > scale)
{
scale += Time.deltaTime;
scale = Mathf.Clamp01(scale);
float adjScale = scale * 2f;
base.transform.localScale = new Vector3(adjScale, adjScale, adjScale);
yield return(null);
}
}
if (completed != null)
{
completed();
}
yield break;
}
private void Start()
{
FarmRoot instance = FarmRoot.Instance;
this.farmCamera = instance.Camera;
this.mainCamera = GUIMain.GetOrthoCamera();
}
public IEnumerator OnTouchedEffect(bool isSelected, Action <bool> result)
{
bool isEvent = false;
FarmRoot farmRoot = FarmRoot.Instance;
if (farmRoot.farmMode == FarmRoot.FarmControlMode.EDIT)
{
yield break;
}
bool isMovingObject = FarmObjectSetting.SettingMode.MOVE == farmRoot.SettingObject.settingMode;
if (this.IsConstruction() && !isMovingObject && !this.IsTutorialFacility() && !farmRoot.IsVisitFriendFarm)
{
yield return(base.StartCoroutine(this.ServerRequestFacilityBuildComplete(delegate(bool e)
{
isEvent = e;
})));
}
else
{
isEvent = this.StartSelectAnimation(isSelected);
}
if (result != null)
{
result(isEvent);
}
yield break;
}
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);
}
}
}
private void SetBackground()
{
GameObject gameObject = new GameObject("BackgroundCamera");
FarmRoot farmRoot = FarmRoot.Instance;
gameObject.transform.SetParent(farmRoot.transform);
Vector3 vector = default(Vector3);
foreach (FarmObject farmObject in farmRoot.Scenery.farmObjects)
{
if (farmObject.facilityID == 5)
{
vector = farmObject.transform.localPosition;
break;
}
}
gameObject.transform.localPosition = new Vector3(vector.x - 3.635f, vector.y + 1.2f, vector.z - 1.21f);
gameObject.transform.Rotate(new Vector3(15f, 125f));
this.backgroundCamera = gameObject.AddComponent <Camera>();
this.preCameraClearFlag = this.backgroundCamera.clearFlags;
this.backgroundCamera.clearFlags = CameraClearFlags.Color;
this.backgroundRenderTex = new RenderTexture(this.backgroundUiTex.width, this.backgroundUiTex.height, 16);
this.backgroundCamera.targetTexture = this.backgroundRenderTex;
this.backgroundUiTex.mainTexture = this.backgroundRenderTex;
this.backgroundCamera.cullingMask &= ~(1 << LayerMask.NameToLayer("Cutscene"));
}
private int[] GetPassGridIndexs(int targetGridIndex)
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
FarmGrid.GridPosition gridPosition = field.Grid.GetGridPosition(base.transform.localPosition);
int gridIndex = field.Grid.GetGridIndex(gridPosition);
List <FarmDigimonUtility.PathInfo> path = FarmDigimonUtility.GetPath(gridIndex, targetGridIndex);
if (path != null)
{
FarmDigimonUtility.PathInfo pathInfo = path.SingleOrDefault((FarmDigimonUtility.PathInfo x) => x.gridIndex == targetGridIndex);
int startGridIndex = pathInfo.gridIndex;
int num = pathInfo.checkPoint - 1;
List <int> list = new List <int>();
while (0 <= num && this.ChoosePath(field.Grid, path, startGridIndex, num, list))
{
num--;
startGridIndex = list.Last <int>();
}
if (0 < list.Count)
{
return(list.ToArray());
}
}
return(null);
}
protected virtual bool CheckExtendBuild()
{
FarmRoot instance = FarmRoot.Instance;
if (!(instance != null))
{
return(false);
}
int num = instance.Scenery.GetFacilityCount(this.farmObject.facilityID);
List <UserFacility> stockFacilityListByfacilityIdAndLevel = Singleton <UserDataMng> .Instance.GetStockFacilityListByfacilityIdAndLevel(this.farmObject.facilityID);
int count = stockFacilityListByfacilityIdAndLevel.Count;
num += count;
FacilityM facilityMaster = FarmDataManager.GetFacilityMaster(this.farmObject.facilityID);
if (FarmUtility.IsShortage(facilityMaster.buildingAssetCategoryId1, facilityMaster.buildingAssetNum1))
{
this.ShowExtendBuildErrorDialog("C-FA01", true);
return(false);
}
if (int.Parse(facilityMaster.maxNum) <= num)
{
this.ShowExtendBuildErrorDialog("E-FA03", false);
return(false);
}
return(true);
}
private bool SetFarmObjectOfEditMode(FarmObject farmObject, Vector3 farmObjectPos)
{
FarmRoot instance = FarmRoot.Instance;
FarmObjectSetting component = base.GetComponent <FarmObjectSetting>();
bool result = component.SetEditFarmObject(farmObject, farmObjectPos);
if (farmObject.isPlaceable)
{
FarmObjectSelect component2 = base.GetComponent <FarmObjectSelect>();
component.ComplatedSetting();
component2.SetSelectObject(farmObject.gameObject);
if (null != instance.farmUI && !this.IsExistStoreFacility())
{
instance.farmUI.EnableEditSaveButton(true);
}
}
else
{
FarmObjectEdit component3 = base.GetComponent <FarmObjectEdit>();
component3.StartEdit(farmObject);
}
if (null != instance.farmUI)
{
instance.farmUI.EnableEditStoreButton(true);
}
return(result);
}
private void Awake()
{
FarmRoot.instance = this;
string path = "Farm/Builds/SettingMark/SettingMark";
GameObject gameObject = AssetDataMng.Instance().LoadObject(path, null, true) as GameObject;
if (null == gameObject)
{
return;
}
GameObject gameObject2 = UnityEngine.Object.Instantiate <GameObject>(gameObject);
gameObject2.transform.parent = base.transform;
gameObject2.transform.localScale = Vector3.one;
gameObject2.transform.localPosition = Vector3.zero;
gameObject2.transform.localEulerAngles = Vector3.zero;
this.settingMark = gameObject2.GetComponent <FarmSettingMark>();
path = "Farm/Builds/SelectMark/SelectMark";
gameObject = (AssetDataMng.Instance().LoadObject(path, null, true) as GameObject);
if (null == gameObject)
{
return;
}
gameObject2 = UnityEngine.Object.Instantiate <GameObject>(gameObject);
gameObject2.transform.parent = base.transform;
gameObject2.transform.localScale = Vector3.one;
gameObject2.transform.localPosition = Vector3.zero;
gameObject2.transform.localEulerAngles = Vector3.zero;
this.selectMark = gameObject2.GetComponent <FarmSelectMark>();
gameObject2.SetActive(false);
FarmCameraControlForCMD.ClearCount();
}
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 APIRequestTask SaveFarmObjectPosition(Action <int> complated)
{
RequestFA_FacilityBuild request = new RequestFA_FacilityBuild
{
SetSendData = delegate(FacilityBuild param)
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
FarmObjectSetting component = this.GetComponent <FarmObjectSetting>();
FarmGrid.GridPosition gridPosition = field.Grid.GetGridPosition(component.farmObject.GetBaseGridPosition3D());
param.facilityId = component.farmObject.facilityID;
param.positionX = gridPosition.x;
param.positionY = gridPosition.y;
},
OnReceived = delegate(FacilityBuildResult response)
{
this.SaveResponseToFacilityBuild(response.userFacilityId);
if (complated != null)
{
complated(response.userFacilityId);
}
}
};
return(new APIRequestTask(request, true));
}
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();
}
private void Start()
{
FarmRoot instance = FarmRoot.Instance;
this.farmCamera = ((!(instance != null)) ? null : instance.Camera);
this.mainCamera = GUIMain.GetOrthoCamera();
base.StartCoroutine(this.DestroyPref(2f));
}
public void ClearConstruction()
{
FarmRoot instance = FarmRoot.Instance;
instance.farmUI.DeleteConstructionDetail(this.userFacilityID);
instance.farmUI.UpdateFacilityButton(this);
this.BuildComplete();
}
private Vector3 GetScreenCenterPoint()
{
Vector3 distanceToGround = FarmUtility.GetDistanceToGround();
FarmRoot instance = FarmRoot.Instance;
Camera camera = instance.Camera;
return(camera.transform.localPosition + distanceToGround);
}
private void MoveComplate(FarmRoot farmRoot, FarmObjectSetting farmObjectSetting)
{
farmRoot.ResetSettingMark();
this.farmObject.DisplayFloorObject();
farmRoot.SetActiveNotTouchObject(true);
this.SetFacilityButton(true, farmRoot);
farmObjectSetting.ComplatedSetting();
}
private void Start()
{
FarmRoot instance = FarmRoot.Instance;
this.farmObject = instance.SettingObject.farmObject;
this.farmCamera = instance.Camera;
GUIScreenHome.enableBackKeyAndroid = false;
}
private void ResetFarmWork()
{
FarmRoot farmRoot = FarmRoot.Instance;
if (null != farmRoot)
{
farmRoot.ClearSettingFarmObject();
}
}
private void WaitColosseumOpen()
{
FarmRoot instance = FarmRoot.Instance;
if (instance != null)
{
instance.StartColosseumOpenAnimation(new Action(base.ResumeScript));
}
}
private int GetGridIndexOfScreenCenter()
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
Vector3 position = this.farmCamera.transform.localPosition + FarmUtility.GetDistanceToGround();
FarmGrid.GridPosition gridPosition = field.Grid.GetGridPosition(position);
return(field.Grid.GetGridIndex(gridPosition));
}
public void CancelMove()
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
this.farmObject.DisplayedInFront(false);
this.farmObject.ResetPosition();
field.SetGridPutFlag(this.farmObject, true);
this.EndSetting(false);
}
private void OpenStoneShop()
{
GUIMain.ShowCommonDialog(null, "CMD_Shop", null);
FarmRoot farmRoot = FarmRoot.Instance;
if (null != farmRoot)
{
farmRoot.ClearSettingFarmObject();
}
}
protected void EnableFarmInput()
{
FarmRoot instance = FarmRoot.Instance;
InputControll input = instance.Input;
if (null != input)
{
input.enabled = true;
}
}
