public override void EventOccurred(IEventData data, EventType type)
{
//是否读取到表格划块
if (!type.Equals(EventType.RENDER_PATH) && !type.Equals(EventType.CLIP_PATH_CHANGED))
{
return;
}
List <PathChunk> paths = new List <PathChunk>();
if (type == EventType.RENDER_PATH)
{
PathRenderInfo renderInfo = (PathRenderInfo)data;
var zoom = renderInfo.GetCtm().Get(0);
//如果是假线 不处理
int flag = renderInfo.GetOperation();
if (flag == PathRenderInfo.NO_OP)
{
return;
}
var ctm = renderInfo.GetGraphicsState().GetCtm();
var t = ctm.Get(6);
var t1 = ctm.Get(7);
var subpaths = renderInfo.GetPath().GetSubpaths();
//foreach (var path in subpaths)
//{
// var shapes = path.GetSegments();
// foreach (var shape in shapes)
// {
// var basePoint = shape.GetBasePoints();
// paths.Add(new PathChunk(basePoint));
// }
//}
#region 缩放
if (zoom != 1)
{
foreach (var path in subpaths)
{
var shapes = path.GetSegments();
foreach (var shape in shapes)
{
var b = shape.GetBasePoints();
foreach (var point in b)
{
point.x = point.x * zoom;
point.y = point.y * zoom;
}
}
}
}
#endregion
//如果是矩形 加上最后一条线
if (subpaths.Count == 2 && subpaths[0].GetSegments().Count == 3 && subpaths[1].GetSegments().Count == 0)
{
var segList = subpaths[0].GetSegments();
#region 全局线框不画
if (segList[0].GetBasePoints()[0].x <= 0 && segList[0].GetBasePoints()[0].y <= 0)
{
return;
}
#endregion
#region 画上底线
//var basePoint = segList[2].GetBasePoints();
List <Point> basePoint = new List <Point>();
basePoint.Add(new Point(segList[2].GetBasePoints()[1]));
basePoint.Add(new Point(subpaths[1].GetStartPoint()));
basePoint[0].y = this.Height - basePoint[0].y;
basePoint[1].y = this.Height - basePoint[1].y;
paths.Add(new PathChunk(basePoint));
#endregion
#region 特殊矩形处理
//var xBasePoint = segList[0].GetBasePoints();
//var yBasePoint = segList[1].GetBasePoints();
//var xSeBasePoint = segList[2].GetBasePoints();
//var ttttt = renderInfo.GetGraphicsState();
#endregion
foreach (var path in subpaths)
{
var shapes = path.GetSegments();
foreach (var shape in shapes)
{
var b = shape.GetBasePoints();
foreach (var point in b)
{
if (t1 == 0)
{
point.y = this.Height - point.y;
}
if (point.y > 768.199996948242 && point.y < 770.199996948242)
{
}
}
paths.Add(new PathChunk(b));
}
}
}
else
{
//如果是画线
if (t1 == 0)
{
t1 = this.Height;
}
foreach (var path in subpaths)
{
var shapes = path.GetSegments();
foreach (var shape in shapes)
{
var basePoint = shape.GetBasePoints();
foreach (var point in basePoint)
{
point.x = point.x + t;
point.y = this.Height - t1 + point.y;
}
paths.Add(new PathChunk(basePoint));
}
}
}
}
if (type == EventType.CLIP_PATH_CHANGED)
{
ClippingPathInfo renderInfo = (ClippingPathInfo)data;
var s = renderInfo.GetGraphicsState().GetCtm();
var t = s.Get(6);
var t1 = s.Get(7);
var clpath = renderInfo.GetClippingPath();
var currentPoint = clpath.GetCurrentPoint();
if (currentPoint != null && currentPoint.x == 0 && currentPoint.y == 0)
{
return;
}
var subpaths = clpath.GetSubpaths();
//如果是矩形裁剪
if (subpaths.Count == 2 && subpaths[0].GetSegments().Count == 3 && subpaths[1].GetSegments().Count == 0)
{
var isJISUAN = clpath.GetCurrentPoint().y == subpaths[0].GetStartPoint().y;
var segList = subpaths[0].GetSegments();
#region 修正坐标系
foreach (var path in subpaths)
{
var shapes = path.GetSegments();
foreach (var shape in shapes)
{
var b = shape.GetBasePoints();
foreach (var point in b)
{
if (t1 == 0 && isJISUAN)
{
point.y = this.Height - point.y;
}
}
}
}
#endregion
#region 画上底线
List <Point> basePoint = new List <Point>();
basePoint.Add(new Point(segList[2].GetBasePoints()[1]));
basePoint.Add(new Point(segList[0].GetBasePoints()[0]));
//basePoint[1].y = this.Height - basePoint[1].y;
#endregion
#region 特殊矩形处理
var clipPaths = new List <PathChunk>(4);
var x1 = new PathChunk(segList[2].GetBasePoints());
var x2 = new PathChunk(segList[0].GetBasePoints());
var y1 = new PathChunk(basePoint);
var y2 = new PathChunk(segList[1].GetBasePoints());
clipPaths.Add(x1);
clipPaths.Add(x2);
clipPaths.Add(y1);
clipPaths.Add(y2);
var clipXpaths = clipPaths.Where(p => p.Direction == 线方向.横向).OrderBy(p => p.StartPath.y).ToList();
var clipYpaths = clipPaths.Where(p => p.Direction == 线方向.纵向).OrderBy(p => p.StartPath.x).ToList();
if (clipXpaths.Count != 2 || clipYpaths.Count != 2)
{
return;
}
if ((clipXpaths[1].EndPath.x - clipXpaths[1].StartPath.x) > clipXpaths[1].StartPath.x * 2 &&
(clipYpaths[1].EndPath.y - clipYpaths[1].StartPath.y) > clipYpaths[1].StartPath.y * 2 &&
(clipYpaths[1].EndPath.y - clipYpaths[1].StartPath.y + clipYpaths[1].StartPath.y * 2) >= this.Height - 50)
{
return;
}
for (int i = paths.Count < 4 ? 0 : paths.Count - 4; i < paths.Count && paths.Count > 0; i++)
{
var path = paths[i];
bool flag = false;
//删除重叠矩形的线
foreach (var xpath in clipPaths)
{
if (xpath.StartPath.x + 0.1 > path.StartPath.x && xpath.StartPath.x - 0.1 < path.StartPath.x &&
xpath.EndPath.x + 0.1 > path.EndPath.x && xpath.EndPath.x - 0.1 < path.EndPath.x &&
xpath.StartPath.y + 0.1 > path.StartPath.y && xpath.StartPath.y - 0.1 < path.StartPath.y &&
xpath.EndPath.y + 0.1 > path.EndPath.y && xpath.EndPath.y - 0.1 < path.EndPath.y)
{
path.IsDeleted = true;
flag = true;
break;
}
}
//continue;
if (flag)
{
continue;
}
if (path.Direction == 线方向.横向 &&
path.StartPath.y + 0.001 > clipXpaths[0].StartPath.y && path.StartPath.y < clipXpaths[1].StartPath.y + 0.001)
{
if (clipXpaths[0].StartPath.x - path.StartPath.x > 0.001 && clipXpaths[0].EndPath.x - path.EndPath.x > -0.001 &&
clipXpaths[0].StartPath.x - 0.001 < path.EndPath.x)
{
path.EndPath.x = clipXpaths[0].StartPath.x;
}
else if (path.StartPath.x - clipXpaths[0].StartPath.x > 0.001 && path.EndPath.x - clipXpaths[0].EndPath.x > 0.001 &&
path.StartPath.x + 0.001 < clipXpaths[0].EndPath.x)
{
path.StartPath.x = clipXpaths[0].EndPath.x;
}
else if (path.StartPath.x + 0.001 < clipXpaths[0].StartPath.x && path.EndPath.x - 0.001 > clipXpaths[0].EndPath.x)
{
paths.Add(new PathChunk(path.StartPath.x, path.StartPath.y, clipXpaths[0].StartPath.x, path.StartPath.y));
paths.Add(new PathChunk(clipXpaths[0].EndPath.x, path.EndPath.y, path.EndPath.x, path.EndPath.y));
path.IsDeleted = true;
}
else if (path.StartPath.x + 0.001 > clipXpaths[0].StartPath.x && path.EndPath.x - 0.001 < clipXpaths[0].EndPath.x)
{
path.IsDeleted = true;
}
}
if (path.Direction == 线方向.纵向 &&
path.StartPath.x + 0.001 > clipYpaths[0].StartPath.x && path.StartPath.x < clipYpaths[1].StartPath.x + 0.001)
{
if (clipYpaths[0].StartPath.y + 0.001 > path.StartPath.y && clipYpaths[0].EndPath.y > path.EndPath.y - 0.001 &&
clipYpaths[0].StartPath.y - 0.001 < path.EndPath.y)
{
path.EndPath.y = clipYpaths[0].StartPath.y;
}
else if (path.EndPath.y + 0.001 > clipYpaths[0].EndPath.y && path.StartPath.y > clipYpaths[0].StartPath.y - 0.001 &&
path.StartPath.y - 0.001 < clipYpaths[0].EndPath.y)
{
path.StartPath.y = clipYpaths[0].EndPath.y;
}
else if (path.StartPath.y - 0.001 < clipYpaths[0].StartPath.y && path.EndPath.y + 0.001 > clipYpaths[0].EndPath.y)
{
paths.Add(new PathChunk(path.StartPath.x, path.StartPath.y, path.StartPath.x, clipYpaths[0].StartPath.y));
paths.Add(new PathChunk(path.EndPath.x, clipYpaths[0].EndPath.y, path.EndPath.x, path.EndPath.y));
path.IsDeleted = true;
}
else if (path.StartPath.y + 0.001 > clipYpaths[0].StartPath.y && path.EndPath.y - 0.001 < clipYpaths[0].EndPath.y)
{
path.IsDeleted = true;
}
}
}
#endregion
}
}
foreach (var item in paths)
{
float counter = increaseCounter();
chunkDictionairy.Add(counter, item);
}
base.EventOccurred(data, type);
}
public override void Load(byte[] data)
{
int offset = 0;
FileHeader header = new FileHeader();
header.Load(data, ref offset);
_chunkList = new Dictionary<Type, List<BaseChunk>>();
var chnkHeaders = new List<ChunkHeader>();
for (int i = 0; i < header.ChunkCount; i++)
{
ChunkHeader chunkHeader = new ChunkHeader();
chunkHeader.Load(data, ref offset);
chnkHeaders.Add(chunkHeader);
}
var orderedList = chnkHeaders.OrderBy(kvp => kvp.ChunkOffset);
foreach (ChunkHeader chunkHeader in orderedList)
{
for (int k = 0; k < chunkHeader.ElementCount; k++)
{
BaseChunk chunk;
switch (chunkHeader.Tag.Substring(0, 3).ToUpper())
{
case "ENV": chunk = new EnvrChunk(); break;
case "COL": chunk = new ColoChunk(); break;
case "PAL": chunk = new PaleChunk(); break;
case "VIR": chunk = new VirtChunk(); break;
case "SCL": chunk = new SclsChunk(); break;
case "PLY": chunk = new PlyrChunk(); break;
case "RPA": chunk = new RPATChunk(); break;
case "PAT": chunk = new PathChunk(); break;
case "RPP": chunk = new RppnChunk(); break;
case "PPN": chunk = new PpntChunk(); break;
case "SON": chunk = new SondChunk(); break;
case "FIL": chunk = new FiliChunk(); break;
case "MEC": chunk = new MecoChunk(); break;
case "MEM": chunk = new MemaChunk(); break;
case "TRE": chunk = new TresChunk(); break;
case "SHI": chunk = new ShipChunk(); break;
case "MUL": chunk = new MultChunk(); break;
case "LGH": chunk = new LghtChunk(); break;
case "LGT": chunk = new LgtvChunk(); break;
case "RAR": chunk = new RaroChunk(); break;
case "ARO": chunk = new ArobChunk(); break;
case "EVN": chunk = new EvntChunk(); break;
case "TGO": chunk = new TgobChunk(); break;
case "ACT":
chunk = new ActrChunk();
if (!chunkHeader.Tag.ToUpper().EndsWith("R"))
{
chunk.ChunkLayer = EditorHelpers.ConvertStringToLayerId(chunkHeader.Tag.ToUpper().Substring(3, 1));
}
break;
case "SCO":
chunk = new ScobChunk();
if (!chunkHeader.Tag.EndsWith("B"))
{
chunk.ChunkLayer = EditorHelpers.ConvertStringToLayerId(chunkHeader.Tag.ToUpper().Substring(3, 1));
}
break;
case "STA": chunk = new StagChunk(); break;
case "RCA": chunk = new RcamChunk(); break;
case "CAM": chunk = new CamrChunk(); break;
case "FLO": chunk = new FlorChunk(); break;
case "TWO": chunk = new TwoDChunk(); break;
case "2DM": chunk = new TwoDMAChunk(); break;
case "DMA": chunk = new DMAPChunk(); break;
case "LBN": chunk = new LbnkChunk(); break;
case "TGD": chunk = new TgdrChunk(); break;
case "RTB": chunk = new RTBLChunk(); break;
default:
Console.WriteLine("Unsupported Chunk Tag: " + chunkHeader.Tag + " Chunk will not be saved!");
chunk = null;
break;
}
if(chunk == null)
continue;
//Console.WriteLine(chunkHeader.Tag + " offset: " + chunkHeader.ChunkOffset);
chunk.ChunkName = chunkHeader.Tag;
chunk.LoadData(data, ref chunkHeader.ChunkOffset);
AddChunk(chunk);
}
}
}
public IEnumerator CreatePath()
{
yield return new WaitForEndOfFrame();
PathFollow[] followers = GameObject.FindObjectsOfType<PathFollow>();
for (byte i = 0; i < chunkCntTemp; i++)
{
GameObject newGO = null;
if (i < 5) {
newGO = GameObject.Instantiate<GameObject>(Straight.option); // Straight Option
} else {
while (newGO == null)
{
float selection = (float)rand.NextDouble()*totalWeight;//Random.Range(0, totalWeight);
for (byte j = 0; j < SpawnOptions.Length + 1; j++) {
if(j == SpawnOptions.Length) {
newGO = GameObject.Instantiate<GameObject>(Straight.option);
break;
}
if (selection < SpawnOptions[j].weight) {
if ((totalRot < -10 && SpawnOptions[j].vertRotDelta < -10) || (totalRot > 10 && SpawnOptions[j].vertRotDelta > 10)) break;
if ((totalRot != 0) && SpawnOptions[j].horizRot) break;
totalRot += SpawnOptions[j].vertRotDelta;
newGO = GameObject.Instantiate<GameObject>(SpawnOptions[j].option);
break;
} else {
selection -= SpawnOptions[j].weight;
}
}
}
}
newGO.transform.SetParent(transform, true);
var newPipe = newGO.GetComponent<PathChunk>();
if (lastPipe) {
newGO.transform.position = lastPipe.EndPoint.transform.position;
newGO.transform.rotation = lastPipe.EndPoint.transform.rotation;
lastPipe.EndPoint.next = newPipe.StartPoint;
} else {
newGO.transform.position = transform.position;
newGO.transform.rotation = Quaternion.identity;
}
lastPipe = newGO.GetComponent<PathChunk>();
currentChunkCount++;
if(i == 0) {
for(byte j = 0; j < followers.Length; j++) {
followers[j].currNode = lastPipe.StartPoint; // Place the path followers on the start point.
}
}
if(i == 20) {
for(byte j = 0; j < followers.Length; j++) {
if(followers[j].gameObject.GetComponent<ObjectSpawner>() != null) {
followers[j].Travel(200f); // Push the obstacle spawner 200 units ahead instead
} else if(followers[j].gameObject.name == "Dead Area") {
followers[j].Travel(70f); // Push the "dead player" area 30 units ahead instead
} else {
followers[j].Travel(5f); // Push everything 5 units ahead, prevent the starting clipping
}
}
}
if(i > 20)
yield return null;
}
chunkCntTemp = chunkCnt; //After first runthrough
while(true) {
while (currentChunkCount >= chunkCntTemp)
{
yield return null;
}
GameObject newGO = null;
while (newGO == null)
{
float selection = (float)rand.NextDouble() * totalWeight;//Random.Range(0, totalWeight);
for(byte j = 0; j < SpawnOptions.Length + 1; j++) {
if(j == SpawnOptions.Length) {
newGO = GameObject.Instantiate<GameObject>(Straight.option);
break;
}
if(selection < SpawnOptions[j].weight) {
if((totalRot < -10 && SpawnOptions[j].vertRotDelta < -10) || (totalRot > 10 && SpawnOptions[j].vertRotDelta > 10)) break;
if((totalRot != 0) && SpawnOptions[j].horizRot) break;
totalRot += SpawnOptions[j].vertRotDelta;
newGO = GameObject.Instantiate<GameObject>(SpawnOptions[j].option);
break;
} else {
selection -= SpawnOptions[j].weight;
}
}
}
newGO.transform.SetParent(transform, true);
var newPipe = newGO.GetComponent<PathChunk>();
if (lastPipe) {
newGO.transform.position = lastPipe.EndPoint.transform.position;
newGO.transform.rotation = lastPipe.EndPoint.transform.rotation;
lastPipe.EndPoint.next = newPipe.StartPoint;
} else {
newGO.transform.position = transform.position;
newGO.transform.rotation = Quaternion.identity;
}
lastPipe = newGO.GetComponent<PathChunk>();
currentChunkCount++;
}
}
