public void InitPath()
{
int startSectionId = 0;
sectionIndex = 0;
ClearPath();
SectionModel firstCornerSection = new SectionModel(
startSectionId,
SectionType.corner,
Direction.right,
new Node(0, 0),
pathWidth, pathWidth, MapManager.Instance.verticalCornerSectionContent.terrains);
int unitLength = Random.Range(3, 6);
unitLength = 2;
int firstStraightSectionLength = unitLength * 3;
SectionContent sectionContent = MapManager.Instance.GetSectionContentByUnitLength(unitLength);
SectionModel firstStraightSection = new SectionModel(
firstCornerSection.sectionId + 1,
SectionType.straight,
Direction.right,
new Node(3, 0),
firstStraightSectionLength, pathWidth);
Direction secondCornerSectionDirection = Random.Range(0, 100) < 50 ? Direction.up : Direction.down;
secondCornerSectionDirection = pm.playMode == PlayMode.campaign ? Direction.up : Direction.down;
SectionModel secondCornerSection = new SectionModel(
firstStraightSection.sectionId + 1,
SectionType.corner,
secondCornerSectionDirection,
new Node(3 + firstStraightSectionLength, 0),
pathWidth, pathWidth, secondCornerSectionDirection == Direction.up ? MapManager.Instance.decreaseCornerSectionContent.terrains : MapManager.Instance.increaseCornerSectionContent.terrains);
SectionComponent firstCornerSectionComponent = MakeSection(firstCornerSection, firstStraightSection);
PutSectionComponent(firstCornerSectionComponent);
SectionComponent firstStraightSectionComponent = MakeSection(firstStraightSection, secondCornerSection);
PutSectionComponent(firstStraightSectionComponent);
SectionComponent secondCornerSectionComponent = MakeSection(secondCornerSection);
PutSectionComponent(secondCornerSectionComponent);
firstCornerSectionComponent.nextSectionComponent = firstStraightSectionComponent;
firstStraightSectionComponent.beforeSectionComponent = firstCornerSectionComponent;
firstStraightSectionComponent.nextSectionComponent = secondCornerSectionComponent;
secondCornerSectionComponent.beforeSectionComponent = firstStraightSectionComponent;
currentSectionComponent = firstCornerSectionComponent;
for (int i = 0; i < 5; i++)
{
AddSection(pm.playMode);
}
}
public List <SectionContent> GetSectionContents(TextAsset[] textAssets)
{
List <SectionContent> returnData = new List <SectionContent>();
foreach (TextAsset textAsset in textAssets)
{
SectionContent sectionContent = GetSectionContentFromTextAsset(textAsset);
returnData.Add(sectionContent);
}
return(returnData);
}
void Init()
{
tilesetList.Clear();
tilesetDictionary.Clear();
tileObjectDictionary.Clear();
for (int i = 0; i < tilesets.Length; i++)
{
TextAsset textAsset = tilesets[i];
Tileset tileset = JsonConvert.DeserializeObject <Tileset>(textAsset.text);
if (tileset.tileproperties != null && tileset.tileproperties.Count > 0)
{
foreach (KeyValuePair <int, TileProperty> kv in tileset.tileproperties)
{
tileObjectDictionary.Add(tileset.firstgid + kv.Key, kv.Value);
}
}
tilesetList.Add(tileset);
tilesetDictionary.Add(i, tileset);
}
campaignSectionContent = GetSectionContents(campaign);
finishSectionContent = GetSectionContentFromTextAsset(finish);
sectionContentList.Clear();
sectionContentList.Add(2, GetSectionContents(unit_2));
sectionContentList.Add(3, GetSectionContents(unit_3));
sectionContentList.Add(4, GetSectionContents(unit_4));
sectionContentList.Add(5, GetSectionContents(unit_5));
sectionContentList[2].Shuffle();
sectionContentList[3].Shuffle();
sectionContentList[4].Shuffle();
sectionContentList[5].Shuffle();
sectionContentQueue.Clear();
sectionContentQueue.Add(2, new Queue <SectionContent>(sectionContentList[2]));
sectionContentQueue.Add(3, new Queue <SectionContent>(sectionContentList[3]));
sectionContentQueue.Add(4, new Queue <SectionContent>(sectionContentList[4]));
sectionContentQueue.Add(5, new Queue <SectionContent>(sectionContentList[5]));
verticalCornerSectionContent = GetSectionContentFromTextAsset(verticalCorner);
horizontalCornerSectionContent = GetSectionContentFromTextAsset(horizontalCorner);
decreaseCornerSectionContent = GetSectionContentFromTextAsset(decreaseCorner);
increaseCornerSectionContent = GetSectionContentFromTextAsset(increaseCorner);
}
public void AddSection(PlayMode playMode)
{
SectionContent sectionContent = null;
int unitLength = -1;
int straightSectionLength = -1;
if (playMode == PlayMode.infinity)
{
unitLength = Random.Range(2, 6);
straightSectionLength = unitLength * 3; //6, 9, 12, 15
sectionContent = MapManager.Instance.GetSectionContentByUnitLength(unitLength);
}
else if (playMode == PlayMode.campaign)
{
sectionContent = MapManager.Instance.GetSectionContentBySectionIndex(sectionIndex++);
if (sectionContent == null)
{
// Debug.Log("sectionContent is null, sectionIndex : " + sectionIndex.ToString());
return;
}
unitLength = sectionContent.unitLength;
straightSectionLength = unitLength * 3;
}
Node straightSectionOrigin = lastSectionComponent.sectionData.origin;
int straightSectionWidth = 0;
int straightSectionHeight = 0;
if (lastSectionComponent.sectionData.direction == Direction.up)
{
straightSectionOrigin += new Node(0, pathWidth);
straightSectionWidth = pathWidth;
straightSectionHeight = straightSectionLength;
}
else if (lastSectionComponent.sectionData.direction == Direction.right)
{
straightSectionOrigin += new Node(pathWidth, 0);
straightSectionWidth = straightSectionLength;
straightSectionHeight = pathWidth;
}
else if (lastSectionComponent.sectionData.direction == Direction.down)
{
straightSectionOrigin += new Node(0, -straightSectionLength);
straightSectionWidth = pathWidth;
straightSectionHeight = straightSectionLength;
}
int[,] terrains = new int[straightSectionHeight, straightSectionWidth];
Dictionary <Node, TiledObject> objects = new Dictionary <Node, TiledObject>();
if (lastSectionComponent.sectionData.direction == Direction.right)
{
terrains = sectionContent.terrains;
foreach (KeyValuePair <Node, TiledObject> kv in sectionContent.objects)
{
Node node = new Node(kv.Key.y, kv.Key.x);
objects.Add(node, kv.Value);
}
}
else if (lastSectionComponent.sectionData.direction == Direction.up)
{
for (int i = 0; i < sectionContent.terrains.GetLength(0); i++)
{
for (int j = 0; j < sectionContent.terrains.GetLength(1); j++)
{
terrains[j, sectionContent.terrains.GetLength(0) - 1 - i] = sectionContent.terrains[i, j];
}
}
foreach (KeyValuePair <Node, TiledObject> kv in sectionContent.objects)
{
Node node = new Node(sectionContent.terrains.GetLength(0) - 1 - kv.Key.x, kv.Key.y);
objects.Add(node, kv.Value);
}
}
else if (lastSectionComponent.sectionData.direction == Direction.down)
{
for (int i = 0; i < sectionContent.terrains.GetLength(0); i++)
{
for (int j = 0; j < sectionContent.terrains.GetLength(1); j++)
{
terrains[sectionContent.terrains.GetLength(1) - 1 - j, i] = sectionContent.terrains[i, j];
}
}
foreach (KeyValuePair <Node, TiledObject> kv in sectionContent.objects)
{
objects.Add(new Node(kv.Key.x, sectionContent.terrains.GetLength(1) - 1 - kv.Key.y), kv.Value);
}
}
SectionModel addStraightSection = new SectionModel(
lastSectionComponent.sectionData.sectionId + 1,
SectionType.straight,
lastSectionComponent.sectionData.direction,
straightSectionOrigin,
straightSectionWidth, straightSectionHeight,
terrains,
objects);
Direction cornerSectionDirection = Direction.none;
Node cornerSectionOrigin = addStraightSection.origin;
if (addStraightSection.direction == Direction.up)
{
cornerSectionDirection = Direction.right;
cornerSectionOrigin += new Node(0, addStraightSection.height);
}
else if (addStraightSection.direction == Direction.right)
{
cornerSectionDirection = Random.Range(0, 100) < 50 ? Direction.up : Direction.down;
cornerSectionOrigin += new Node(addStraightSection.width, 0);
}
else if (addStraightSection.direction == Direction.down)
{
cornerSectionDirection = Direction.right;
cornerSectionOrigin += new Node(0, -pathWidth);
}
SectionContent cornerSectionContent = null;
if (playMode == PlayMode.campaign && sectionIndex == MapManager.Instance.campaignSectionContent.Count)
{
cornerSectionContent = MapManager.Instance.finishSectionContent;
}
else if (cornerSectionDirection == Direction.up)
{
cornerSectionContent = MapManager.Instance.decreaseCornerSectionContent;
}
else if (cornerSectionDirection == Direction.down)
{
cornerSectionContent = MapManager.Instance.increaseCornerSectionContent;
}
else if (cornerSectionDirection == Direction.right)
{
if (addStraightSection.direction == Direction.up)
{
cornerSectionContent = MapManager.Instance.decreaseCornerSectionContent;
}
else if (addStraightSection.direction == Direction.down)
{
cornerSectionContent = MapManager.Instance.increaseCornerSectionContent;
}
}
bool isLastSection = playMode == PlayMode.campaign && sectionIndex == MapManager.Instance.campaignSectionContent.Count;
SectionModel addCornerSection = new SectionModel(
addStraightSection.sectionId + 1,
SectionType.corner,
isLastSection ? addStraightSection.direction : cornerSectionDirection,
cornerSectionOrigin,
pathWidth, pathWidth, cornerSectionContent.terrains);
SectionComponent straightSectionComponent = MakeSection(addStraightSection, addCornerSection);
lastSectionComponent.nextSectionComponent = straightSectionComponent;
straightSectionComponent.beforeSectionComponent = lastSectionComponent;
PutSectionComponent(straightSectionComponent);
SectionComponent cornerSectionComponent = MakeSection(addCornerSection, null, isLastSection);
straightSectionComponent.nextSectionComponent = cornerSectionComponent;
cornerSectionComponent.beforeSectionComponent = straightSectionComponent;
PutSectionComponent(cornerSectionComponent);
if (sectionList.Count > maxMaintainSectionCount)
{
SectionComponent firstStraightSection = sectionList[0];
SectionComponent firstCornerSection = sectionList[1];
RemoveSectionComponent(firstStraightSection);
RemoveSectionComponent(firstCornerSection);
firstStraightSection.RemoveSection();
firstCornerSection.RemoveSection();
}
}