private void ApplySegmentTemplates()
{
for (int y = 0; y < segmentHeight; y++)
{
for (int x = 0; x < segmentWidth; x++)
{
// chance of not applying template
if (Game.Random.Next(100) > 50)
{
continue;
}
if (segments[x, y] != null) // || segments[x, y].ID == 0)
{
List <SegmentTemplateData> templates = SegmentTemplate.FindMatchingSegmentTemplates(1, segments[x, y].ID);
if (templates.Count > 0)
{
int index = Game.Random.Next(templates.Count - 1);
Map templateMap = SegmentTemplate.GenerateMapFromTemplate(templates[index], segments[x, y].ID);
map.Copy(templateMap,
x * MapSegment.SegmentCellWidthHeight,
y * MapSegment.SegmentCellWidthHeight);
segments[x, y].template = templates[index];
}
}
}
}
}
private static SegmentTemplate LoadSegmentTemplate(XElement element)
{
var template = new SegmentTemplate
{
Element = element,
Timescale = element.GetAttributeAsInt64("timescale"),
InitUrlTemplate = element.GetAttributeAsString("initialization"),
SegmentUrlTemplate = element.GetAttributeAsString("media")
};
// PTO is optional, defaults to 0.
if (element.Attribute("presentationTimeOffset") != null)
{
template.RawPresentationTimeOffset = element.GetAttributeAsInt64("presentationTimeOffset");
}
// Segment start time is optional, starts at 0 and then just += duration.
long nextRawStart = 0;
foreach (var segmentElement in element.Elements(SegmentTimelineName).Elements(SegmentName))
{
var repeat = 0L;
if (segmentElement.Attribute("r") != null)
{
repeat = segmentElement.GetAttributeAsInt64("r");
}
for (var i = 0; i < repeat + 1; i++)
{
var segment = new TimelineSegment
{
Element = segmentElement,
SegmentTemplate = template,
RawDuration = segmentElement.GetAttributeAsInt64("d"),
};
if (segmentElement.Attribute("t") != null && repeat == 0)
{
// We only take "t" on the first iteration of a repeat.
// Within a repeated cycle, we just use nextRawStart as if "t" were not there.
segment.RawStart = segmentElement.GetAttributeAsInt64("t");
}
else
{
segment.RawStart = nextRawStart;
}
nextRawStart = segment.RawStart + segment.RawDuration;
template.Segments.Add(segment);
}
}
return(template);
}
public static async Task <int> NewTemplateAsync(this BotContext context, User user)
{
var segmentTemplate = new SegmentTemplate
{
User = user
};
context.SegmentTemplates.Add(segmentTemplate);
await context.SaveChangesAsync().ConfigureAwait(false);
return(segmentTemplate.SegmentTemplateId);
}
public void SegmentTemplateTest()
{
List <SegmentTemplateData> templates = SegmentTemplate.FindMatchingSegmentTemplates(1, 1);
Console.WriteLine("Templates Found: " + templates.Count);
Map map = SegmentTemplate.GenerateMapFromTemplate(templates[0], 0);
Debug.Log(map.ToString());
map = SegmentTemplate.GenerateMapFromTemplate(templates[0], 90);
Debug.Log(map.ToString());
map = SegmentTemplate.GenerateMapFromTemplate(templates[0], 180);
Debug.Log(map.ToString());
map = SegmentTemplate.GenerateMapFromTemplate(templates[0], 270);
Debug.Log(map.ToString());
}
public void CreateMapView(DungeonMap dungeonMap)
{
Vector3 parentPosition;
parentPosition.x = 0;
parentPosition.y = 0;
parentPosition.z = 0;
GameObject mapParent = new GameObject("Map Mesh");
mapParent.transform.position = parentPosition;
mapParent.transform.parent = this.transform;
GameObject segmentParent = new GameObject("Segment Mesh");
segmentParent.transform.position = parentPosition;
segmentParent.transform.parent = this.transform;
GameObject segmentTemplateParent = new GameObject("Segment Template Mesh");
segmentParent.transform.position = parentPosition;
segmentParent.transform.parent = this.transform;
for (int y = 0; y < dungeonMap.SegmentHeight; y++)
{
for (int x = 0; x < dungeonMap.SegmentWidth; x++)
{
Vector3 childPosition;
childPosition.x = x * MapConstants.MapSegmentWidth;
childPosition.y = y * -MapConstants.MapSegmentHeight;
childPosition.z = 0;
MapMesh mesh = Instantiate <MapMesh>(mapMeshPrefab);
mesh.name = "Map X_" + x + " Y_" + y + " ID_" + dungeonMap.segments[x, y].ID;
mesh.transform.parent = mapParent.transform;
mesh.transform.position = parentPosition;
mesh.CreateMapMesh(childPosition, dungeonMap.CreateSegmentMap(x, y));
childPosition.z = -0.1f;
MapMesh mesh2 = Instantiate <MapMesh>(mapMeshPrefab);
mesh2.name = "Segment X_" + x + " Y_" + y + " ID_" + dungeonMap.segments[x, y].ID;
mesh2.transform.parent = segmentParent.transform;
mesh2.transform.position = parentPosition;
mesh2.CreateSegmentComponentMesh(childPosition, dungeonMap.segments[x, y]);
if (dungeonMap.segments[x, y].template.ThemeID != 0)
{
Vector3 templatePosition = new Vector3(childPosition.x + MapSegment.SegmentCellWidthHeight / 2f, childPosition.y - MapSegment.SegmentCellWidthHeight / 2f, -0.2f);
SpriteRenderer sprite1 = Instantiate <SpriteRenderer>(segmentTemplatePrefab);
sprite1.name = "Segment Template X_" + x + " Y_" + y + " ID_" + dungeonMap.segments[x, y].ID;
sprite1.transform.parent = segmentTemplateParent.transform;
sprite1.transform.position = templatePosition;
sprite1.sprite = Resources.Load <Sprite>("Art/Theme1/" + dungeonMap.segments[x, y].template.Image);
sprite1.transform.rotation = Quaternion.Euler(Vector3.forward * SegmentTemplate.GetTemplateSpriteRotation(dungeonMap.segments[x, y].template, dungeonMap.segments[x, y].ID));
}
CreateMapSegmentTextOverlay(childPosition, dungeonMap.segments[x, y].ID);
}
}
}
private static void CheckTimelineCoverage(SegmentTemplate template, DateTimeOffset windowStart, DateTimeOffset windowEnd, string path, IFeedbackSink feedback)
{
var period = template.ResolveAdaptationSet().Period;
var periodTimingString = $"The period lasts from {period.Start.ToTimeStringAccurate()} to {(period.End ?? windowEnd).ToTimeStringAccurate()}.";
var contentExistsUpTo = period.Start;
// Skip until playback window start. This may even mean skipping the entire period.
if (windowStart > contentExistsUpTo)
{
feedback.Info("Skipping data that lies before the playback window start.");
contentExistsUpTo = windowStart;
}
var ignoredPastSegments = 0;
var ignoredFutureSegments = 0;
foreach (var segment in template.Segments)
{
// If it is entirely in the past, skip it.
if (segment.End <= contentExistsUpTo)
{
ignoredPastSegments++;
continue;
}
// If it leaves a gap, scream.
if (segment.Start > contentExistsUpTo)
{
var gapLength = segment.Start - contentExistsUpTo;
var playbackWindowStartString = contentExistsUpTo == windowStart ? " This gap is at the start of the playback window." : "";
feedback.InvalidContent($"There is a gap of {gapLength.TotalMilliseconds:F1} ms from {contentExistsUpTo.ToTimeStringAccurate()} to {segment.Start.ToTimeStringAccurate()} in {path}. {periodTimingString}{playbackWindowStartString}");
}
// If the segment is entirely in the future, skip it.
// This can be either because this period was cut short by a new period
// or because this is the last period and the described segment is not available yet.
if (segment.Start > (period.End ?? windowEnd))
{
ignoredFutureSegments++;
continue;
}
// Mark as contentful time segment.
contentExistsUpTo = segment.End;
// If we overshot period end, clip back.
if (period.End.HasValue && contentExistsUpTo > period.End)
{
contentExistsUpTo = period.End.Value;
}
}
if (period.End.HasValue)
{
// Make sure we covered the period until the end if we know its end.
if (contentExistsUpTo != period.End.Value)
{
var gapLength = period.End.Value - contentExistsUpTo;
feedback.InvalidContent($"There is a gap of {gapLength.TotalMilliseconds:F1} ms from {contentExistsUpTo.ToTimeStringAccurate()} to {period.End.Value.ToTimeStringAccurate()} in {path}. {periodTimingString} This gap is at the end of the period.");
}
}
else
{
// Make sure we covered the period until playback window end if we do not know period end.
if (contentExistsUpTo < windowEnd)
{
var gapLength = windowEnd - contentExistsUpTo;
feedback.InvalidContent($"There is a gap of {gapLength.TotalMilliseconds:F1} ms from {contentExistsUpTo.ToTimeStringAccurate()} to {windowEnd.ToTimeStringAccurate()}. {periodTimingString} This gap is at the end of the period.");
}
}
if (ignoredPastSegments != 0 || ignoredFutureSegments != 0)
{
feedback.Info($"Ignored {ignoredPastSegments} segments that were too early and would never be played. Ignored {ignoredFutureSegments} segments that were too late and would never be played.");
}
}
