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 bool SearchPutGrid(FarmObjectSetting.ExtendBuildPositionSearchInfo searchInfo)
{
bool result = false;
searchInfo.isOutsideMap = true;
FarmGrid.GridPosition startGrid = searchInfo.startGrid;
while (startGrid.x != searchInfo.endGrid.x && startGrid.y != searchInfo.endGrid.y)
{
if (!searchInfo.farmField.IsOutsideField(startGrid))
{
searchInfo.isOutsideMap = false;
int gridIndex = searchInfo.farmField.Grid.GetGridIndex(startGrid);
int[] gridIndexs = searchInfo.oneBeforeFarmObject.GetGridIndexs(searchInfo.field, gridIndex);
if (!searchInfo.oneBeforeFarmObject.IsInvalidGrid(searchInfo.farmField, gridIndexs) && !searchInfo.oneBeforeFarmObject.IsPutGrid(searchInfo.field, gridIndexs))
{
result = true;
searchInfo.resultGrid = startGrid;
break;
}
}
startGrid.x += searchInfo.changeValue.x;
startGrid.y += searchInfo.changeValue.y;
}
return(result);
}
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
});
}
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 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 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));
}
private static void CheckAroundGrids(FarmGrid farmGrid, List <FarmGrid.Grid> fieldGrids, int centerGridIndex, List <int> aroundGridIndexs, bool isIgnorePutedFlag)
{
FarmGrid.GridPosition gridPosition = farmGrid.IndexToPosition(centerGridIndex);
int num = FarmDigimonUtility.CheckGrid(farmGrid, fieldGrids, gridPosition.x, gridPosition.y - 1, isIgnorePutedFlag);
if (num != -1)
{
aroundGridIndexs.Add(num);
}
num = FarmDigimonUtility.CheckGrid(farmGrid, fieldGrids, gridPosition.x, gridPosition.y + 1, isIgnorePutedFlag);
if (num != -1)
{
aroundGridIndexs.Add(num);
}
num = FarmDigimonUtility.CheckGrid(farmGrid, fieldGrids, gridPosition.x - 1, gridPosition.y, isIgnorePutedFlag);
if (num != -1)
{
aroundGridIndexs.Add(num);
}
num = FarmDigimonUtility.CheckGrid(farmGrid, fieldGrids, gridPosition.x + 1, gridPosition.y, isIgnorePutedFlag);
if (num != -1)
{
aroundGridIndexs.Add(num);
}
}
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 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 bool GetAroundGridIndexsForPath(FarmGrid farmGrid, int centerGridIndex, FarmDigimonUtility.PathInfo[] path, List <int> aroundGridIndexs)
{
FarmGrid.GridPosition gridPosition = farmGrid.IndexToPosition(centerGridIndex);
for (int i = 0; i < path.Length; i++)
{
FarmGrid.GridPosition gridPosition2 = farmGrid.IndexToPosition(path[i].gridIndex);
if ((gridPosition2.x == gridPosition.x - 1 && gridPosition2.y == gridPosition.y) || (gridPosition2.x == gridPosition.x + 1 && gridPosition2.y == gridPosition.y) || (gridPosition2.x == gridPosition.x && gridPosition2.y == gridPosition.y - 1) || (gridPosition2.x == gridPosition.x && gridPosition2.y == gridPosition.y + 1))
{
aroundGridIndexs.Add(path[i].gridIndex);
}
}
return(0 < aroundGridIndexs.Count);
}
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 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);
}
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);
}
}
public void UpdateSelectGrid(Vector3 touchPos)
{
this.isSelectedGrid = false;
FarmField.Field field = this.farmField.GetField();
if (field == null)
{
return;
}
Rect rect = new Rect(field.originPosition.x, field.originPosition.y, (float)field.fieldHorizontal * this.farmField.gridHorizontal, (float)field.fieldVertical * this.farmField.gridVertical);
if (rect.x <= touchPos.x && touchPos.x <= rect.x + rect.width && rect.y >= touchPos.z && touchPos.z >= rect.y - rect.height)
{
FarmGrid.GridPosition gridPosition = this.GetGridPosition(touchPos);
int gridIndex = this.GetGridIndex(gridPosition);
if (0 <= gridIndex && gridIndex <= field.grids.Count)
{
this.isSelectedGrid = true;
this.selectedGridIndex = gridIndex;
}
}
}
public void SetPutFlag(FarmObject farmObject, int gridX, int gridY, bool putFlag)
{
FarmField.Field field = this.GetField();
FarmGrid.GridPosition gridPosition = farmObject.AdjustGridPosition(gridX, gridY);
bool impassable = !FarmUtility.IsWalkBuild(farmObject.facilityID);
for (int i = 0; i < farmObject.sizeY; i++)
{
int num = (gridPosition.y + i) * field.fieldHorizontal;
for (int j = 0; j < farmObject.sizeX; j++)
{
int num2 = num + gridPosition.x + j;
if (num2 >= 0 && field.grids.Count > num2)
{
FarmGrid.Grid value = field.grids[num2];
value.put = putFlag;
value.impassable = impassable;
field.grids[num2] = value;
}
}
}
}
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 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 int GetGridIndex(FarmGrid.GridPosition gridPosition)
{
FarmField.Field field = this.farmField.GetField();
return(gridPosition.y * field.fieldHorizontal + gridPosition.x);
}
public bool IsOutsideField(FarmGrid.GridPosition gridPosition)
{
FarmField.Field field = this.GetField();
return(0 > gridPosition.x || 0 > gridPosition.y || field.fieldHorizontal <= gridPosition.x || field.fieldVertical <= gridPosition.y);
}
public FarmGrid.GridPosition SetGridPutFlag(FarmObject farmObject, bool putFlag)
{
FarmGrid.GridPosition gridPosition = this.farmGrid.GetGridPosition(farmObject.GetBaseGridPosition3D());
this.SetPutFlag(farmObject, gridPosition.x, gridPosition.y, putFlag);
return(gridPosition);
}
public static List <FarmDigimonUtility.PathInfo> GetPath(int startGridIndex, int endGridIndex)
{
FarmRoot instance = FarmRoot.Instance;
FarmField field = instance.Field;
List <FarmGrid.Grid> grids = instance.Field.GetField().grids;
bool[] array = new bool[grids.Count];
List <FarmDigimonUtility.PathInfo> list = new List <FarmDigimonUtility.PathInfo>();
int num = 0;
List <int> list2 = new List <int>();
List <int> list3 = new List <int>();
list2.Add(startGridIndex);
list.Add(new FarmDigimonUtility.PathInfo
{
gridIndex = startGridIndex
});
if (startGridIndex == endGridIndex)
{
return(list);
}
bool flag = false;
FarmGrid.GridPosition gridPosition = field.Grid.IndexToPosition(startGridIndex);
if (FarmDigimonUtility.CheckGrid(field.Grid, grids, gridPosition.x, gridPosition.y, false) == -1)
{
flag = true;
}
while (0 < list2.Count)
{
num++;
for (int i = 0; i < list2.Count; i++)
{
FarmDigimonUtility.CheckAroundGrids(field.Grid, grids, list2[i], list3, false);
}
if (flag)
{
if (0 >= list3.Count)
{
for (int j = 0; j < list2.Count; j++)
{
FarmDigimonUtility.CheckAroundGrids(field.Grid, grids, list2[j], list3, true);
}
}
else
{
flag = false;
}
}
list2.Clear();
for (int k = 0; k < list3.Count; k++)
{
int num2 = list3[k];
if (!array[num2])
{
array[num2] = true;
list2.Add(num2);
list.Add(new FarmDigimonUtility.PathInfo
{
gridIndex = num2,
checkPoint = num
});
if (endGridIndex == num2)
{
return(list);
}
}
}
list3.Clear();
}
return(null);
}
public void ResetSetteingFence()
{
List <FarmObject> list = this.Scenery.farmObjects.Where((FarmObject x) => x.transform.localPosition.y < 8000f).ToList <FarmObject>();
int[,] array = new int[this.Field.GetField().fieldHorizontal, this.Field.GetField().fieldVertical];
List <UserFacility> list2 = new List <UserFacility>();
for (int k = 0; k < list.Count; k++)
{
if (list[k].facilityID == 11)
{
FarmGrid.GridPosition gridPosition = this.Field.Grid.GetGridPosition(list[k].GetBaseGridPosition3D());
UserFacility item = new UserFacility
{
userFacilityId = list[k].userFacilityID,
facilityId = list[k].facilityID,
positionX = gridPosition.x,
positionY = gridPosition.y,
level = 0,
completeTime = string.Empty
};
list2.Add(item);
array[gridPosition.x, gridPosition.y] = 1;
}
}
int i;
for (i = 0; i < this.Field.GetField().fieldVertical; i++)
{
int j;
for (j = 0; j < this.Field.GetField().fieldHorizontal; j++)
{
if (array[j, i] > 0)
{
UserFacility fence = list2.First((UserFacility x) => x.positionX == j && x.positionY == i);
FarmObject farmObject = list.First((FarmObject x) => x.userFacilityID == fence.userFacilityId);
FarmObject_Fence farmObject_Fence = (FarmObject_Fence)farmObject;
bool flag = i - 1 >= 0 && array[j, i - 1] > 0;
bool flag2 = j + 1 < this.Field.GetField().fieldHorizontal&& array[j + 1, i] > 0;
bool flag3 = i + 1 < this.Field.GetField().fieldVertical&& array[j, i + 1] > 0;
bool flag4 = j - 1 >= 0 && array[j - 1, i] > 0;
int num = 0;
if (flag && flag2 && flag3 && flag4)
{
farmObject_Fence.ChangeFenceType(FarmObject_Fence.Type.Mesh03);
}
else if ((flag && flag3 && (flag2 || flag4)) || (flag2 && flag4 && (flag || flag3)))
{
if (flag && flag3 && flag2)
{
num = 270;
}
else if (flag && flag3 && flag4)
{
num = 90;
}
else if (flag2 && flag4 && flag)
{
num = 180;
}
else if (flag2 && flag4 && flag3)
{
num = 360;
}
farmObject_Fence.ChangeFenceType(FarmObject_Fence.Type.Mesh04);
}
else if ((flag && (flag2 || flag4)) || (flag3 && (flag2 || flag4)))
{
if (flag && flag2)
{
num = 90;
}
else if (flag && flag4)
{
num = 360;
}
else if (flag3 && flag2)
{
num = 180;
}
else if (flag3 && flag4)
{
num = 270;
}
farmObject_Fence.ChangeFenceType(FarmObject_Fence.Type.Mesh02);
}
else if (flag || flag3)
{
num = 90;
farmObject_Fence.ChangeFenceType(FarmObject_Fence.Type.Mesh01);
}
else
{
farmObject_Fence.ChangeFenceType(FarmObject_Fence.Type.Mesh01);
}
farmObject_Fence.transform.localRotation = Quaternion.Euler(0f, (float)num, 0f);
}
}
}
}
