internal static GameplayDraft ParallelDangerLane(GameplayDraft current)
{
if (current.Has(GameplayDraft.Tree))
{
if (current.Has(GameplayDraft.SafeLane2))
{
return(GameplayDraft.DangerLane1);
}
else
{
return(dangerlanes[EndlessLevelGenerator.random.Next(0, 2)]);
}
}
else if (current.Has(GameplayDraft.Eagle) || current.Has(GameplayDraft.House))
{
if (current.Has(GameplayDraft.SafeLane3))
{
return(dangerlanes[EndlessLevelGenerator.random.Next(0, 2)]);
}
else if (current.Has(GameplayDraft.SafeLane2))
{
return(dangerlanes[EndlessLevelGenerator.random.Next(0, 2) == 0 ? 0 : 2]);
}
else
{
return(dangerlanes[EndlessLevelGenerator.random.Next(1, 3)]);
}
}
else
{
return(GameplayDraft.Empty);
}
}
void BuildIt(int blockNumber)
{
build = new List <GameplayDraft>();
GameplayDraft current = GameplayDraft.Empty;
build.Add(current);
for (int i = 1; i < 3 + blockNumber * 2; i++)
{
int phase = EndlessLevelGenerator.random.Next(0, 10);
if (phase < 2)
{
current = GameplayDraft.Empty | DraftBuilder.RandomDanger(false);
}
else if (phase < 5)
{
current = GameplayDraft.Tree | DraftBuilder.RandomDanger(true);
}
else
{
current = GameplayDraft.House | DraftBuilder.RandomDanger(false);
}
build.Add(current);
}
//add lanes to build
int currentIndex = 1;
build[0] |= DraftBuilder.StartSafeLane();
while (currentIndex < build.Count)
{
//continue a lane to a neighbor lane
build[currentIndex] |= DraftBuilder.ContinueSafeLane(build[currentIndex - 1], build[currentIndex]);
//build[currentIndex] |= DraftBuilder.ParallelDangerLane(build[currentIndex]);
currentIndex++;
}
}
internal static GameplayDraft ContinueSafeLane(GameplayDraft before, GameplayDraft current)
{
return(transition[before.SafeToIndex(), current.DangerToIndex()]);
}
internal Chunk(Chunk prev, GameplayDraft draft, District district)
{
//set start x
if (prev == null)
{
_startX = 0;
}
else
{
_startX = prev._startX + prev.Width;
}
//set other members
_draft = draft;
_mainLanes = (Lanes)(draft & GameplayDraft.SafeLanes);
_district = district;
//set cells
_cells = new BaseObject[4];
if (draft.Has(GameplayDraft.Tree))
{
//select variation
bool large = draft.Has(GameplayDraft.DangerLane2);
int variation = EndlessLevelGenerator.random.Next();
//add a tree
_cells[0] = new Tree(_startX, large, variation);
//move pointer forward
Width += 2f;
//add extra eagle
if (draft.Has(GameplayDraft.DangerLane3))
{
_cells[3] = new Eagle(_startX + Width, 3);
//move pointer forward
Width += 2f;
}
}
if (draft.Has(GameplayDraft.House))
{
//select variation
int hIndex = EndlessLevelGenerator.random.Next(0, _district.Houses.Length);
var hPrototype = _district.Houses[hIndex % _district.Houses.Length];
var house = hPrototype.CloneAt(_startX + Width);
//add a house
_cells[0] = house;
//move pointer forward
Width += house.Width;
//add cats or eagles
//if (draft.Has(GameplayDraft.DangerLane1) && hPrototype.CatSignature.Has(Lanes.Lane1))
//{
// //add cat on first floor
// house.CatSignature |= Lanes.Lane1;
// house._cats[0] = hPrototype._cats[0].Clone();
//}
//else if (draft.Has(GameplayDraft.DangerLane2) && hPrototype.CatSignature.Has(Lanes.Lane2))
//{
// //add cat on second floor
// house.CatSignature |= Lanes.Lane2;
// house._cats[1] = hPrototype._cats[1].Clone();
//}
//else if (draft.Has(GameplayDraft.DangerLane3) && hPrototype.CatSignature.Has(Lanes.Lane3))
//{
// //add cat on third floor
// house.CatSignature |= Lanes.Lane3;
// house._cats[2] = hPrototype._cats[2].Clone();
//}
//else
//{
//add eagle instead of cat
if (EndlessLevelGenerator.random.Next(0, 2) == 0)
{
_cells[2] = new Eagle(_startX, 2);
}
else
{
_cells[3] = new Eagle(_startX, 3);
}
//}
}
}
/// <summary>
/// returns whether the enum source value contains given value
/// </summary>
/// <param name="src">enum source value</param>
/// <param name="cmp">given value</param>
/// <returns></returns>
internal static bool Has(this GameplayDraft src, GameplayDraft cmp)
{
return((src & cmp) == cmp);
}
internal static int DangerToIndex(this GameplayDraft draft)
{
return((int)(draft & GameplayDraft.DangerLanes) >> 4);
}
internal static int SafeToIndex(this GameplayDraft draft)
{
return((int)(draft & GameplayDraft.SafeLanes));
}
