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 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 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);
}
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();
}
}
public ActionResult <FarmFieldDto> Create(FarmFieldDto targetValue)
{
var userDimensions = targetValue.Dimensions;
var dimensions = new Dimensions {
};
dimensions.Width = userDimensions.Width;
dimensions.Height = userDimensions.Height;
dynamic farmfield = null;
if (userDimensions != null)
{
farmfield = new FarmField {
Name = targetValue.Name,
Active = targetValue.Active,
Dimensions = dimensions,
Description = targetValue.Description
};
}
if (farmfield == null)
{
return(BadRequest("Farmfield is null, AHHHHHH"));
}
var data = context.Set <FarmField>().Add(farmfield);
context.SaveChanges();
targetValue.Id = data.Entity.Id;
return(Created($"/api/farm-field/{data.Entity.Id}", targetValue));
}
public void SetSelectMark(FarmField farmField, FarmSelectMark mark)
{
mark.gameObject.SetActive(true);
mark.SetParent(base.gameObject);
Vector2 gridSize = new Vector2(farmField.gridHorizontal, farmField.gridVertical);
mark.SetSize(this.sizeX, this.sizeY, gridSize);
}
protected override void Start()
{
base.Start();
// Utility AI setup
// ****** VALUES ******
UAIV_AgentHealth agentHealth = new UAIV_AgentHealth(this, _AgentController._AgentStats.HealthPoints);
UAIV_AgentFood agentFood = new UAIV_AgentFood(this, _AgentController._AgentStats.FoodPoints);
UAIV_AgentEnergy agentEnergy = new UAIV_AgentEnergy(this, _AgentController._AgentStats.EnergyPoints);
UAIV_FarmPlaced farmPlaced = new UAIV_FarmPlaced(this, 1);
UAIV_DistanceTo distanceToHQ = new UAIV_DistanceTo(_AgentController._PlayerOwner.GetBuilding_ByTag(GameCache._Cache.GetData("Headquarters").tag), this, 20);
UAIV_InventorySize inventorySize = new UAIV_InventorySize(this, _AgentController._Inventory._MaxInventorySize);
UAIV_SoldierEnemyCount enemySoldierCount = new UAIV_SoldierEnemyCount(this, 3.0f);
// ****** SCORERS ******
UtilityScorer scorer_AgentHealth = new UtilityScorer(agentHealth, _HealthCurve);
UtilityScorer scorer_AgentFood = new UtilityScorer(agentFood, _FoodCurve);
UtilityScorer scorer_AgentEnergy = new UtilityScorer(agentEnergy, _EnergyCurve);
UtilityScorer scorer_FarmBoolCheck = new UtilityScorer(farmPlaced, _FarmPlacedCurve);
UtilityScorer scorer_DistanceToHQ = new UtilityScorer(distanceToHQ, _DistanceToHQCurve);
UtilityScorer scorer_InventorySize = new UtilityScorer(inventorySize, _InventorySizeCurve);
UtilityScorer scorer_enemySoldierThreatLevel = new UtilityScorer(enemySoldierCount, _EnemySoldierThreatCurve);
// ****** ACTIONS ******
RoamAround roamAction_SearchFarmSpot = new RoamAround(this, 0.0f);
roamAction_SearchFarmSpot.AddScorer(scorer_DistanceToHQ);
roamAction_SearchFarmSpot.AddScorer(scorer_FarmBoolCheck);
FarmField farmFieldAction = new FarmField(this, 0.5f);
DeliverResources deliverResourceAction = new DeliverResources(GameCache._Cache.GetData("Headquarters").tag, this, 0.0f);
deliverResourceAction.AddScorer(scorer_InventorySize);
EatFood eatFoodAction = new EatFood(this, 0.0f);
eatFoodAction.AddScorer(scorer_AgentFood);
eatFoodAction.SetWeight(2);
SleepAndRest sleepRestAction = new SleepAndRest("Field", this, 0.0f);
sleepRestAction.AddScorer(scorer_AgentEnergy);
Hide hideAction = new Hide("Headquarters", this, 0.0f);
hideAction.AddScorer(scorer_enemySoldierThreatLevel);
hideAction.SetWeight(3);
// ****** REGISTER ACTIONS ******
_AgentActions.Add(roamAction_SearchFarmSpot);
_AgentActions.Add(farmFieldAction);
_AgentActions.Add(deliverResourceAction);
_AgentActions.Add(eatFoodAction);
_AgentActions.Add(sleepRestAction);
_AgentActions.Add(hideAction);
}
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);
}
public IEnumerator Walk()
{
FarmRoot farmRoot = FarmRoot.Instance;
FarmField farmField = farmRoot.Field;
FarmDigimonAI ai = base.GetComponent <FarmDigimonAI>();
FarmDigimonAI.ActionParam param = ai.GetActionParam();
float speed = 1.6f;
if (param.pathGridIndexs != null && 0 < param.pathGridIndexs.Length)
{
int nowIndex = param.pathGridIndexs.Length;
int checkIndex = 0;
while (checkIndex < nowIndex)
{
Vector3 digimonPos3D = base.transform.localPosition;
digimonPos3D.y = 0f;
int gridIndex = param.pathGridIndexs[checkIndex];
Vector3 gridPos3D = farmField.Grid.GetPositionGridCenter(gridIndex, false);
gridPos3D.y = 0f;
Vector3 rayDirection = gridPos3D - digimonPos3D;
digimonPos3D.y = farmRoot.transform.localPosition.y + 0.1f;
gridPos3D.y = farmRoot.transform.localPosition.y + 0.1f;
if (!Physics.Raycast(digimonPos3D, rayDirection, rayDirection.magnitude, this.MASK_LAYER))
{
digimonPos3D.y = 0f;
gridPos3D.y = 0f;
Vector3 digimonDirection = Quaternion.AngleAxis(base.transform.localEulerAngles.y, Vector3.up) * Vector3.forward;
float angle = Vector3.Angle(digimonDirection, rayDirection);
Vector3 digimonRightDirection = Quaternion.AngleAxis(90f, Vector3.up) * digimonDirection;
if (0f > Vector3.Dot(digimonRightDirection, rayDirection))
{
angle *= -1f;
}
this.enumerator = this.Turn(angle, speed);
Coroutine coroutine = base.StartCoroutine(this.enumerator);
if (40f <= Mathf.Abs(angle))
{
yield return(coroutine);
}
this.enumerator = this.Movement(digimonPos3D, gridPos3D, speed);
yield return(base.StartCoroutine(this.enumerator));
this.enumerator = null;
nowIndex = checkIndex;
checkIndex = 0;
}
else
{
checkIndex += Mathf.Max(1, (nowIndex - checkIndex) / 2);
}
}
}
yield break;
}
public virtual void SetSettingMark(FarmField farmField, FarmSettingMark mark)
{
mark.SetParent(base.gameObject);
Vector2 gridSize = new Vector2(farmField.gridHorizontal, farmField.gridVertical);
mark.SetSize(this.sizeX, this.sizeY, gridSize);
if (null != this.floorObject)
{
this.floorObject.SetActive(false);
}
}
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 APIRequestTask SaveStockFarmObjectPosition(int userFacilityId, Action <int> complated)
{
RequestFA_FacilityStock request = new RequestFA_FacilityStock
{
SetSendData = delegate(FacilityStock param)
{
param.userFacilityId = userFacilityId;
param.stockFlg = 0;
},
OnReceived = delegate(FacilityStockResult response)
{
UserFacility userStockFacility = Singleton <UserDataMng> .Instance.GetUserStockFacility(userFacilityId);
Singleton <UserDataMng> .Instance.DeleteUserStockFacility(userFacilityId);
Singleton <UserDataMng> .Instance.AddUserFacility(userStockFacility);
}
};
RequestFA_FacilityMoving request2 = new RequestFA_FacilityMoving
{
SetSendData = delegate(FacilityMoving param)
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
FarmObjectSetting component = this.GetComponent <FarmObjectSetting>();
FarmGrid.GridPosition gridPosition = field.Grid.GetGridPosition(component.farmObject.GetBaseGridPosition3D());
param.userFacilityId = userFacilityId;
param.positionX = gridPosition.x;
param.positionY = gridPosition.y;
},
OnReceived = delegate(WebAPI.ResponseData response)
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
FarmObjectSetting component = this.GetComponent <FarmObjectSetting>();
FarmGrid.GridPosition gridPosition = field.Grid.GetGridPosition(component.farmObject.GetBaseGridPosition3D());
UserFacility userFacility = Singleton <UserDataMng> .Instance.GetUserFacility(userFacilityId);
userFacility.positionX = gridPosition.x;
userFacility.positionY = gridPosition.y;
this.SaveResponseToStockToFarmFacility(userFacilityId);
if (complated != null)
{
complated(userFacilityId);
}
}
};
APIRequestTask apirequestTask = new APIRequestTask(request, true);
APIRequestTask task = new APIRequestTask(request2, true);
apirequestTask.Add(task);
return(apirequestTask);
}
public static int GetPassableGridIndex()
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
int[] passableGridIndexs = field.Grid.GetPassableGridIndexs();
if (0 < passableGridIndexs.Length)
{
int num = UnityEngine.Random.Range(0, passableGridIndexs.Length);
return(passableGridIndexs[num]);
}
return(-1);
}
public FarmGrid.GridPosition ComplatedSetting()
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
this.farmObject.DisplayedInFront(false);
FarmGrid.GridPosition result = field.SetGridPutFlag(this.farmObject, true);
if (this.farmObject.facilityID == 11)
{
FarmRoot.Instance.ResetSetteingFence();
}
this.EndSetting(false);
return(result);
}
public void SetMoveFarmObject(FarmObject farmObject)
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
this.farmObject = farmObject;
this.settingMode = FarmObjectSetting.SettingMode.MOVE;
this.farmObject.SetSettingMark(field, instance.SettingMark);
this.farmObject.SetPlaceable(true);
farmObject.BackupPosition();
field.SetGridPutFlag(this.farmObject, false);
this.farmObject.DisplayedInFront(true);
instance.Input.AddTouchDragEvent(new Func <InputControll, bool>(this.OnDrag));
}
public bool IsInvalidGrid(FarmField farmField, int[] gridIndexs)
{
bool result = false;
FarmField.Field field = farmField.GetField();
foreach (int num in gridIndexs)
{
if (0 > num || field.grids.Count <= num || field.grids[num].invalid)
{
result = true;
break;
}
}
return(result);
}
private Vector3 GetGridPosition3D(Vector3 pos)
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
float num = field.gridHorizontal * (float)this.baseGridPositionX + 0.5f * field.gridHorizontal;
float num2 = field.gridVertical * (float)this.baseGridPositionY + 0.5f * field.gridVertical;
float num3 = 0.5f * (float)this.sizeX * field.gridHorizontal;
float num4 = 0.5f * (float)this.sizeY * field.gridVertical;
Vector3 result = pos;
result.x -= num3 - num;
result.y = 0f;
result.z += num4 - num2;
return(result);
}
public static int ChooseAroundGridIndex(FarmObject farmObject)
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
FarmGrid.GridPosition gridPosition = field.Grid.GetGridPosition(farmObject.transform.localPosition);
int[] gridIndexs = farmObject.GetGridIndexs(field.GetField(), field.Grid.GetGridIndex(gridPosition));
int[] aroundGridIndexs = FarmDigimonUtility.GetAroundGridIndexs(gridIndexs);
int[] passableGridIndexs = field.Grid.GetPassableGridIndexs(aroundGridIndexs);
if (0 < passableGridIndexs.Length)
{
int num = UnityEngine.Random.Range(0, passableGridIndexs.Length);
return(passableGridIndexs[num]);
}
return(-1);
}
public override void SetSettingMark(FarmField farmField, FarmSettingMark mark)
{
mark.SetParent(base.gameObject);
Vector2 gridSize = new Vector2(farmField.gridHorizontal, farmField.gridVertical);
mark.SetSize(this.sizeX, this.sizeY, gridSize);
if (null != this.floorObject)
{
Transform transform = this.floorObject.transform;
this.originalScale = transform.localScale;
Vector3 localScale = new Vector3(this.originalScale.x * this.movingScale.x, this.originalScale.y * this.movingScale.y, this.originalScale.z * this.movingScale.z);
transform.localScale = localScale;
this.originalPosition = transform.localPosition;
transform.localPosition = this.movingPos;
}
}
public IEnumerator InitializeFarmObjectParallelRead()
{
FarmRoot farmRoot = FarmRoot.Instance;
FarmField farmField = farmRoot.Field;
farmField.ClearPutFlag();
List <UserFacility> userFacilitys = Singleton <UserDataMng> .Instance.GetUserFacilityList();
int num = userFacilitys.Count / 6;
if (0 < userFacilitys.Count - 6 * num)
{
num++;
}
List <UserFacility[]> readFacility = new List <UserFacility[]>();
for (int j = 0; j < 6; j++)
{
readFacility.Add(new UserFacility[num]);
}
int parallelIndex = 0;
int dataIndex = 0;
for (int k = 0; k < userFacilitys.Count; k++)
{
UserFacility[] array = readFacility[parallelIndex];
array[dataIndex] = userFacilitys[k];
parallelIndex++;
if (6 <= parallelIndex)
{
parallelIndex = 0;
dataIndex++;
}
}
Coroutine[] coroutineList = new Coroutine[6];
for (int l = 0; l < 6; l++)
{
coroutineList[l] = base.StartCoroutine(this.ReadFacility(readFacility[l]));
}
for (int i = 0; i < 6; i++)
{
yield return(coroutineList[i]);
}
farmRoot.ResetSetteingFence();
yield break;
}
private IEnumerator HitCheckBuild()
{
FarmRoot farmRoot = FarmRoot.Instance;
FarmField farmField = farmRoot.Field;
List <FarmGrid.Grid> grids = farmField.GetField().grids;
while (base.gameObject.activeSelf)
{
while (!this.digimon.activeSelf)
{
yield return(new WaitForSeconds(1f));
}
while (!this.CheckHitBuild(farmField.Grid, grids))
{
yield return(new WaitForSeconds(0.5f));
}
}
yield break;
}
public void ResumeFarmObject()
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
field.ClearPutFlag();
List <UserFacility> userFacilityList = Singleton <UserDataMng> .Instance.GetUserFacilityList();
for (int i = 0; i < userFacilityList.Count; i++)
{
UserFacility userFacility = userFacilityList[i];
FarmObject farmObject = this.FindFarmObjectByUserFacilityId(userFacility.userFacilityId);
if (null != farmObject)
{
this.SetFarmObjectParam(farmObject, userFacility);
}
}
instance.ResetSetteingFence();
}
private void SetFarmObjectParam(FarmObject farmObject, UserFacility userFacility)
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
FarmGrid.GridPosition gridPosition = new FarmGrid.GridPosition
{
x = userFacility.positionX,
y = userFacility.positionY
};
int gridIndex = field.Grid.GetGridIndex(gridPosition);
Vector3 positionGridCenter = field.Grid.GetPositionGridCenter(gridIndex, false);
farmObject.SetPosition(field.gridHorizontal, field.gridVertical, positionGridCenter);
field.SetPutFlag(farmObject, gridPosition.x, gridPosition.y, true);
if (!string.IsNullOrEmpty(userFacility.completeTime))
{
this.StartConstruction(userFacility.userFacilityId);
}
}
private IEnumerator SaveFarmObjectMove()
{
FarmRoot farmRoot = FarmRoot.Instance;
FarmField farmField = farmRoot.Field;
FarmObjectSetting farmObjectSetting = base.GetComponent <FarmObjectSetting>();
FarmGrid.GridPosition gridPosition = farmField.Grid.GetGridPosition(this.farmObject.GetBaseGridPosition3D());
FarmGrid.GridPosition gridBackupPosition = farmField.Grid.GetGridPosition(this.farmObject.GetBackupGridPosition3D());
if (gridPosition.x != gridBackupPosition.x || gridPosition.y != gridBackupPosition.y)
{
RestrictionInput.StartLoad(RestrictionInput.LoadType.SMALL_IMAGE_MASK_OFF);
RequestFA_FacilityMoving request = new RequestFA_FacilityMoving
{
SetSendData = delegate(FacilityMoving param)
{
param.userFacilityId = this.farmObject.userFacilityID;
param.positionX = gridPosition.x;
param.positionY = gridPosition.y;
},
OnReceived = delegate(WebAPI.ResponseData response)
{
UserFacility userFacility = Singleton <UserDataMng> .Instance.GetUserFacility(this.farmObject.userFacilityID);
userFacility.positionX = gridPosition.x;
userFacility.positionY = gridPosition.y;
}
};
yield return(base.StartCoroutine(request.Run(delegate()
{
RestrictionInput.EndLoad();
this.MoveComplate(farmRoot, farmObjectSetting);
}, null, null)));
}
else
{
this.MoveComplate(farmRoot, farmObjectSetting);
}
yield break;
}
public bool OnDrag(InputControll inputControll)
{
if (this.farmObject.gameObject == inputControll.rayHitColliderObject)
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
if (field.Grid.isSelectedGrid)
{
FarmField.Field field2 = field.GetField();
int[] gridIndexs = this.farmObject.GetGridIndexs(field2, field.Grid.selectedGridIndex);
if (!this.farmObject.IsInvalidGrid(field, gridIndexs))
{
this.farmObject.SetPosition(field.gridHorizontal, field.gridVertical, field.Grid.GetPositionGridCenter(field.Grid.selectedGridIndex, false));
this.farmObject.DisplayedInFront(true);
bool placeable = false == this.farmObject.IsPutGrid(field2, gridIndexs);
this.farmObject.SetPlaceable(placeable);
}
}
return(true);
}
return(false);
}
public static int[] GetAroundGridIndexs(int[] gridIndexs)
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
List <FarmGrid.GridPosition> list = new List <FarmGrid.GridPosition>();
List <int> list2 = new List <int>();
for (int i = 0; i < gridIndexs.Length; i++)
{
FarmGrid.GridPosition item = field.Grid.IndexToPosition(gridIndexs[i]);
list.Add(item);
}
for (int j = 0; j < list.Count; j++)
{
FarmGrid.GridPosition gridPosition = list[j];
int index = field.Grid.GetGridIndex(gridPosition.x - 1, gridPosition.y);
if (index != -1 && !gridIndexs.Any((int x) => x == index) && !list2.Any((int x) => x == index))
{
list2.Add(index);
}
index = field.Grid.GetGridIndex(gridPosition.x + 1, gridPosition.y);
if (index != -1 && !gridIndexs.Any((int x) => x == index) && !list2.Any((int x) => x == index))
{
list2.Add(index);
}
index = field.Grid.GetGridIndex(gridPosition.x, gridPosition.y - 1);
if (index != -1 && !gridIndexs.Any((int x) => x == index) && !list2.Any((int x) => x == index))
{
list2.Add(index);
}
index = field.Grid.GetGridIndex(gridPosition.x, gridPosition.y + 1);
if (index != -1 && !gridIndexs.Any((int x) => x == index) && !list2.Any((int x) => x == index))
{
list2.Add(index);
}
}
return(list2.ToArray());
}
public bool SetEditFarmObject(FarmObject farmObject, Vector3 basePos3D)
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
FarmField.Field field2 = field.GetField();
this.farmObject = farmObject;
this.settingMode = FarmObjectSetting.SettingMode.EDIT;
FarmGrid.GridPosition gridPosition = field.Grid.GetGridPosition(basePos3D);
bool flag = field.IsOutsideField(gridPosition);
if (flag)
{
gridPosition = field.Grid.GetGridPosition(Vector3.zero);
}
int gridIndex = field.Grid.GetGridIndex(gridPosition);
Vector3 positionGridCenter = field.Grid.GetPositionGridCenter(gridIndex, false);
this.farmObject.SetPosition(field.gridHorizontal, field.gridVertical, positionGridCenter);
this.farmObject.DisplayedInFront(true);
int[] gridIndexs = this.farmObject.GetGridIndexs(field2, gridIndex);
this.farmObject.isPlaceable = (!this.farmObject.IsInvalidGrid(field, gridIndexs) && !this.farmObject.IsPutGrid(field2, gridIndexs));
return(flag);
}
public bool SetFarmObject(FarmObject farmObject, Vector3 basePos3D)
{
FarmField field = FarmRoot.Instance.Field;
this.farmObject = farmObject;
this.settingMode = FarmObjectSetting.SettingMode.BUILD;
this.farmObject.SetSettingMark(field, FarmRoot.Instance.SettingMark);
FarmGrid.GridPosition gridPosition = field.Grid.GetGridPosition(basePos3D);
bool flag = field.IsOutsideField(gridPosition);
if (flag)
{
gridPosition = field.Grid.GetGridPosition(Vector3.zero);
}
int gridIndex = field.Grid.GetGridIndex(gridPosition);
Vector3 positionGridCenter = field.Grid.GetPositionGridCenter(gridIndex, false);
this.farmObject.SetPosition(field.gridHorizontal, field.gridVertical, positionGridCenter);
this.farmObject.DisplayedInFront(true);
FarmField.Field field2 = field.GetField();
this.farmObject.SetMarkColor(field2, gridIndex);
FarmRoot.Instance.Input.AddTouchDragEvent(new Func <InputControll, bool>(this.OnDrag));
return(flag);
}
public FarmGrid(FarmField farmField)
{
this.farmField = farmField;
}
