private bool TryToAddSingleBeatLevelElement(SingleBeat singleBeat, LevelElementType type)
{
LevelElementPlacement placement = LevelElementPlacement.CreateSingleSynchro(
type, singleBeat.Time);
return(TryToAddLevelElement(placement));
}
private bool TryToAddHeldNoteLevelElement(HeldNote heldNote, LevelElementType type)
{
LevelElementPlacement placement = LevelElementPlacement.CreateProlongedSynchro(
type, heldNote.StartTime, heldNote.EndTime);
return(TryToAddLevelElement(placement));
}
private bool TryToAddMultipleBeatsLevelElement(MultipleBeats multipleBeats, LevelElementType type)
{
LevelElementPlacement placement = LevelElementPlacement.CreateMultipleSynchro(
type, multipleBeats.GetBeatTimes());
return(TryToAddLevelElement(placement));
}
public Level GenerateThirdTutorialLevel()
{
LevelPlan levelPlan = new LevelPlan();
float segmentLength = 5;
for (int i = 0; i < 30; i++)
{
float offset = 3 + i * segmentLength;
LevelElementPlacement singleProjectile = LevelElementPlacement.CreateSingleSynchro(
LevelElementType.SingleProjectile, offset);
List <float> synchros = new List <float>()
{
offset + 2, offset + 2.5f, offset + 3
};
LevelElementPlacement multipleProjectiles = LevelElementPlacement.CreateMultipleSynchro(
LevelElementType.MultipleProjectiles, synchros);
levelPlan.AddLevelElementPlacement(singleProjectile);
levelPlan.AddLevelElementPlacement(multipleProjectiles);
}
Level level = GenerateLevel(levelPlan);
level.Name = "TutorialLevel3";
level.IsTutorial = true;
return(level);
}
public static LevelElementPlacement CreateSingleSynchro(LevelElementType type, float synchroTime)
{
LevelElementPlacement placement = new LevelElementPlacement(type);
placement.SynchroStartTime = synchroTime;
placement.SynchroEndTime = synchroTime;
if (type == LevelElementType.JumpObstacle)
{
placement.LevelElementStartTime = synchroTime;
placement.LevelElementEndTime = synchroTime + LevelGenerationValues.GetPlainJumpDuration();
}
if (type == LevelElementType.HighCollectible)
{
float halfJumpDuration = LevelGenerationValues.GetPlainJumpDuration() / 2.0f;
placement.LevelElementStartTime = synchroTime - halfJumpDuration;
placement.LevelElementEndTime = synchroTime + halfJumpDuration;
}
if (type == LevelElementType.LowCollectible)
{
placement.LevelElementStartTime = synchroTime - 0.01f;
placement.LevelElementEndTime = synchroTime + 0.01f;
}
if (type == LevelElementType.SingleProjectile)
{
placement.LevelElementStartTime = synchroTime - LevelGenerationValues.ProjectileSafetyTime;
placement.LevelElementEndTime = synchroTime;
}
return(placement);
}
public Level GenerateFirstTutorialLevel()
{
LevelPlan levelPlan = new LevelPlan();
float segmentLength = 7;
for (int i = 0; i < 30; i++)
{
float offset = 3 + i * segmentLength;
LevelElementPlacement highCollectible = LevelElementPlacement.CreateSingleSynchro(
LevelElementType.HighCollectible, offset);
LevelElementPlacement jumpObstacle = LevelElementPlacement.CreateSingleSynchro(
LevelElementType.JumpObstacle, offset + 2);
LevelElementPlacement chasm = LevelElementPlacement.CreateProlongedSynchro(
LevelElementType.Chasm, offset + 4, offset + 5);
levelPlan.AddLevelElementPlacement(highCollectible);
levelPlan.AddLevelElementPlacement(jumpObstacle);
levelPlan.AddLevelElementPlacement(chasm);
}
Level level = GenerateLevel(levelPlan);
level.Name = "TutorialLevel1";
level.IsTutorial = true;
return(level);
}
private Vector2 GetCollectiblePosition(LevelElementPlacement placement, float collectibleYOffset, float groundY)
{
float xPosition = GetPlayerRightEdgeXByTime(placement.SynchroStartTime)
+ (PhysicsValues.CollectibleHitboxWidth / 2.0f);
float yPosition = groundY + collectibleYOffset;
return(new Vector2(xPosition, yPosition));
}
private void AddLevelElementPlacement(LevelElementPlacement placement)
{
float leftTimeMargin = GetLeftTimeMarginOfLevelElement(placement);
float rightTimeMargin = GetRightTimeMarginOfLevelElement(placement);
reservedTimeRanges.Add(new Tuple <float, float>(leftTimeMargin, rightTimeMargin));
LevelPlan.AddLevelElementPlacement(placement);
}
public Obstacle CreateDuckObstacle(LevelElementPlacement placement, float groundY)
{
float obstacleStartTime = placement.SynchroStartTime + LevelGenerationValues.DuckingObstacleEnteringSafetyTime;
float obstacleEndtime = placement.SynchroEndTime - LevelGenerationValues.DuckingObstacleLeavingSafetyTime;
float leftX = GetXPositionByTime(obstacleStartTime);
float rightX = GetXPositionByTime(obstacleEndtime);
float topY = groundY + LevelGenerationValues.GetDuckObstacleGapHeight() + LevelGenerationValues.GetDuckObstacleHeight();
float bottomY = groundY + LevelGenerationValues.GetDuckObstacleGapHeight();
return(new Obstacle(new Vector2(leftX, topY), new Vector2(rightX, bottomY)));
}
public Obstacle CreateJumpObstacle(LevelElementPlacement placement, float groundY)
{
float centerOfObstacle = GetXPositionByTime(placement.SynchroStartTime) +
PhysicsValues.GetPlainJumpLength() / 2.0f;
float halfObstacleWidth = LevelGenerationValues.GetJumpObstacleWidth() / 2.0f;
float leftX = centerOfObstacle - halfObstacleWidth;
float rightX = centerOfObstacle + halfObstacleWidth;
float topY = groundY + LevelGenerationValues.GetJumpObstacleHeight();
return(new Obstacle(new Vector2(leftX, topY), new Vector2(rightX, groundY)));
}
private bool TryToAddLevelElement(LevelElementPlacement placement)
{
float leftTimeMargin = GetLeftTimeMarginOfLevelElement(placement);
float rightTimeMargin = GetRightTimeMarginOfLevelElement(placement);
if (IsTimeRangeFree(leftTimeMargin, rightTimeMargin))
{
AddLevelElementPlacement(placement);
distributionManager.AddLevelElementUse(placement.Type);
return(true);
}
return(false);
}
private void FillWithLowCollectibles()
{
foreach (SingleBeat singleBeat in songElements.SingleBeats)
{
if (singleBeat.Applicability < LevelGenerationValues.FillUpElementsApplicabilityThreshold)
{
continue;
}
LevelElementPlacement placement = LevelElementPlacement.CreateSingleSynchro(
LevelElementType.LowCollectible, singleBeat.Time);
if (IsTimeRangeFree(placement.LevelElementStartTime, placement.LevelElementEndTime))
{
AddLevelElementPlacement(placement);
}
}
}
public static LevelElementPlacement CreateProlongedSynchro(LevelElementType type,
float synchroStartTime, float synchroEndTime)
{
LevelElementPlacement placement = new LevelElementPlacement(type);
placement.SynchroStartTime = synchroStartTime;
placement.SynchroEndTime = synchroEndTime;
if (type == LevelElementType.Chasm)
{
placement.SetLevelElementTimesEqualToSynchroTimes();
}
if (type == LevelElementType.DuckObstacle)
{
placement.SetLevelElementTimesEqualToSynchroTimes();
}
return(placement);
}
public Level GenerateSecondTutorialLevel()
{
LevelPlan levelPlan = new LevelPlan();
float segmentLength = 4;
for (int i = 0; i < 30; i++)
{
float offset = 3 + i * segmentLength;
LevelElementPlacement duckObstacle = LevelElementPlacement.CreateProlongedSynchro(
LevelElementType.DuckObstacle, offset, offset + 2);
levelPlan.AddLevelElementPlacement(duckObstacle);
}
Level level = GenerateLevel(levelPlan);
level.Name = "TutorialLevel2";
level.IsTutorial = true;
return(level);
}
public static LevelElementPlacement CreateMultipleSynchro(LevelElementType type, List <float> synchroTimes)
{
LevelElementPlacement placement = new LevelElementPlacement(type);
placement.SynchroStartTime = synchroTimes[0];
placement.SynchroEndTime = synchroTimes[synchroTimes.Count - 1];
placement.SynchroTimes = synchroTimes;
if (type == LevelElementType.ChasmWithCollectibles)
{
placement.LevelElementStartTime = synchroTimes[0] - LevelGenerationValues.TimeBeforeFirstChasmCollectible;
placement.LevelElementEndTime = synchroTimes[synchroTimes.Count - 1] +
LevelGenerationValues.TimeAfterLastChasmCollectible;
}
if (type == LevelElementType.MultipleProjectiles)
{
placement.LevelElementStartTime = synchroTimes[0] - LevelGenerationValues.ProjectileSafetyTime;
placement.LevelElementEndTime = synchroTimes[synchroTimes.Count - 1];
}
return(placement);
}
private void CreateSingleSynchronisation(LevelElementType type, float synchronisationTime)
{
AddLevelElementPlacement(LevelElementPlacement.CreateSingleSynchro(type, synchronisationTime));
}
private float GetRightTimeMarginOfLevelElement(LevelElementPlacement placement)
{
return(placement.LevelElementEndTime);
}
private float GetLeftTimeMarginOfLevelElement(LevelElementPlacement placement)
{
return(placement.LevelElementStartTime - LevelGenerationValues.TimeBeforeLevelElement);
}
public Vector2 GetHighCollectiblePosition(LevelElementPlacement placement, float groundY)
{
return(GetCollectiblePosition(placement, LevelGenerationValues.GetHighCollectibleYOffset(), groundY));
}
public void AddLevelElementPlacement(LevelElementPlacement destination)
{
LevelElementPlacements.Add(destination);
}
private void CreateProlongedSynchronisation(LevelElementType type,
float synchroStartTime, float synchroEndTime)
{
AddLevelElementPlacement(LevelElementPlacement.CreateProlongedSynchro(type, synchroStartTime, synchroEndTime));
}
