void AddSugorokuPoint(FieldConnectPoint sugorokuPoint, int masuType)
{
usedList[sugorokuPoint.Index] = true;
sugorokuPoints.Add(sugorokuPoint);
masuTypes.Add(masuType);
if (IsExtendablePoint(sugorokuPoint) != false)
{
extendablePoints.Add(sugorokuPoint);
}
List <FieldConnectPoint> connectedPoints = allPoints[sugorokuPoint.Index].ConnectionList;
for (int i0 = 0; i0 < connectedPoints.Count; ++i0)
{
FieldConnectPoint connectedPoint = connectedPoints[i0];
int index = extendablePoints.FindIndex(point => point.Index == connectedPoint.Index);
if (index > 0)
{
if (IsExtendablePoint(extendablePoints[index]) == false)
{
extendablePoints.RemoveAt(index);
}
}
}
}
bool TryGetCommonPoint(FieldConnectPoint point1, FieldConnectPoint point2, out FieldConnectPoint commonPoint)
{
bool foundCommonPoint = false;
commonPoint = null;
List <FieldConnectPoint> connectedPoints = point1.ConnectionList;
List <FieldConnectPoint> connectedPoints2 = point2.ConnectionList;
FieldConnectPoint basePoint = sugorokuPoints[sugorokuPoints.FindIndex(p => p.Index == point1.Index)];
for (int i0 = 0; i0 < connectedPoints.Count; ++i0)
{
FieldConnectPoint connectedPoint = connectedPoints[i0];
if (connectedPoint.Index != point2.Index)
{
for (int i1 = 0; i1 < connectedPoints2.Count; ++i1)
{
FieldConnectPoint connectedPoint2 = connectedPoints2[i1];
if (connectedPoint.Index == connectedPoint2.Index && usedList[connectedPoint.Index] == false)
{
foundCommonPoint = true;
commonPoint = connectedPoint;
break;
}
}
}
if (foundCommonPoint != false)
{
break;
}
}
return(foundCommonPoint);
}
public IEnumerator SugorokuMapCreate(SugorokuMapParameter parameter)
{
lastInterruptionTime = System.DateTime.Now;
this.parameter = parameter;
sugorokuPoints.Clear();
masuTypes.Clear();
pointDataList.Clear();
extendablePoints.Clear();
var startPoint = new FieldConnectPoint();
startPoint.Initialize(allPoints[startIndex].Position, 0);
startPoint.Index = startIndex;
extendablePoints.Add(startPoint);
sugorokuPoints.Add(startPoint);
masuTypes.Add(0);
usedList[startIndex] = true;
int sugorokuSize = Mathf.Min(parameter.sugorokuSize, allPoints.Count);
int minAisleSize = parameter.minAisleSize;
int maxAisleSize = parameter.maxAisleSize;
int count = 0;
while (sugorokuPoints.Count < sugorokuSize && count < sugorokuSize)
{
int aisleSize = random.Next(minAisleSize, maxAisleSize + 1);
GenerateAisles(aisleSize);
++count;
if (ShouldInterrupt() != false)
{
yield return(null);
lastInterruptionTime = System.DateTime.Now;
}
}
for (int i0 = 0; i0 < sugorokuPoints.Count; ++i0)
{
FieldConnectPoint sugorokuPoint = sugorokuPoints[i0];
var data = new SugorokuPointData();
data.SetPosition(sugorokuPoint.Position);
data.SetRoomType(masuTypes[i0]);
data.SetIndex(sugorokuPoint.Index);
var indexList = new List <int>();
for (int i1 = 0; i1 < sugorokuPoint.ConnectionList.Count; ++i1)
{
indexList.Add(sugorokuPoint.ConnectionList[i1].Index);
}
data.SetConnectionIndexList(indexList);
data.SetMassType(0);
data.SetMassParam(0, 0);
pointDataList.Add(data);
}
}
/**
* すごろくマップの生成
*/
public IEnumerator SugorokuMapCreate()
{
var candidateList = new List <FieldConnectPoint>();
var initPoint = new FieldConnectPoint();
int count = 0;
//int index = GetCenterPositionIndex();
int index = 0;
startIndex = index;
sugorokuPointList.Clear();
sugorokuDataList.Clear();
// スタート地点
initPoint.Initialize(pointList[index].Position, 0);
initPoint.Index = index;
pointTypeList[index] = 1;
sugorokuPointList.Add(initPoint);
candidateList.Add(initPoint);
sugorokuDataList.Add(0);
/* 候補となるポイントが無くなるか一定回数行う */
while (candidateList.Count > 0)
{
PassCreate(pointList, sugorokuPointList, candidateList, pointTypeList, 3);
++count;
if (count > 25)
{
candidateList.Clear();
}
}
sugorokuPointDataList = new List <SugorokuPointData>();
for (int i0 = 0; i0 < sugorokuPointList.Count; ++i0)
{
var data = new SugorokuPointData();
data.SetPosition(sugorokuPointList[i0].Position);
data.SetRoomType(sugorokuDataList[i0]);
data.SetIndex(sugorokuPointList[i0].Index);
var indexList = new List <int>();
for (int i1 = 0; i1 < sugorokuPointList[i0].ConnectionList.Count; ++i1)
{
indexList.Add(sugorokuPointList[i0].ConnectionList[i1].Index);
}
data.SetConnectionIndexList(indexList);
data.SetMassType(0);
data.SetMassParam(0, 0);
sugorokuPointDataList.Add(data);
}
yield break;
}
IEnumerator CreateMeshParameter(List <FieldConnectPoint> points, float uvY1, float uvY2, float decalSize)
{
vertices.Clear();
uvs.Clear();
decalUvs.Clear();
indices.Clear();
indicesMap.Clear();
judgedCombinationSet.Clear();
disconnectCombinationSet.Clear();
for (int i0 = 0; i0 < points.Count; ++i0)
{
FieldConnectPoint point = points[i0];
List <float> widthList = point.WidthList;
var connectPoints = new List <FieldConnectPoint>(point.ConnectionList);
if (connectPoints.Count != 0)
{
if (connectPoints.Count == 1)
{
FieldConnectPoint p = connectPoints[0];
Vector3 dir = p.Position - point.Position;
dir.Normalize();
float halfWidth = widthList[0] * 0.5f;
var left = new Vector3(-dir.z, 0, dir.x) * halfWidth + point.Position;
var right = new Vector3(dir.z, 0, -dir.x) * halfWidth + point.Position;
int leftIndex = vertices.Count;
int rightIndex = leftIndex + 1;
vertices.Add(left);
uvs.Add(new Vector2(0.5f, (uvY1 + uvY2) * 0.5f));
vertices.Add(right);
uvs.Add(new Vector2(0.5f, (uvY1 + uvY2) * 0.5f));
decalUvs.Add(new Vector2(left.x / decalSize, left.z / decalSize));
decalUvs.Add(new Vector2(right.x / decalSize, right.z / decalSize));
Dictionary <int, int[]> map;
if (indicesMap.TryGetValue(point.Index, out map) == false)
{
map = new Dictionary <int, int[]>();
indicesMap.Add(point.Index, map);
}
map.Add(p.Index, new int[] { leftIndex, rightIndex });
if (indicesMap.TryGetValue(p.Index, out map) != false)
{
if (map.TryGetValue(point.Index, out int[] indexLR) != false)
bool IsExtendablePoint(FieldConnectPoint point)
{
bool extendable = false;
List <FieldConnectPoint> connectedPoints = allPoints[point.Index].ConnectionList;
for (int i0 = 0; i0 < connectedPoints.Count; ++i0)
{
if (usedList[connectedPoints[i0].Index] == false)
{
extendable = true;
break;
}
}
return(extendable);
}
void GenerateAisles(int aisleSize)
{
int index = random.Next(extendablePoints.Count);
for (int i0 = 0; i0 < aisleSize && sugorokuPoints.Count < parameter.sugorokuSize; ++i0)
{
FieldConnectPoint extendablePoint = extendablePoints[index];
FieldConnectPoint point = allPoints[extendablePoint.Index];
List <FieldConnectPoint> connectedPoints = point.ConnectionList;
if (connectedPoints.Count - extendablePoint.ConnectionList.Count > 0)
{
var candidates = new List <FieldConnectPoint>();
for (int i1 = 0; i1 < connectedPoints.Count; ++i1)
{
FieldConnectPoint connectedPoint = connectedPoints[i1];
if (usedList[connectedPoint.Index] == false)
{
candidates.Add(connectedPoint);
}
}
if (candidates.Count > 0)
{
FieldConnectPoint nextPointSrc = candidates[random.Next(candidates.Count)];
var sugorokuPoint = new FieldConnectPoint();
sugorokuPoint.Initialize(nextPointSrc.Position, 0);
sugorokuPoint.Index = nextPointSrc.Index;
ConnectPoints(extendablePoint, sugorokuPoint);
AddSugorokuPoint(sugorokuPoint, 0);
index = extendablePoints.Count - 1;
}
}
}
int roomSize = random.Next(parameter.minRoomSize, parameter.maxRoomSize + 1);
GenerateRoom(index, roomSize);
}
public void SetSerializedData(SugorokuSerializedData data)
{
int i0, i1;
sugorokuPointDataList = data.GetPointDataList();
sugorokuPointList.Clear();
sugorokuDataList.Clear();
for (i0 = 0; i0 < sugorokuPointDataList.Count; ++i0)
{
var point = new FieldConnectPoint();
point.Initialize(sugorokuPointDataList[i0].GetPosition(), PointType.kGridRoad);
point.Index = sugorokuPointDataList[i0].GetIndex();
sugorokuDataList.Add(sugorokuPointDataList[i0].GetRoomType());
sugorokuPointList.Add(point);
}
for (i0 = 0; i0 < sugorokuPointDataList.Count; ++i0)
{
var indexList = sugorokuPointDataList[i0].GetConnectionIndexList();
for (i1 = 0; i1 < indexList.Count; ++i1)
{
sugorokuPointList[i0].SetConnection(sugorokuPointList[indexList[i1]]);
}
}
startIndex = data.GetStartIndex();
goalIndex = data.GetGoalIndex();
if (pointList == null)
{
pointList = new List <FieldConnectPoint>();
}
pointList.Clear();
pointList.AddRange(sugorokuPointList);
}
public void SetSerializedData(SugorokuSerializedData data)
{
pointDataList = data.GetPointDataList();
sugorokuPoints.Clear();
masuTypes.Clear();
for (int i0 = 0; i0 < pointDataList.Count; ++i0)
{
var point = new FieldConnectPoint();
SugorokuPointData pointData = pointDataList[i0];
point.Initialize(pointData.GetPosition(), PointType.kGridRoad);
point.Index = pointData.GetIndex();
masuTypes.Add(pointData.GetRoomType());
sugorokuPoints.Add(point);
}
for (int i0 = 0; i0 < pointDataList.Count; ++i0)
{
var indexList = pointDataList[i0].GetConnectionIndexList();
for (int i1 = 0; i1 < indexList.Count; ++i1)
{
sugorokuPoints[i0].SetConnection(sugorokuPoints[indexList[i1]]);
}
}
startIndex = data.GetStartIndex();
goalIndex = data.GetGoalIndex();
if (allPoints == null)
{
allPoints = new List <FieldConnectPoint>();
}
allPoints.Clear();
allPoints.AddRange(sugorokuPoints);
}
/**
* 部屋を拡張する
*
* @param list マスとして使用可能なポイントのリスト
* @param save_list すごろくマスとして新たに生成したポイントのリスト
* @param enable_list 伸ばす余地のあるすごろくマスのリスト
* @param room_list 同じ部屋のすごろくマスのリスト
* @param use_type_list マスの使用状況
*/
void ExtendRoom(List <FieldConnectPoint> list, List <FieldConnectPoint> save_list, List <FieldConnectPoint> enable_list,
List <FieldConnectPoint> room_list, List <int> use_type_list)
{
var idx_list = new List <int>(); // 拡張候補のマスのインデックス
var room_idx_list = new List <int>(); // 拡張候補のマスがどの部屋からなのかのインデックス
var extend_idx_list = new List <int>(); // さらに拡張する際の候補となるidx_listのインデックス
FieldConnectPoint tmp_point, tmp_point2, tmp_point3;
int i0, i1, idx, tmp_idx, rand;
for (i0 = 0; i0 < room_list.Count; ++i0)
{
idx = room_list[i0].Index;
tmp_point = list[idx];
for (i1 = 0; i1 < tmp_point.ConnectionList.Count; ++i1)
{
tmp_idx = tmp_point.ConnectionList[i1].Index;
if (use_type_list[tmp_idx] == 0)
{
room_idx_list.Add(i0);
idx_list.Add(tmp_idx);
}
}
}
/* 拡張できるマスが無いので終了 */
if (room_idx_list.Count <= 0)
{
return;
}
/* すごろくマスの生成 */
rand = randomSystem.Next(0, room_idx_list.Count);
idx = idx_list[rand];
tmp_point2 = room_list[room_idx_list[rand]];
tmp_point = new FieldConnectPoint();
tmp_point.Initialize(list[idx].Position, 0);
tmp_point.Index = list[idx].Index;
tmp_point.SetConnection(tmp_point2);
tmp_point2.SetConnection(tmp_point);
enable_list.Add(tmp_point);
room_list.Add(tmp_point);
save_list.Add(tmp_point);
sugorokuDataList.Add(1);
use_type_list[tmp_point.Index] = 1;
/* 伸ばしたマスからさらに伸ばした時に、部屋と繋がるマスがあるかどうか調べる */
for (i0 = 0; i0 < list[idx].ConnectionList.Count; ++i0)
{
tmp_idx = list[idx].ConnectionList[i0].Index;
for (i1 = 0; i1 < idx_list.Count; ++i1)
{
if (idx_list[i1] == tmp_idx)
{
extend_idx_list.Add(i1);
}
}
}
/* さらに拡張できるマスが無いので終了 */
if (extend_idx_list.Count <= 0)
{
return;
}
rand = randomSystem.Next(0, extend_idx_list.Count);
tmp_idx = extend_idx_list[rand];
idx = idx_list[tmp_idx];
tmp_point3 = room_list[room_idx_list[tmp_idx]];
tmp_point2 = new FieldConnectPoint();
tmp_point2.Initialize(list[idx].Position, 0);
tmp_point2.Index = list[idx].Index;
tmp_point3.SetConnection(tmp_point2);
tmp_point2.SetConnection(tmp_point3);
tmp_point.SetConnection(tmp_point2);
tmp_point2.SetConnection(tmp_point);
enable_list.Add(tmp_point2);
room_list.Add(tmp_point2);
save_list.Add(tmp_point2);
sugorokuDataList.Add(1);
use_type_list[tmp_point2.Index] = 1;
}
/**
* 四角の部屋を作る
*
* @param list マスとして使用可能なポイントのリスト
* @param save_list すごろくマスとして新たに生成したポイントのリスト
* @param enable_list 伸ばす余地のあるすごろくマスのリスト
* @param use_type_list マスの使用状況
* @param save_idx 部屋を生成する起点となるすごろくマスのインデックス
* @param room_extend_num 部屋を拡張する回数
*/
void SquareRoomCreate(List <FieldConnectPoint> list, List <FieldConnectPoint> save_list, List <FieldConnectPoint> enable_list, List <int> use_type_list, int save_idx,
int room_extend_num = 0)
{
FieldConnectPoint center_point, tmp_point, tmp_point2;
var room_mass_list = new List <FieldConnectPoint>();
var tmp_list = new List <int>();
var tmp_list2 = new List <int>();
int i0, i1, i2, i3, tmp_i, no;
bool flg;
var list_idx_tbl = new int[3];
var field_tbl = new FieldConnectPoint[3];
center_point = save_list[save_idx];
tmp_point = list[center_point.Index];
room_mass_list.Add(center_point);
for (i0 = 0; i0 < tmp_point.ConnectionList.Count; ++i0)
{
tmp_i = tmp_point.ConnectionList[i0].Index;
if (use_type_list[tmp_i] == 0)
{
tmp_list.Add(tmp_i);
}
}
if (tmp_list.Count <= 1)
{
return;
}
flg = false;
/*! 2方向に伸ばして、伸ばした2方向で共通の点がある場合は伸ばす */
for (i0 = 0; i0 < tmp_list.Count; ++i0)
{
tmp_point = list[tmp_list[i0]];
tmp_list2.Clear();
/* 伸ばせる方向のインデックスを調べる */
for (i1 = 0; i1 < tmp_point.ConnectionList.Count; i1++)
{
tmp_i = tmp_point.ConnectionList[i1].Index;
if (use_type_list[tmp_i] == 0)
{
tmp_list2.Add(tmp_i);
}
}
for (i1 = 0; i1 < tmp_list.Count; ++i1)
{
if (i0 == i1)
{
continue;
}
tmp_point2 = list[tmp_list[i1]];
for (i2 = 0; i2 < tmp_list2.Count; ++i2)
{
for (i3 = 0; i3 < tmp_point2.ConnectionList.Count; ++i3)
{
/* 2方向の伸ばした場所が共通のマスと繋がる場所がある場合（四角の4マスが繋がるような部屋を作る） */
if (tmp_list2[i2] == tmp_point2.ConnectionList[i3].Index)
{
list_idx_tbl[0] = tmp_list[i0];
list_idx_tbl[1] = tmp_list[i1];
list_idx_tbl[2] = tmp_list2[i2];
flg = true;
i0 = tmp_list.Count;
i1 = tmp_list.Count;
i2 = tmp_list2.Count;
i3 = tmp_point2.ConnectionList.Count;
}
}
}
}
}
if (flg != false)
{
sugorokuDataList[sugorokuDataList.Count - 1] = 1;
/*! 新しいマス3つを生成する */
for (i0 = 0; i0 < 3; ++i0)
{
field_tbl[i0] = new FieldConnectPoint();
no = list_idx_tbl[i0];
field_tbl[i0].Initialize(list[no].Position, 0);
field_tbl[i0].Index = list[no].Index;
save_list.Add(field_tbl[i0]);
enable_list.Add(field_tbl[i0]);
use_type_list[field_tbl[i0].Index] = 1;
room_mass_list.Add(field_tbl[i0]);
sugorokuDataList.Add(1);
}
/*! 新しく生成したマスを相互に接続する */
field_tbl[0].SetConnection(center_point);
center_point.SetConnection(field_tbl[0]);
field_tbl[1].SetConnection(center_point);
center_point.SetConnection(field_tbl[1]);
field_tbl[0].SetConnection(field_tbl[2]);
field_tbl[2].SetConnection(field_tbl[0]);
field_tbl[1].SetConnection(field_tbl[2]);
field_tbl[2].SetConnection(field_tbl[1]);
}
/* 部屋の拡張 */
while (room_extend_num > 0)
{
ExtendRoom(list, save_list, enable_list, room_mass_list, use_type_list);
room_extend_num--;
}
}
/**
* 候補のリストから通路と部屋を作る処理
*
* @param list マスとして使用可能なポイントのリスト
* @param save_list すごろくマスとして新たに生成したポイントのリスト
* @param enable_list 伸ばす余地のあるすごろくマスのリスト
* @param use_type_list マスの使用状況
* @param pass_num 通路の数。0の場合は通路作成後に部屋の生成を行う。
* @param use_enable_index 通路を伸ばすすごろくマスの指定。-1の場合はランダムなすごろくマスを使う。
*/
void PassCreate(List <FieldConnectPoint> list, List <FieldConnectPoint> save_list, List <FieldConnectPoint> enable_list, List <int> use_type_list,
int pass_num = 1, int use_enable_index = -1)
{
int i0, index, randomIndex, count, tmp_i;
FieldConnectPoint tmp_point, tmp_point2;
var tmp_list = new List <int>();
bool flg = false;
if (use_enable_index < 0)
{
randomIndex = randomSystem.Next(0, enable_list.Count);
}
else
{
randomIndex = use_enable_index;
}
index = enable_list[randomIndex].Index;
tmp_point = list[index];
index = randomIndex;
/*! 残りの接続数がいくつか調べる */
count = tmp_point.ConnectionList.Count - enable_list[index].ConnectionList.Count;
if (count > 0)
{
tmp_list.Clear();
for (i0 = 0; i0 < tmp_point.ConnectionList.Count; ++i0)
{
tmp_i = tmp_point.ConnectionList[i0].Index;
if (use_type_list[tmp_i] == 0)
{
tmp_list.Add(i0);
}
}
if (tmp_list.Count > 0)
{
/*! 通路として繋ぐ */
randomIndex = randomSystem.Next(0, tmp_list.Count);
randomIndex = tmp_list[randomIndex];
tmp_point2 = new FieldConnectPoint();
tmp_point2.Initialize(tmp_point.ConnectionList[randomIndex].Position, 0);
tmp_point2.Index = tmp_point.ConnectionList[randomIndex].Index;
use_type_list[tmp_point2.Index] = 1;
tmp_point2.SetConnection(enable_list[index]);
enable_list[index].SetConnection(tmp_point2);
enable_list.Add(tmp_point2);
save_list.Add(tmp_point2);
sugorokuDataList.Add(0);
--pass_num;
if (pass_num <= 0)
{
/*! 四角の部屋を作る */
SquareRoomCreate(list, save_list, enable_list, use_type_list, save_list.Count - 1, 1);
}
else
{
/*! 通路を伸ばす */
PassCreate(list, save_list, enable_list, use_type_list, pass_num, enable_list.Count - 1);
}
flg = true;
}
}
if (flg == false)
{
enable_list.RemoveAt(index);
}
}
void Prepare(List <FieldConnectPoint> points)
{
connectCountMap.Clear();
widthMap.Clear();
for (int i0 = 0; i0 < points.Count; ++i0)
{
FieldConnectPoint point = points[i0];
point.Index = i0;
if (point.Type == PointType.kGridRoad)
{
List <FieldConnectPoint> connectPoints = point.ConnectionList;
int count = connectPoints.Count;
for (int i1 = 0; i1 < connectPoints.Count; ++i1)
{
if (connectPoints[i1].Type != PointType.kGridRoad)
{
--count;
}
}
connectCountMap.Add(i0, count);
}
}
maxWidth = 0;
for (int i0 = 0; i0 < widthCandidates.Length; ++i0)
{
float width = widthCandidates[i0].value;
if (width > maxWidth)
{
maxWidth = width;
}
}
for (int i0 = 0; i0 < points.Count; ++i0)
{
FieldConnectPoint point = points[i0];
List <FieldConnectPoint> connectPoints = point.ConnectionList;
List <float> widthList = point.WidthList;
for (int i1 = connectPoints.Count - 1; i1 >= 0; --i1)
{
FieldConnectPoint connectPoint = connectPoints[i1];
var key1 = new Vector2Int(point.Index, connectPoint.Index);
var key2 = new Vector2Int(connectPoint.Index, point.Index);
float width;
if (widthMap.TryGetValue(key1, out width) == false)
{
width = DetectWeightedValue(widthCandidates);
widthMap.Add(key1, width);
widthMap.Add(key2, width);
}
if (Mathf.Approximately(width, 0) != false)
{
connectPoints.RemoveAt(i1);
}
else
{
widthList.Add(width);
}
}
widthList.Reverse();
}
}
void ConnectPoints(FieldConnectPoint point1, FieldConnectPoint point2)
{
point1.SetConnection(point2);
point2.SetConnection(point1);
}
void GenerateRoom(int basePointIndex, int roomSize = 3)
{
var roomPoints = new List <FieldConnectPoint>();
bool extendable = false;
if (sugorokuPoints.Count <= parameter.sugorokuSize - 2)
{
FieldConnectPoint basePoint = extendablePoints[basePointIndex];
roomPoints.Add(basePoint);
FieldConnectPoint basePointSrc = allPoints[basePoint.Index];
List <FieldConnectPoint> connectedPoints = basePointSrc.ConnectionList;
var candidates = new List <FieldConnectPoint>();
for (int i0 = 0; i0 < connectedPoints.Count; ++i0)
{
FieldConnectPoint connectedPoint = connectedPoints[i0];
if (usedList[connectedPoint.Index] == false)
{
candidates.Add(connectedPoint);
}
}
while (candidates.Count > 0)
{
int randomIndex = random.Next(candidates.Count);
FieldConnectPoint nextPointSrc = candidates[randomIndex];
if (TryGetCommonPoint(basePointSrc, nextPointSrc, out FieldConnectPoint commonPoint) != false)
{
var sugorokuPoint = new FieldConnectPoint();
sugorokuPoint.Initialize(nextPointSrc.Position, 0);
sugorokuPoint.Index = nextPointSrc.Index;
ConnectPoints(basePoint, sugorokuPoint);
AddSugorokuPoint(sugorokuPoint, 1);
roomPoints.Add(sugorokuPoint);
var sugorokuPoint2 = new FieldConnectPoint();
sugorokuPoint2.Initialize(commonPoint.Position, 0);
sugorokuPoint2.Index = commonPoint.Index;
ConnectPoints(basePoint, sugorokuPoint2);
AddSugorokuPoint(sugorokuPoint2, 1);
roomPoints.Add(sugorokuPoint2);
ConnectPoints(sugorokuPoint, sugorokuPoint2);
int baseSugorokPointIndex = sugorokuPoints.FindIndex(point => point.Index == basePoint.Index);
masuTypes[baseSugorokPointIndex] = 1;
extendable = true;
break;
}
else
{
candidates.RemoveAt(randomIndex);
}
}
}
while (roomPoints.Count < roomSize && extendable != false && sugorokuPoints.Count < parameter.sugorokuSize)
{
bool foundNewRoomPoint = false;
for (int i0 = 0; i0 < roomPoints.Count; ++i0)
{
FieldConnectPoint roomPoint1 = roomPoints[i0];
FieldConnectPoint point1 = allPoints[roomPoint1.Index];
for (int i1 = 0; i1 < roomPoints.Count; ++i1)
{
if (i1 != i0)
{
FieldConnectPoint roomPoint2 = roomPoints[i1];
FieldConnectPoint point2 = allPoints[roomPoint2.Index];
if (TryGetCommonPoint(point1, point2, out FieldConnectPoint commonPoint) != false)
{
var sugorokuPoint = new FieldConnectPoint();
sugorokuPoint.Initialize(commonPoint.Position, 0);
sugorokuPoint.Index = commonPoint.Index;
ConnectPoints(roomPoint1, sugorokuPoint);
ConnectPoints(roomPoint2, sugorokuPoint);
AddSugorokuPoint(sugorokuPoint, 1);
roomPoints.Add(sugorokuPoint);
foundNewRoomPoint = true;
break;
}
}
}
if (foundNewRoomPoint != false)
{
break;
}
}
extendable = foundNewRoomPoint;
}
}
