private void Multiline(int count)
{
SimulationCell redlines = GetMultiLines(false);
using (var trk = game.Track.CreateTrackWriter())
{
var owner = (StandardLine)_ownerline;
LineChanging();
// owner line doesn't count, but our min bounds is 1
var diff = (count - 1) - redlines.Count;
if (diff < 0)
{
for (int i = 0; i > diff; i--)
{
trk.RemoveLine(redlines.First());
redlines.RemoveLine(redlines.First().ID);
}
}
else if (diff > 0)
{
for (int i = 0; i < diff; i++)
{
var red = new RedLine(owner.Position, owner.Position2, owner.inv)
{
Multiplier = ((RedLine)owner).Multiplier
};
red.CalculateConstants();
trk.AddLine(red);
redlines.AddLine(red);
}
}
}
game.Track.NotifyTrackChanged();
}
public static GenericVertex[] GetAccelDecor(RedLine line)
{
var linecolor = Constants.RedLineColor;
var multiplier = ((RedLine)line).Multiplier;
GenericVertex[] ret = new GenericVertex[3 * multiplier];
var angle = Angle.FromLine(line.End, line.Start);
var angle2 = Angle.FromRadians(angle.Radians - 1.5708f);
var start = line.Position2;
for (int idx = 0; idx < multiplier; idx++)
{
var a = start;
var b = angle.MovePoint(start, line.inv ? -8 : 8);
var c = angle2.MovePoint(b, 8);
ret[idx * 3 + 0] = new GenericVertex((Vector2)a, linecolor);
ret[idx * 3 + 1] = new GenericVertex((Vector2)b, linecolor);
ret[idx * 3 + 2] = new GenericVertex((Vector2)c, linecolor);
if (idx + 1 < multiplier)
{
start = angle.MovePoint(start, line.inv ? -2 : 2);
}
}
return(ret);
}
public void RemoveLine(RedLine line)
{
var accel = _lookup[line.ID];
for (int ix = 0; ix < accel.shapes; ix++)
{
int offset = accel.start + (ix * ShapeSize);
if (IsNulled(offset))
{
continue;
}
_freeverts.Enqueue(_indices.unsafe_array[offset]);
for (int i = 0; i < ShapeSize; i++)
{
var index = accel.start + (ix * ShapeSize) + i;
_indices.unsafe_array[index] = nullindex;
}
}
_accelibo.Bind();
_accelibo.SetData(
_indices.unsafe_array,
accel.start,
accel.start,
accel.shapes * ShapeSize);
_accelibo.Unbind();
}
private void ChangeMultiplier(int mul)
{
var lines = GetMultiLines(false);
using (var trk = _editor.CreateTrackWriter())
{
RedLine redCpy = null;
StandardLine blueCpy = null;
LineType origLineType = _ownerline.Type;
// If adding acceleration to a blue line
if (origLineType == LineType.Blue && mul != 0)
{
redCpy = RedLine.CloneFromBlue((StandardLine)_ownerline);
_editor._renderer.RedrawLine(_ownerline);
_editor._renderer.AddLine(redCpy);
}
// If setting acceleration to 0 of a red line
else if (origLineType == LineType.Red && mul == 0)
{
_editor._renderer.RemoveLine(_ownerline);
blueCpy = StandardLine.CloneFromRed((RedLine)_ownerline);
_editor._renderer.AddLine(blueCpy);
}
else
{
redCpy = (RedLine)_ownerline.Clone();
}
if (redCpy != null)
{
redCpy.Multiplier = mul;
}
StandardLine cpy = redCpy != null ? redCpy : blueCpy;
UpdateOwnerLine(trk, cpy);
foreach (var line in lines)
{
StandardLine copy;
// Going from red lines to blue
if (origLineType == LineType.Red && _ownerline.Type == LineType.Blue)
{
copy = StandardLine.CloneFromRed(line);
}
// Going from blue lines to red
else if (origLineType == LineType.Blue && _ownerline.Type == LineType.Red)
{
copy = RedLine.CloneFromBlue(line);
}
else
{
copy = (StandardLine)line.Clone();
}
if (copy is RedLine redCopy)
{
redCopy.Multiplier = mul;
}
UpdateLine(trk, line, copy);
}
}
}
private static void AddLine(Track track, line_json line)
{
switch (line.type)
{
case 0:
{
var add = new StandardLine(
new Vector2d(line.x1, line.y1),
new Vector2d(line.x2, line.y2),
Convert.ToBoolean(line.flipped));
add.ID = line.id;
add.Extension = (StandardLine.Ext)line.extended;
if (Convert.ToBoolean(line.leftExtended))
{
add.Extension |= StandardLine.Ext.Left;
}
if (Convert.ToBoolean(line.rightExtended))
{
add.Extension |= StandardLine.Ext.Right;
}
track.AddLine(add);
break;
}
case 1:
{
var add = new RedLine(
new Vector2d(line.x1, line.y1),
new Vector2d(line.x2, line.y2),
Convert.ToBoolean(line.flipped));
add.ID = line.id;
add.Extension = (StandardLine.Ext)line.extended;
if (Convert.ToBoolean(line.leftExtended))
{
add.Extension |= StandardLine.Ext.Left;
}
if (Convert.ToBoolean(line.rightExtended))
{
add.Extension |= StandardLine.Ext.Right;
}
track.AddLine(add);
break;
}
case 2:
{
var add = new SceneryLine(
new Vector2d(line.x1, line.y1),
new Vector2d(line.x2, line.y2));
add.ID = line.id;
track.AddLine(add);
break;
}
default:
throw new TrackIO.TrackLoadException(
"Unknown line type");
}
}
public void test()
{
Generate.Click();
RedLine.Click();
Thread.Sleep(800);
Assert.IsTrue(Completed.Text.Contains("Good job"), "Not Completed");
ClosePopUp.Click();
}
public static GenericVertex[] GetAccelDecor(RedLine line)
{
var linecolor = Constants.RedLineColor;
var multiplier = ((RedLine)line).Multiplier;
var shapecount = Math.Min(multiplier, 3);
if (multiplier > 3)
{
shapecount += 4;
}
GenericVertex[] ret = new GenericVertex[3 * shapecount];
var angle = Angle.FromLine(line.End, line.Start);
var angle2 = Angle.FromRadians(angle.Radians - 1.5708f);
var start = line.Position2;
for (int idx = 0; idx < Math.Min(multiplier, 3); idx++)
{
var a = start;
var b = angle.MovePoint(start, line.inv ? -8 : 8);
var c = angle2.MovePoint(b, 8);
ret[idx * 3 + 0] = new GenericVertex((Vector2)a, linecolor);
ret[idx * 3 + 1] = new GenericVertex((Vector2)b, linecolor);
ret[idx * 3 + 2] = new GenericVertex((Vector2)c, linecolor);
if (idx + 1 < multiplier)
{
start = angle.MovePoint(start, line.inv ? -2 : 2);
}
}
if (multiplier > 3)
{
// Draw White plus
var a = angle.MovePoint(start, line.inv ? -2 : 2);
var b = angle2.MovePoint(a, 2);
var c = angle2.MovePoint(b, 3);
Vector2[] tall = Utility.GetThickLine(
(Vector2)b, (Vector2)c, Angle.FromVector(c - b), 0.5f);
Vector2[] tess = Utility.TesselateThickLine(tall);
for (int i = 0; i < tess.Length; i++)
{
ret[3 * 3 + i] = new GenericVertex(tess[i], Color.White);
}
a = angle2.MovePoint(b, 1.5);
b = angle.MovePoint(a, -1.5);
c = angle.MovePoint(a, 1.5);
tall = Utility.GetThickLine(
(Vector2)b, (Vector2)c, Angle.FromVector(c - b), 0.5f);
tess = Utility.TesselateThickLine(tall);
for (int i = 0; i < tess.Length; i++)
{
ret[5 * 3 + i] = new GenericVertex(tess[i], Color.White);
}
}
return(ret);
}
public void EnterClearly()
{
Anim.Play("Creator_ShowWorkspace");
LeftCreatingPanel.SetActive(true);
LeftMainPanel.SetActive(false);
RightPanel.SetActive(true);
RedLine.SetActive(true);
Table.CleanBeforeInit();
Table.Initialize();
}
public void BackToLobby()
{
Anim.Play("Creator_HideWorkspace");
LeftCreatingPanel.SetActive(false);
LeftMainPanel.SetActive(true);
RightPanel.SetActive(false);
RedLine.SetActive(false);
Table.IsActive = false;
LoadBtn.interactable = false;
LoadList();
}
protected GameLine CreateLine(
TrackWriter trk,
Vector2d start,
Vector2d end,
bool inv,
bool snapstart,
bool snapend)
{
GameLine added = null;
switch (Swatch.Selected)
{
case LineType.Blue:
added = new StandardLine(start, end, inv);
break;
case LineType.Red:
var red = new RedLine(start, end, inv)
{
Multiplier = Swatch.RedMultiplier
};
red.CalculateConstants(); //multiplier needs to be recalculated
added = red;
break;
case LineType.Scenery:
added = new SceneryLine(start, end)
{
Width = Swatch.GreenMultiplier
};
break;
default: //In case no swatch is chosen select blue and make a blue line
added = new StandardLine(start, end, inv);
Swatch.Selected = LineType.Blue;
break;
}
trk.AddLine(added);
if (Swatch.Selected != LineType.Scenery)
{
if (snapstart)
{
SnapLineEnd(trk, added, added.Position);
}
if (snapend)
{
SnapLineEnd(trk, added, added.Position2);
}
}
game.Track.Invalidate();
return(added);
}
public void AddLine(RedLine line)
{
if (_lookup.ContainsKey(line.ID))
{
LineChanged(line, false);
return;
}
_lookup.Add(
line.ID,
new accelentry()
{
start = _indices.Count,
shapes = 0
});
DrawAccel(line, false);
}
protected GameLine CreateLine(
TrackWriter trk,
Vector2d start,
Vector2d end,
bool inv,
bool snapstart,
bool snapend)
{
GameLine added = null;
switch (game.Canvas.ColorControls.Selected)
{
case LineType.Blue:
added = new StandardLine(start, end, inv);
break;
case LineType.Red:
var red = new RedLine(start, end, inv)
{
Multiplier = game.Canvas.ColorControls.RedMultiplier
};
red.CalculateConstants(); //multiplier needs to be recalculated
added = red;
break;
case LineType.Scenery:
added = new SceneryLine(start, end)
{
Width = game.Canvas.ColorControls.GreenMultiplier
};
break;
}
trk.AddLine(added);
if (game.Canvas.ColorControls.Selected != LineType.Scenery)
{
if (snapstart)
{
SnapLineEnd(trk, added, added.Position);
}
if (snapend)
{
SnapLineEnd(trk, added, added.Position2);
}
}
game.Track.Invalidate();
return(added);
}
private void Multiline(int count)
{
SimulationCell multilines = GetMultiLines(false);
using (var trk = _editor.CreateTrackWriter())
{
var owner = (StandardLine)_ownerline;
MakingChange();
// owner line doesn't count, but our min bounds is 1
var diff = (count - 1) - multilines.Count;
if (diff < 0)
{
for (int i = 0; i > diff; i--)
{
trk.RemoveLine(multilines.First());
multilines.RemoveLine(multilines.First().ID);
}
}
else if (diff > 0)
{
if (_ownerline is RedLine redline)
{
for (int i = 0; i < diff; i++)
{
var red = new RedLine(owner.Position, owner.Position2, owner.inv)
{
Multiplier = ((RedLine)owner).Multiplier
};
red.CalculateConstants();
trk.AddLine(red);
}
}
else if (_ownerline is StandardLine blueline)
{
for (int i = 0; i < diff; i++)
{
var blue = new StandardLine(owner.Position, owner.Position2, owner.inv);
blue.CalculateConstants();
trk.AddLine(blue);
}
}
}
}
_editor.NotifyTrackChanged();
}
public void EnterWithFile()
{
string fileName = FileButtons[CurrentListIndex].gameObject.GetComponentInChildren <Text>().text;
if (Table.ReadFromTWx(CurrentFilePath, fileName.Substring(0, fileName.Length - 4)))
{
Anim.Play("Creator_ShowWorkspace");
LeftCreatingPanel.SetActive(true);
LeftMainPanel.SetActive(false);
RightPanel.SetActive(true);
RedLine.SetActive(true);
Table.Initialize();
}
else
{
MessageBox.Show(LocaleManager.instance.GetLocaleText("error_occured"), LocaleManager.instance.GetLocaleText("creator_cannotload"), MessageBoxButton.OK);
}
}
public override void Render()
{
base.Render();
if (Active)
{
var diff = _end - _start;
var x = diff.X;
var y = diff.Y;
Color c = Color.FromArgb(200, 150, 150, 150);
if (Math.Abs(x) + Math.Abs(y) < MINIMUM_LINE)
{
c = Color.Red;
var sz = 2f;
if (Swatch.Selected == LineType.Scenery)
{
sz *= Swatch.GreenMultiplier;
}
GameRenderer.RenderRoundedLine(_start, _end, c, sz);
}
else
{
switch (Swatch.Selected)
{
case LineType.Blue:
StandardLine sl = new StandardLine(_start, _end, _addflip);
sl.CalculateConstants();
GameRenderer.DrawTrackLine(sl, c, Settings.Editor.RenderGravityWells, true);
break;
case LineType.Red:
RedLine rl = new RedLine(_start, _end, _addflip);
rl.Multiplier = Swatch.RedMultiplier;
rl.CalculateConstants();
GameRenderer.DrawTrackLine(rl, c, Settings.Editor.RenderGravityWells, true);
break;
case LineType.Scenery:
GameRenderer.RenderRoundedLine(_start, _end, c, 2 * Swatch.GreenMultiplier);
break;
}
}
}
}
protected GameLine CreateLine( //Creates a line from a pair of vectors (modified from Tool.cs)
TrackWriter trk,
Vector2d start,
Vector2d end,
LineType type,
bool inv,
int multiplier = 1, //Only applies to red lines (smh)
float width = 1.0f) //Width only applicable to green lines
{
GameLine added = null;
switch (type)
{
case LineType.Blue:
added = new StandardLine(start, end, inv);
break;
case LineType.Red:
var red = new RedLine(start, end, inv)
{
Multiplier = multiplier
};
red.CalculateConstants(); //multiplier needs to be recalculated
added = red;
break;
case LineType.Scenery:
added = new SceneryLine(start, end)
{
Width = width
};
break;
}
trk.AddLine(added);
game.Track.Invalidate();
return(added);
}
public static Track LoadTrack(string trackfile, string trackname)
{
var ret = new Track();
ret.Filename = trackfile;
ret.Name = trackname;
ret.Remount = false;
var addedlines = new Dictionary <int, StandardLine>();
var location = trackfile;
var bytes = File.ReadAllBytes(location);
using (var file =
new MemoryStream(bytes))
{
var br = new BinaryReader(file);
int magic = br.ReadInt32();
if (magic != ('T' | 'R' << 8 | 'K' << 16 | 0xF2 << 24))
{
throw new TrackIO.TrackLoadException("File was read as .trk but it is not valid");
}
byte version = br.ReadByte();
string[] features = ReadString(br).Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (version != 1)
{
throw new TrackIO.TrackLoadException("Unsupported version");
}
bool redmultipier = false;
bool scenerywidth = false;
bool supports61 = false;
bool songinfo = false;
bool ignorabletrigger = false;
for (int i = 0; i < features.Length; i++)
{
switch (features[i])
{
case TrackFeatures.redmultiplier:
redmultipier = true;
break;
case TrackFeatures.scenerywidth:
scenerywidth = true;
break;
case TrackFeatures.six_one:
supports61 = true;
break;
case TrackFeatures.songinfo:
songinfo = true;
break;
case TrackFeatures.ignorable_trigger:
ignorabletrigger = true;
break;
case TrackFeatures.zerostart:
ret.ZeroStart = true;
break;
case TrackFeatures.remount:
ret.Remount = true;
break;
case TrackFeatures.frictionless:
ret.frictionless = true;
break;
default:
throw new TrackIO.TrackLoadException("Unsupported feature");
}
}
if (supports61)
{
ret.SetVersion(61);
}
else
{
ret.SetVersion(62);
}
if (songinfo)
{
var song = br.ReadString();
try
{
var strings = song.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
var fn = Program.UserDirectory + "Songs" +
Path.DirectorySeparatorChar +
strings[0];
if (File.Exists(fn))
{
if (AudioService.LoadFile(ref fn))
{
ret.Song = new Song(Path.GetFileName(fn), float.Parse(strings[1], Program.Culture));
}
else
{
Program.NonFatalError("An unknown error occured trying to load the song file");
}
}
}
catch
{
// ignored
}
}
ret.StartOffset = new Vector2d(br.ReadDouble(), br.ReadDouble());
var lines = br.ReadInt32();
List <LineTrigger> linetriggers = new List <LineTrigger>();
for (var i = 0; i < lines; i++)
{
GameLine l;
byte ltype = br.ReadByte();
var lt = (LineType)(ltype & 0x1F);//we get 5 bits
var inv = (ltype >> 7) != 0;
var lim = (ltype >> 5) & 0x3;
var ID = -1;
var prvID = -1;
var nxtID = -1;
var multiplier = 1;
var linewidth = 1f;
LineTrigger tr = null;
if (redmultipier)
{
if (lt == LineType.Red)
{
multiplier = br.ReadByte();
}
}
if (lt == LineType.Blue || lt == LineType.Red)
{
if (ignorabletrigger)
{
tr = new LineTrigger();
bool zoomtrigger = br.ReadBoolean();
if (zoomtrigger)
{
tr.ZoomTrigger = true;
var target = br.ReadSingle();
var frames = br.ReadInt16();
tr.ZoomFrames = frames;
tr.ZoomTarget = target;
}
else
{
tr = null;
}
}
ID = br.ReadInt32();
if (lim != 0)
{
prvID = br.ReadInt32(); //ignored
nxtID = br.ReadInt32(); //ignored
}
}
if (lt == LineType.Scenery)
{
if (scenerywidth)
{
float b = br.ReadByte();
linewidth = b / 10f;
}
}
var x1 = br.ReadDouble();
var y1 = br.ReadDouble();
var x2 = br.ReadDouble();
var y2 = br.ReadDouble();
if (tr != null)
{
tr.LineID = ID;
linetriggers.Add(tr);
}
switch (lt)
{
case LineType.Blue:
var bl = new StandardLine(new Vector2d(x1, y1), new Vector2d(x2, y2), inv);
bl.ID = ID;
bl.Extension = (StandardLine.Ext)lim;
l = bl;
break;
case LineType.Red:
var rl = new RedLine(new Vector2d(x1, y1), new Vector2d(x2, y2), inv);
rl.ID = ID;
rl.Extension = (StandardLine.Ext)lim;
if (redmultipier)
{
rl.Multiplier = multiplier;
}
l = rl;
break;
case LineType.Scenery:
l = new SceneryLine(new Vector2d(x1, y1), new Vector2d(x2, y2))
{
Width = linewidth
};
break;
default:
throw new TrackIO.TrackLoadException("Invalid line type at ID " + ID);
}
if (l is StandardLine)
{
if (!addedlines.ContainsKey(l.ID))
{
addedlines[ID] = (StandardLine)l;
ret.AddLine(l);
}
}
else
{
ret.AddLine(l);
}
}
ret.Triggers = TriggerConverter.ConvertTriggers(linetriggers, ret);
if (br.BaseStream.Position != br.BaseStream.Length)
{
var meta = br.ReadInt32();
if (meta == ('M' | 'E' << 8 | 'T' << 16 | 'A' << 24))
{
ParseMetadata(ret, br);
}
else
{
throw new TrackIO.TrackLoadException("Expected metadata tag but got " + meta.ToString("X8"));
}
}
}
return(ret);
}
/// <summary>
/// Redraws the red line accel indicator.
/// </summary>
private void DrawAccel(RedLine line, bool hide)
{
var entry = _lookup[line.ID];
var newdecor = hide ? new GenericVertex[ShapeSize * line.Multiplier] : GetAccelDecor(line);
int shapes = newdecor.Length / ShapeSize;
for (int ix = 0; ix < entry.shapes; ix++)
{
int offset = entry.start + (ix * ShapeSize);
if (IsNulled(offset))
{
continue;//nulled out
}
_freeverts.Enqueue(_indices.unsafe_array[offset]);
for (int i = 0; i < ShapeSize; i++)
{
_indices.unsafe_array[offset + i] = nullindex;
}
}
bool growing = shapes > entry.shapes;
_accelbuffer.Bind();
for (int ix = 0; ix < shapes; ix++)
{
var vertexbase = GetVertexBase();
_accelbuffer.SetData(
newdecor,
ShapeSize * ix,
vertexbase,
ShapeSize);
for (int i = 0; i < ShapeSize; i++)
{
if (growing)
{
_indices.Add(vertexbase + i);
}
else
{
int offset = entry.start + (ix * ShapeSize) + i;
_indices.unsafe_array[offset] = vertexbase + i;
}
}
}
_accelbuffer.Unbind();
_accelibo.Bind();
_accelibo.SetData(
_indices.unsafe_array,
entry.start,
entry.start,
entry.shapes * ShapeSize);
if (growing)
{
int startindex = _indices.Count - (shapes * ShapeSize);
EnsureIBOSize(_indices.Count);
_accelibo.SetData(
_indices.unsafe_array,
startindex,
startindex,
shapes * ShapeSize);
_lookup[line.ID] = new accelentry()
{
shapes = shapes,
start = startindex
};
}
_accelibo.Unbind();
}
public void LineChanged(RedLine line, bool hit)
{
DrawAccel(line, hit);
}
public static Track LoadTrack(string trackfile, string trackname)
{
var ret = new Track();
ret.Filename = trackfile;
ret.Name = trackname;
var addedlines = new Dictionary <int, StandardLine>();
var location = trackfile;
var bytes = File.ReadAllBytes(location);
using (var file =
new MemoryStream(bytes))
{
var br = new BinaryReader(file);
int magic = br.ReadInt32();
if (magic == ('T' | 'R' << 8 | 'K' << 16 | 0xF2 << 24))
{
byte version = br.ReadByte();
string[] features = Encoding.ASCII.GetString(br.ReadBytes(br.ReadInt16())).Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (version != 1)
{
throw new TrackIO.TrackLoadException("Unsupported version");
}
bool redmultipier = false;
bool scenerywidth = false;
bool supports61 = false;
bool songinfo = false;
bool ignorabletrigger = false;
for (int i = 0; i < features.Length; i++)
{
switch (features[i])
{
case "REDMULTIPLIER":
redmultipier = true;
break;
case "SCENERYWIDTH":
scenerywidth = true;
break;
case "6.1":
supports61 = true;
break;
case "SONGINFO":
songinfo = true;
break;
case "IGNORABLE_TRIGGER":
ignorabletrigger = true;
break;
case "ZEROSTART":
ret.ZeroStart = true;
break;
default:
throw new TrackIO.TrackLoadException("Unsupported feature");
}
}
if (supports61)
{
ret.SetVersion(61);
}
else
{
ret.SetVersion(62);
}
if (songinfo)
{
var song = br.ReadString();
try
{
var strings = song.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
var fn = Program.UserDirectory + "Songs" +
Path.DirectorySeparatorChar +
strings[0];
if (File.Exists(fn))
{
if (AudioService.LoadFile(ref fn))
{
Settings.Local.CurrentSong = new Song(Path.GetFileName(fn), float.Parse(strings[1]));
Settings.Local.EnableSong = true;
}
else
{
Program.NonFatalError("An unknown error occured trying to load the song file");
}
}
}
catch
{
// ignored
}
}
ret.StartOffset = new Vector2d(br.ReadDouble(), br.ReadDouble());
var lines = br.ReadInt32();
for (var i = 0; i < lines; i++)
{
GameLine l;
byte ltype = br.ReadByte();
var lt = (LineType)(ltype & 0x1F);//we get 5 bits
var inv = (ltype >> 7) != 0;
var lim = (ltype >> 5) & 0x3;
var ID = -1;
var prvID = -1;
var nxtID = -1;
var multiplier = 1;
var linewidth = 1f;
LineTrigger tr = ignorabletrigger ? new LineTrigger() : null;
if (redmultipier)
{
if (lt == LineType.Red)
{
multiplier = br.ReadByte();
}
}
if (lt == LineType.Blue || lt == LineType.Red)
{
if (ignorabletrigger)
{
bool zoomtrigger = br.ReadBoolean();
if (zoomtrigger)
{
tr.Zoomtrigger = true;
var target = br.ReadSingle();
var frames = br.ReadInt16();
tr.ZoomFrames = frames;
tr.ZoomTarget = target;
}
else
{
tr = null;
}
}
ID = br.ReadInt32();
if (lim != 0)
{
prvID = br.ReadInt32(); //ignored
nxtID = br.ReadInt32(); //ignored
}
}
if (lt == LineType.Scenery)
{
if (scenerywidth)
{
float b = br.ReadByte();
linewidth = b / 10f;
}
}
var x1 = br.ReadDouble();
var y1 = br.ReadDouble();
var x2 = br.ReadDouble();
var y2 = br.ReadDouble();
switch (lt)
{
case LineType.Blue:
var bl = new StandardLine(new Vector2d(x1, y1), new Vector2d(x2, y2), inv);
bl.ID = ID;
bl.Extension = (StandardLine.Ext)lim;
l = bl;
bl.Trigger = tr;
break;
case LineType.Red:
var rl = new RedLine(new Vector2d(x1, y1), new Vector2d(x2, y2), inv);
rl.ID = ID;
rl.Extension = (StandardLine.Ext)lim;
if (redmultipier)
{
rl.Multiplier = multiplier;
}
l = rl;
rl.Trigger = tr;
break;
case LineType.Scenery:
l = new SceneryLine(new Vector2d(x1, y1), new Vector2d(x2, y2))
{
Width = linewidth
};
break;
default:
throw new TrackIO.TrackLoadException("Invalid line type at ID " + ID);
}
if (l is StandardLine)
{
if (!addedlines.ContainsKey(l.ID))
{
addedlines[ID] = (StandardLine)l;
ret.AddLine(l);
}
}
else
{
ret.AddLine(l);
}
}
}
}
return(ret);
}
public static Track LoadTrack(sol_track trackdata)
{
var ret = new Track {
Name = trackdata.name, Filename = trackdata.filename
};
var buffer = (List <Amf0Object>)trackdata.get_property("data");
List <GameLine> lineslist = new List <GameLine>(buffer.Count);
var addedlines = new Dictionary <int, StandardLine>(buffer.Count);
var version = trackdata.data.First(x => x.name == "version").data as string;
if (version == "6.1")
{
ret.SetVersion(61);
}
else
{
ret.SetVersion(62);
}
try
{
var options = (List <Amf0Object>)trackdata.get_property("trackData");
if (options.Count >= 2)
{
try
{
ret.ZeroStart = (bool)options.Find(x => x.name == "2").get_property("5");
}
catch
{
//ignored
}
}
}
catch
{
//ignored
}
for (var i = buffer.Count - 1; i >= 0; --i)
{
var line = (List <Amf0Object>)buffer[i].data;
var type = Convert.ToInt32(line[9].data, CultureInfo.InvariantCulture);
switch (type)
{
case 0:
{
var l =
new StandardLine(
new Vector2d(Convert.ToDouble(line[0].data, CultureInfo.InvariantCulture),
Convert.ToDouble(line[1].data, CultureInfo.InvariantCulture)),
new Vector2d(Convert.ToDouble(line[2].data, CultureInfo.InvariantCulture),
Convert.ToDouble(line[3].data, CultureInfo.InvariantCulture)),
Convert.ToBoolean(line[5].data, CultureInfo.InvariantCulture))
{
ID = Convert.ToInt32(line[8].data, CultureInfo.InvariantCulture)
};
l.Extension = (StandardLine.Ext)(
Convert.ToInt32(
line[4].data,
CultureInfo.InvariantCulture));
if (line[6].data != null)
{
var prev = Convert.ToInt32(line[6].data, CultureInfo.InvariantCulture);
}
if (line[7].data != null)
{
var next = Convert.ToInt32(line[7].data, CultureInfo.InvariantCulture);
}
if (!addedlines.ContainsKey(l.ID))
{
lineslist.Add(l);
addedlines[l.ID] = l;
}
}
break;
case 1:
{
var l =
new RedLine(
new Vector2d(Convert.ToDouble(line[0].data, CultureInfo.InvariantCulture),
Convert.ToDouble(line[1].data, CultureInfo.InvariantCulture)),
new Vector2d(Convert.ToDouble(line[2].data, CultureInfo.InvariantCulture),
Convert.ToDouble(line[3].data, CultureInfo.InvariantCulture)),
Convert.ToBoolean(line[5].data, CultureInfo.InvariantCulture))
{
ID = Convert.ToInt32(line[8].data, CultureInfo.InvariantCulture)
};
l.Extension = (StandardLine.Ext)(
Convert.ToInt32(
line[4].data,
CultureInfo.InvariantCulture));
if (line[6].data != null)
{
var prev = Convert.ToInt32(line[6].data, CultureInfo.InvariantCulture);
}
if (line[7].data != null)
{
var next = Convert.ToInt32(line[7].data, CultureInfo.InvariantCulture);
}
if (!addedlines.ContainsKey(l.ID))
{
lineslist.Add(l);
addedlines[l.ID] = l;
}
}
break;
case 2:
lineslist.Add(
new SceneryLine(
new Vector2d(Convert.ToDouble(line[0].data, CultureInfo.InvariantCulture),
Convert.ToDouble(line[1].data, CultureInfo.InvariantCulture)),
new Vector2d(Convert.ToDouble(line[2].data, CultureInfo.InvariantCulture),
Convert.ToDouble(line[3].data, CultureInfo.InvariantCulture))));
break;
default:
throw new TrackIO.TrackLoadException("Unknown line type");
}
}
var startlineprop = trackdata.get_property("startLine");
var startline = startlineprop as List <Amf0Object>;
if (startline == null && startlineprop is double)
{
var conv = Convert.ToInt32(startlineprop, CultureInfo.InvariantCulture);
if (conv >= ret.Lines.Count || conv < 0)
{
startline = new List <Amf0Object>();
startline.Add(new Amf0Object {
data = 100
});
startline.Add(new Amf0Object {
data = 100
});
}
}
else if (startlineprop is double)
{
var conv = Convert.ToInt32(startlineprop, CultureInfo.InvariantCulture);
startline = new List <Amf0Object>();
startline.Add(new Amf0Object {
data = lineslist[conv].Position.X
});
startline.Add(new Amf0Object {
data = lineslist[conv].Position.Y - 50 * 0.5
});
}
ret.StartOffset = new Vector2d(
Convert.ToDouble(startline[0].data, CultureInfo.InvariantCulture),
Convert.ToDouble(startline[1].data, CultureInfo.InvariantCulture));
foreach (var line in lineslist)
{
ret.AddLine(line);
}
return(ret);
}
private static void MoveFrameRelative(List <LineSelection> selectedLines, int direction, bool isCompleteAction)
{
RiderFrame flag = window.Track.GetFlag();
int currentFrame = window.Track.Offset;
if (flag == null || currentFrame <= flag.FrameID)
{
// Behavior only defined if flag is set and current frame is ahead of it
return;
}
Rider flagFrameRider = flag.State;
Rider flagNextFrameRider = window.Track.Timeline.ExtractFrame(flag.FrameID + 1).State;
// Where the Rider was at the flag frame, and the frame after that
// This establishes the initial frame of reference
//
// flagNextFrameRider is considered to be the frame with 0 relative velocity to the reference frame
// All frames after will look as if the rider has started falling within the reference frame, because gravity.
//
// This is all if the user-configured relative speeds are (0, 0). If the user changes these speeds,
// the lines will be drawn accordingly.
Vector2d flagFramePos = Game.Rider.GetBounds(flagFrameRider).Vector;
Vector2d flagNextFramePos = Game.Rider.GetBounds(flagNextFrameRider).Vector;
// The difference between where the rider was on frames 0 and 1 establishes a reference speed to apply
Vector2d firstFrameDiff = Vector2d.Subtract(flagNextFramePos, flagFramePos);
// Add the user-configurable speed offsets
firstFrameDiff = Vector2d.Add(firstFrameDiff, new Vector2d(Settings.animationRelativeVelX, Settings.animationRelativeVelY));
int framesElapsed = currentFrame - flag.FrameID;
// Apply the speed vector to the number of elapsed frames, and add it to the initial reference frame
// to get an expected position for the current frame
Vector2d currentFrameExpectedPos = Vector2d.Add(Vector2d.Multiply(firstFrameDiff, framesElapsed), flagFramePos);
// Same for the next frame
Vector2d nextFrameExpectedPos = Vector2d.Add(Vector2d.Multiply(firstFrameDiff, framesElapsed + direction), flagFramePos);
if (isCompleteAction)
{
window.Invalidate();
window.Track.UndoManager.BeginAction();
}
TrackWriter trackWriter = window.Track.CreateTrackWriter();
List <GameLine> newLines = new List <GameLine>();
foreach (LineSelection selection in selectedLines)
{
GameLine selectedLine = selection.line;
Vector2d p1 = selectedLine.Position;
Vector2d p2 = selectedLine.Position2;
Vector2d diff1 = Vector2d.Subtract(p1, currentFrameExpectedPos);
Vector2d diff2 = Vector2d.Subtract(p2, currentFrameExpectedPos);
Vector2d nextP1 = Vector2d.Add(nextFrameExpectedPos, diff1);
Vector2d nextP2 = Vector2d.Add(nextFrameExpectedPos, diff2);
// Add a new line in the same position, then move the existing line to maintain the selection
GameLine newLine;
if (!Settings.forwardLinesAsScenery && (direction > 0 || !Settings.recededLinesAsScenery))
{
switch (selection.line.Type)
{
case LineType.Red:
newLine = new RedLine(nextP1, nextP2, ((RedLine)selectedLine).inv);
break;
case LineType.Blue:
newLine = new StandardLine(nextP1, nextP2, ((StandardLine)selectedLine).inv);
break;
case LineType.Scenery:
newLine = new SceneryLine(nextP1, nextP2);
break;
default:
newLine = new SceneryLine(nextP1, nextP2);
break;
}
}
else
{
newLine = new SceneryLine(nextP1, nextP2);
}
newLines.Add(newLine);
}
var selectTool = CurrentTools.SelectTool;
foreach (GameLine newLine in newLines)
{
trackWriter.AddLine(newLine);
}
selectTool.SelectLines(newLines);
if (isCompleteAction)
{
window.Track.UndoManager.EndAction();
window.Track.NotifyTrackChanged();
}
}
