public void RemoveLine(StandardLine line)
{
var positions = GetGridPositions(line);
using (_sync.AcquireWrite())
{
foreach (var pos in positions)
{
Unregister(line, pos.X, pos.Y);
}
}
}
private void Register(StandardLine l, int x, int y)
{
var key = GetCellKey(x, y);
SimulationCell cell;
if (!Cells.TryGetValue(key, out cell))
{
cell = new SimulationCell();
Cells[key] = cell;
}
cell.AddLine(l);
}
public void AddExtensionChange(StandardLine l1, StandardLine l2, bool add)
{
if (!_working)
{
if (_actions.Count == 0)
{
return;
}
var ac = new ExtensionAction(l1, l2, add);
var act = (lineaction)_actions[_actions.Count - 1];
act.extensions.Add(ac);
}
}
/// <summary>
/// Removes the line ID in all old grid cells and adds it back to new
/// ones
/// </summary>
public void MoveLine(Vector2d old1, Vector2d old2, StandardLine line)
{
var oldpos = GetGridPositions(old1, old2, GridVersion);
var newpos = GetGridPositions(line);
using (_sync.AcquireWrite())
{
foreach (var v in oldpos)
{
Unregister(line, v.X, v.Y);
}
foreach (var v in newpos)
{
Register(line, v.X, v.Y);
}
}
}
public void TryDisconnectLines(StandardLine l1, StandardLine l2, bool undo = true)
{
if (l1 == null || l2 == null)
{
return;
}
Vector2d joint;
if (l1.Position == l2.Position || l1.Position == l2.Position2)
{
joint = l1.Position;
}
else if (l1.Position2 == l2.Position || l1.Position2 == l2.Position2)
{
joint = l1.Position2;
}
else
{
return;
}
//var leftlink = (l1.CompliantPosition == joint && l2.CompliantPosition2 == joint);
var rightlink = (l1.CompliantPosition2 == joint && l2.CompliantPosition == joint);
if (rightlink)
{
l1.Next = null;
l1.RemoveExtension(StandardLine.ExtensionDirection.Right);
l2.Prev = null;
l2.RemoveExtension(StandardLine.ExtensionDirection.Left);
if (undo)
{
UndoManager.AddExtensionChange(l1, l2, false);
}
}
else
{
l1.Prev = null;
l1.RemoveExtension(StandardLine.ExtensionDirection.Left);
l2.Next = null;
l2.RemoveExtension(StandardLine.ExtensionDirection.Right);
if (undo)
{
UndoManager.AddExtensionChange(l2, l1, false);
}
}
}
public override void OnMouseUp(Vector2d pos)
{
game.Invalidate();
if (_started)
{
_started = false;
var diff = _end - _start;
var x = diff.X;
var y = diff.Y;
if (Math.Abs(x) + Math.Abs(y) < MINIMUM_LINE / game.Track.Zoom && (_end != _start || game.Canvas.ColorControls.Selected != LineType.Scenery))
{
return;
}
AddLine();
_last = null;
}
base.OnMouseUp(pos);
}
private void AddLine()
{
Line added = null;
switch (game.Canvas.ColorControls.Selected)
{
case LineType.Blue:
added = new StandardLine(_start, _end, false)
{
inv = inv
};
added.CalculateConstants();
break;
case LineType.Red:
added = new RedLine(_start, _end, false)
{
inv = inv
};
(added as RedLine).Multiplier = game.Canvas.ColorControls.RedMultiplier;
added.CalculateConstants();
break;
case LineType.Scenery:
added = new SceneryLine(_start, _end)
{
Width = game.Canvas.ColorControls.GreenMultiplier
};
break;
}
game.Track.AddLine(added);
if (added is StandardLine)
{
var stl = added as StandardLine;
game.Track.TryConnectLines(stl, _last);
_last = stl;
}
if (game.Canvas.ColorControls.Selected != LineType.Scenery)
{
game.Track.ChangeMade(_start, _end);
game.Track.TrackUpdated();
}
game.Invalidate();
}
public override void OnMouseDown(Vector2d pos)
{
_started = true;
_last = null;
if (game.EnableSnap)
{
var gamepos = MouseCoordsToGame(pos);
var ssnap = Snap(gamepos);
var snap = ssnap as StandardLine;
if (snap != null)
{
_start = (snap.CompliantPosition - gamepos).Length < (snap.CompliantPosition2 - gamepos).Length ? snap.CompliantPosition : snap.CompliantPosition2;
_last = snap;
}
else if (ssnap != null)
{
_start = (ssnap.Position - gamepos).Length < (ssnap.Position2 - gamepos).Length
? ssnap.Position
: ssnap.Position2;
}
else
{
_start = gamepos;
}
}
else
{
_start = MouseCoordsToGame(pos);
}
var state = OpenTK.Input.Keyboard.GetState();
inv = state[OpenTK.Input.Key.ShiftLeft] || state[OpenTK.Input.Key.ShiftRight];
_end = _start;
game.Invalidate();
base.OnMouseDown(pos);
}
private SimulationCell GetPairs(StandardLine input)
{
var list = new SimulationCell();
var c1 = _editorcells.GetCellFromPoint(input.Position);
var c2 = _editorcells.GetCellFromPoint(input.Position2);
var cells = new LineContainer <GameLine>[]
{
c1,
c1 == c2 ? null : c2
};
foreach (var cell in cells)
{
if (cell == null)
{
continue;
}
foreach (var line in cell)
{
if (line.Type == LineType.Scenery)
{
continue;
}
if (line.ID != input.ID)
{
if (
line.End == input.Start ||
line.Start == input.End)
{
list.AddLine((StandardLine)line);
}
}
}
}
return(list);
}
public List <CellLocation> GetGridPositions(StandardLine line)
{
return(GetGridPositions(line, GridVersion));
}
public List <Line> Erase(Vector2d pos, LineType t, float zoom)
{
List <Line> ret = new List <Line>();
var eraser = new Vector2d(5 / zoom, 5 / zoom);
var searchrect = new FloatRect((Vector2)(pos - eraser), (Vector2)(eraser * 2));
searchrect = searchrect.Inflate(24, 24);
var fr = new FloatRect((Vector2)(pos - eraser), (Vector2)(eraser * 2));
var lines = FastChunks.LinesInChunks(FastChunks.UsedChunksInRect(fr));
foreach (var line in lines)
{
var scenery = line as SceneryLine;
if (scenery != null)
{
var sceneryeraser = new Vector2d((5 / zoom) * scenery.Width, (5 / zoom) * scenery.Width);
var sceneryfr = new FloatRect((Vector2)(pos - sceneryeraser), (Vector2)(sceneryeraser * 2));
if (!Line.DoesLineIntersectRect(line, sceneryfr))
{
continue;
}
}
else
{
if (!Line.DoesLineIntersectRect(line, fr))
{
continue;
}
}
if (!(t == LineType.All || ((t == LineType.Red && line.GetLineType() == LineType.Red) ||
(t == LineType.Blue && line.GetLineType() == LineType.Blue) ||
(t == LineType.Scenery && line.GetLineType() == LineType.Scenery))))
{
continue;
}
var sl = line as StandardLine;
StandardLine pl1 = null;
StandardLine pl2 = null;
StandardLine nl1 = null;
StandardLine nl2 = null;
if (sl != null)
{
if (sl.Prev != null)
{
pl1 = sl.Prev;
pl2 = sl;
sl.Prev.Next = null;
sl.Prev.RemoveExtension(StandardLine.ExtensionDirection.Right);
sl.RemoveExtension(StandardLine.ExtensionDirection.Left);
sl.Prev = null;
}
if (sl.Next != null)
{
nl1 = sl;
nl2 = sl.Next;
sl.Next.Prev = null;
sl.Next.RemoveExtension(StandardLine.ExtensionDirection.Left);
sl.RemoveExtension(StandardLine.ExtensionDirection.Right);
sl.Next = null;
}
}
RemoveLine(line);
ret.Add(line);
if (pl1 != null)
{
UndoManager.AddExtensionChange(pl1, pl2, false);
}
if (nl1 != null)
{
UndoManager.AddExtensionChange(nl1, nl2, false);
}
}
return(ret);
}
public static Track LoadTrack(sol_track trackdata)
{
var ret = new Track {
Name = trackdata.name
};
var buffer = (List <Amf0Object>)trackdata.get_property("data");
var addedlines = new Dictionary <int, StandardLine>();
var version = trackdata.data.First(x => x.name == "version").data as string;
if (version == "6.1")
{
ret.SetVersion(6.1m);
}
else
{
ret.SetVersion(6.2m);
}
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
}
var extensions = new List <Extensionentry>();
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.SetExtension(Convert.ToInt32(line[4].data, CultureInfo.InvariantCulture));
if (line[6].data != null)
{
var prev = Convert.ToInt32(line[6].data, CultureInfo.InvariantCulture);
extensions.Add(new Extensionentry {
Line = l, Linkid = prev, Next = false
});
}
if (line[7].data != null)
{
var next = Convert.ToInt32(line[7].data, CultureInfo.InvariantCulture);
extensions.Add(new Extensionentry {
Line = l, Linkid = next, Next = true
});
}
if (!addedlines.ContainsKey(l.ID))
{
ret.AddLines(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.SetExtension(Convert.ToInt32(line[4].data, CultureInfo.InvariantCulture));
if (line[6].data != null)
{
var prev = Convert.ToInt32(line[6].data, CultureInfo.InvariantCulture);
extensions.Add(new Extensionentry {
Line = l, Linkid = prev, Next = false
});
}
if (line[7].data != null)
{
var next = Convert.ToInt32(line[7].data, CultureInfo.InvariantCulture);
extensions.Add(new Extensionentry {
Line = l, Linkid = next, Next = true
});
}
if (!addedlines.ContainsKey(l.ID))
{
ret.AddLines(l);
addedlines[l.ID] = l;
}
}
break;
case 2:
ret.AddLines(
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 Exception("Unknown line type");
}
}
foreach (var v in extensions)
{
if (v.Next)
{
StandardLine sl;
if (addedlines.TryGetValue(v.Linkid, out sl))
{
v.Line.Next = sl;
sl.Prev = v.Line;
}
}
else //prev
{
StandardLine sl;
if (addedlines.TryGetValue(v.Linkid, out sl))
{
v.Line.Prev = sl;
sl.Next = v.Line;
}
}
}
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 = ret.Lines[conv].Position.X
});
startline.Add(new Amf0Object {
data = ret.Lines[conv].Position.Y - 50 * 0.5
});
}
ret.Start.X = Convert.ToDouble(startline[0].data, CultureInfo.InvariantCulture);
ret.Start.Y = Convert.ToDouble(startline[1].data, CultureInfo.InvariantCulture);
ret.ResetUndo();
ret.ResetChanges();
return(ret);
}
public static Track LoadTrackTRK(string track, string savename)
{
var ret = new Track();
ret.Name = track;
var addedlines = new Dictionary <int, StandardLine>();
var extensions = new List <Extensionentry>();
var location = Program.CurrentDirectory + "Tracks" + Path.DirectorySeparatorChar + track;
if (savename != null)
{
location += Path.DirectorySeparatorChar + savename + ".trk";
}
else
{
location += ".trk";
}
using (var file =
File.Open(location, FileMode.Open))
{
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 Exception("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 Exception("Unsupported feature");
}
}
if (supports61)
{
ret.SetVersion(6.1m);
}
else
{
ret.SetVersion(6.2m);
}
if (songinfo)
{
var song = br.ReadString();
try
{
var strings = song.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
var fn = Program.CurrentDirectory + "Songs" +
Path.DirectorySeparatorChar +
strings[0];
if (File.Exists(fn))
{
if (AudioPlayback.LoadFile(ref fn))
{
game.CurrentSong = new Song(Path.GetFileName(fn), float.Parse(strings[1]));
game.EnableSong = true;
}
else
{
Program.NonFatalError("An unknown error occured trying to load the song file");
}
}
}
catch
{
// ignored
}
}
ret.Start = new Vector2d(br.ReadDouble(), br.ReadDouble());
var lines = br.ReadInt32();
for (var i = 0; i < lines; i++)
{
Line 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();
nxtID = br.ReadInt32();
}
}
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.SetExtension(lim);
l = bl;
if (prvID != -1)
{
extensions.Add(new Extensionentry {
Line = bl, Linkid = prvID, Next = false
});
}
if (nxtID != -1)
{
extensions.Add(new Extensionentry {
Line = bl, Linkid = nxtID, Next = true
});
}
bl.Trigger = tr;
break;
case LineType.Red:
var rl = new RedLine(new Vector2d(x1, y1), new Vector2d(x2, y2), inv);
rl.ID = ID;
rl.SetExtension(lim);
if (redmultipier)
{
rl.Multiplier = multiplier;
}
l = rl;
if (prvID != -1)
{
extensions.Add(new Extensionentry {
Line = rl, Linkid = prvID, Next = false
});
}
if (nxtID != -1)
{
extensions.Add(new Extensionentry {
Line = rl, Linkid = nxtID, Next = true
});
}
rl.Trigger = tr;
break;
case LineType.Scenery:
l = new SceneryLine(new Vector2d(x1, y1), new Vector2d(x2, y2))
{
Width = linewidth
};
break;
default:
throw new Exception("Invalid line type");
}
if (l is StandardLine)
{
if (!addedlines.ContainsKey(l.ID))
{
addedlines[ID] = (StandardLine)l;
ret.AddLines(l);
}
}
else
{
ret.AddLines(l);
}
}
}
}
foreach (var v in extensions)
{
if (v.Next)
{
StandardLine sl;
if (addedlines.TryGetValue(v.Linkid, out sl))
{
//if (sl.Extension == StandardLine.ExtensionDirection.Right || sl.Extension == StandardLine.ExtensionDirection.Both)
{
v.Line.Next = sl;
sl.Prev = v.Line;
}
}
}
else //prev
{
StandardLine sl;
if (addedlines.TryGetValue(v.Linkid, out sl))
{
//if (sl.Extension == StandardLine.ExtensionDirection.Left || sl.Extension == StandardLine.ExtensionDirection.Both)
{
v.Line.Prev = sl;
sl.Next = v.Line;
}
}
}
}
ret.ResetUndo();
ret.ResetChanges();
return(ret);
}
public static List <CellLocation> GetGridPositions(StandardLine line, int gridversion)
{
return(GetGridPositions(line.Position, line.Position2, gridversion));
}
public void SelectLine(Vector2d pos)
{
_started = true;
var gamepos = MouseCoordsToGame(pos);
var ssnap = Snap(gamepos);
var snap = ssnap as StandardLine;
var keyboard = Keyboard.GetState();
if (snap == null)
{
if (ssnap == null)
{
_started = false;
return;
}
else//scenery
{
if ((ssnap.Position - gamepos).Length < (ssnap.Position2 - gamepos).Length)
{
_joint = Joint.Left;
_startPos = ssnap.Position;
}
else
{
_joint = Joint.Right;
_startPos = ssnap.Position2;
}
_snappedline = Snap(_startPos, ssnap);
if (_snappedline is StandardLine)
{
_snappedline = null;
}
_nonphysicalline = ssnap;
_originalPos1 = _nonphysicalline.Position;
_originalPos2 = _nonphysicalline.Position2;
UpdateTooltip();
game.Invalidate();
if (keyboard[Key.ControlLeft] || keyboard[Key.ControlRight])
{
_joint = Joint.Both;
_snappedline = null;
}
return;
}
}
if (keyboard[Key.AltLeft] || keyboard[Key.AltRight])
{
if (game.Track.Animating)
{
game.Track.EnterPlayback();
{
if (!DoLifelock())
{
LifeLock = true;
}
else
{
_started = false;
game.Track.ExitPlayback();
return;
}
game.Track.ExitPlayback();
}
}
}
if ((snap.Position - gamepos).Length < (snap.Position2 - gamepos).Length)
{
_joint = Joint.Left;
_startPos = snap.Position;
}
else
{
_joint = Joint.Right;
_startPos = snap.Position2;
}
_snappedline = Snap(_startPos, ssnap);
if (!(_snappedline is StandardLine))
{
_snappedline = null;
}
else
{
if ((_snappedline.Position - _startPos).Length < (_snappedline.Position2 - _startPos).Length)
{
_snapjoint = Joint.Left;
}
else
{
_snapjoint = Joint.Right;
}
_snaporiginalpos1 = _snappedline.Position;
_snaporiginalpos2 = _snappedline.Position2;
}
if (keyboard[Key.ControlLeft] || keyboard[Key.ControlRight])
{
_joint = Joint.Both;
_snappedline = null;
}
_line = snap;
UpdateTooltip();
_originalPos1 = _line.CompliantPosition;
_originalPos2 = _line.CompliantPosition2;
if (_line.Prev != null)
{
_prev = _line.Prev;
_line.Prev.Next = null;
_line.Prev.RemoveExtension(StandardLine.ExtensionDirection.Right);
_line.RemoveExtension(StandardLine.ExtensionDirection.Left);
_line.Prev = null;
}
else
{
_prev = null;
}
if (_line.Next != null)
{
_next = _line.Next;
_line.Next.Prev = null;
_line.Next.RemoveExtension(StandardLine.ExtensionDirection.Left);
_line.RemoveExtension(StandardLine.ExtensionDirection.Right);
_line.Next = null;
}
else
{
_next = null;
}
_snext = null;
_sprev = null;
if (_snappedline is StandardLine)
{
var snl = _snappedline as StandardLine;
if (snl.Next != null)
{
_snext = snl.Next;
snl.Next.Prev = null;
snl.Next.RemoveExtension(StandardLine.ExtensionDirection.Left);
snl.RemoveExtension(StandardLine.ExtensionDirection.Right);
snl.Next = null;
}
if (snl.Prev != null)
{
_sprev = snl.Prev;
snl.Prev.Next = null;
snl.Prev.RemoveExtension(StandardLine.ExtensionDirection.Right);
snl.RemoveExtension(StandardLine.ExtensionDirection.Left);
snl.Prev = null;
}
}
game.Track.ChangeMade(_originalPos1, _originalPos2);
game.Invalidate();
}
public void Select(StandardLine line, Vector2d position)
{
if (selectionwindow != null)
{
if (selectionwindow.UserData != line)
{
selectionwindow.Close();
selectionwindow = null;
}
}
if (selectionwindow == null)
{
selectionwindow = new WindowControl(game.Canvas, "Line Settings", false);
selectionwindow.MakeModal(true);
selectionwindow.UserData = line;
selectionwindow.DeleteOnClose = true;
selectionwindow.DisableResizing();
selectionwindow.Height = 170;
selectionwindow.Width = 150;
ControlBase container1 = new ControlBase(selectionwindow);
container1.Dock = Gwen.Pos.Fill;
if (line.GetLineType() != LineType.Scenery)
{
LabeledCheckBox btn = new LabeledCheckBox(container1);
btn.Dock = Gwen.Pos.Top;
btn.Text = "Inverse";
btn.IsChecked = line.inv;
btn.CheckChanged += (o, e) =>
{
var caller = (LabeledCheckBox)o;
line.inv = caller.IsChecked;
line.CalculateConstants();
game.Track.TrackUpdated();
game.Invalidate();
};
LineTrigger tr = (LineTrigger)line.Trigger ?? new LineTrigger();
var gb = new PropertyTree(container1);
gb.Height = 110;
gb.Dock = Gwen.Pos.Top;
PropertyTree table = new PropertyTree(gb);
table.Name = "triggers";
table.Dock = Gwen.Pos.Fill;
table.Height = 100;
var row = table.Add("Zoom Trigger");
var enabled = row.Add("Enabled", new Gwen.Controls.Property.Check(table));
enabled.Value = tr.Zoomtrigger ? "1" : "0";
enabled.ValueChanged += (o, e) =>
{
if (enabled.Value == "1")
{
tr.Zoomtrigger = true;
tr.ZoomTarget = float.Parse(((PropertyRow)container1.FindChildByName("Zoom", true)).Value);
tr.ZoomFrames = int.Parse(((PropertyRow)container1.FindChildByName("ZoomFrames", true)).Value);
line.Trigger = tr;
}
else
{
tr.Zoomtrigger = false;
if (!tr.Enabled)
{
line.Trigger = null;
}
}
game.Track.LineChanged(line);
};
var prop = row.Add("Zoom");
prop.Name = "Zoom";
prop.Value = (enabled.Value == "1" ? tr.ZoomTarget : 1).ToString();
prop.ValueChanged += (o, e) =>
{
var caller = (PropertyRow)o;
float val = 0;
if (float.TryParse(caller.Value, out val) && val >= 0.1 && val <= 24)
{
caller.LabelColor = System.Drawing.Color.Black;
tr.ZoomTarget = val;
}
else
{
caller.LabelColor = System.Drawing.Color.Red;
}
};
prop = row.Add("Frames");
prop.Name = "ZoomFrames";
prop.Value = (enabled.Value == "1" ? tr.ZoomFrames : 40).ToString();
prop.ValueChanged += (o, e) =>
{
var caller = (PropertyRow)o;
int val = 0;
if (int.TryParse(caller.Value, out val) && val >= 1 && val < 10000)
{
caller.LabelColor = System.Drawing.Color.Black;
tr.ZoomFrames = val;
}
else
{
caller.LabelColor = System.Drawing.Color.Red;
}
};
}
if (line.GetLineType() == LineType.Red)
{
selectionwindow.Height += 30;
NoDecimalNUD nud = new NoDecimalNUD(container1);
var marg = nud.Margin;
marg.Top = 5;
marg.Left = marg.Right = 1;
marg.Left = 70;
marg.Bottom = 10;
nud.Margin = marg;
nud.Dock = Gwen.Pos.Top;
nud.Min = 1;
nud.Max = 3;
nud.Value = (line as RedLine).Multiplier;
nud.ValueChanged += nud_redlinemultiplier_ValueChanged;
nud.UserData = line;
Label l = new Label(container1);
l.Y = 137;
l.Text = "Multiplier";
selectionwindow.Height += 25;
nud = new NoDecimalNUD(container1);
marg = nud.Margin;
marg.Top = 5;
marg.Left = marg.Right = 1;
marg.Left = 70;
marg.Bottom = 10;
nud.Margin = marg;
nud.Dock = Gwen.Pos.Top;
var lines = game.Track.GetLinesInRect(new FloatRect((Vector2)line.Position, new Vector2(1, 1)), false);
List <Line> redlines = new List <Line>();
foreach (var red in lines)
{
if (red.Position == line.Position && red.Position2 == line.Position2)
{
redlines.Add(red);
}
}
nud.Min = 1;
nud.Max = 50;
redlines.Sort(new Track.Linecomparer());
nud.Value = redlines.Count;
nud.ValueChanged += (o, e) =>
{
var diff = nud.Value - redlines.Count;
if (diff < 0)
{
for (int i = 0; i > diff; i--)
{
game.Track.RemoveLine(redlines[(int)((redlines.Count - 1))]);
redlines.RemoveAt(redlines.Count - 1);
}
}
else
{
for (int i = 0; i < diff; i++)
{
var red = new RedLine(line.Position, line.Position2, line.inv)
{
Multiplier = ((RedLine)line).Multiplier
};
game.Track.AddLine(red);
redlines.Add(red);
}
}
game.Track.TrackUpdated();
};
nud.UserData = line;
l = new Label(container1);
l.Y = 137 + 35;
l.Text = "Multilines";
}
selectionwindow.IsHiddenChanged += Selectionwindow_IsHiddenChanged;
selectionwindow.Show();
selectionwindow.X = (int)position.X;
selectionwindow.Y = (int)position.Y;
game.Cursor = MouseCursor.Default;
}
}
/// <summary>
/// Removes the line from the physics
/// </summary>
public void RemoveLineFromGrid(StandardLine line)
{
Grid.RemoveLine(line);
}
/// <summary>
/// Adds the line to the physics grid.
/// </summary>
public void AddLineToGrid(StandardLine line)
{
Grid.AddLine(line);
}
public ExtensionAction(StandardLine l, StandardLine l2, bool set)
{
L = l;
L2 = l2;
Add = set;
}
public void TryConnectLines(StandardLine l1, StandardLine l2, bool undo = true)
{
if (l1 == null || l2 == null)
{
return;
}
Vector2d joint;
if (l1.Position == l2.Position || l1.Position == l2.Position2)
{
joint = l1.Position;
}
else if (l1.Position2 == l2.Position || l1.Position2 == l2.Position2)
{
joint = l1.Position2;
}
else
{
return;
}
var leftlink = (l1.CompliantPosition == joint && l2.CompliantPosition2 == joint);
var rightlink = (l1.CompliantPosition2 == joint && l2.CompliantPosition == joint);
if (!leftlink && !rightlink)
{
return;
}
var diff1 = l2.CompliantPosition2 - l2.CompliantPosition;
var diff2 = l1.CompliantPosition2 - l1.CompliantPosition;
var angle1 = Angle.FromVector(diff1).Degrees; // (Math.Atan2(diff1.Y, diff1.X) * (180.0 / Math.PI));
var angle2 = Angle.FromVector(diff2).Degrees;
var anglediff1 = new Angle(angle1 - angle2).Degrees;
var anglediff2 = new Angle(angle2 - angle1).Degrees;
bool cmp1 = anglediff1 > 0 && anglediff1 <= 180;
bool cmp2 = anglediff2 > 0 && anglediff2 <= 180;
if ((rightlink) ? cmp2 : cmp1)
{
if (rightlink)
{
l1.Next = l2;
l1.AddExtension(StandardLine.ExtensionDirection.Right);
l2.Prev = l1;
l2.AddExtension(StandardLine.ExtensionDirection.Left);
if (undo)
{
UndoManager.AddExtensionChange(l1, l2, true);
}
}
else
{
l1.Prev = l2;
l1.AddExtension(StandardLine.ExtensionDirection.Left);
l2.Next = l1;
l2.AddExtension(StandardLine.ExtensionDirection.Right);
if (undo)
{
UndoManager.AddExtensionChange(l2, l1, true);
}
}
}
}
public override void OnMouseUp(Vector2d pos)
{
game.Invalidate();
if (_started)
{
_started = false;
var diff = _end - _start;
var x = diff.X;
var y = diff.Y;
if (Math.Abs(x) + Math.Abs(y) < MINIMUM_LINE)
{
return;
}
StandardLine next = null;
if (game.ShouldXySnap())
{
_end = SnapXY(_start, _end);
}
else if (game.EnableSnap)
{
var ssnap = Snap(_end);
var snap = ssnap as StandardLine;
if (snap != null)
{
var old = _end;
_end = (snap.CompliantPosition - _end).Length < (snap.CompliantPosition2 - _end).Length ? snap.CompliantPosition : snap.CompliantPosition2;
if (_end == _start)
{
_end = old;
}
else
{
next = snap;
}
}
else if (ssnap != null)
{
var old = _end;
_end = (ssnap.Position - _end).Length < (ssnap.Position2 - _end).Length
? ssnap.Position
: ssnap.Position2;
if (_end == _start)
{
_end = old;
}
}
}
if ((_end - _start).Length >= MINIMUM_LINE)
{
Line added = null;
switch (game.Canvas.ColorControls.Selected)
{
case LineType.Blue:
added = new StandardLine(_start, _end, _addflip);
break;
case LineType.Red:
added = new RedLine(_start, _end, _addflip);
(added as RedLine).Multiplier = game.Canvas.ColorControls.RedMultiplier;
break;
case LineType.Scenery:
added = new SceneryLine(_start, _end)
{
Width = game.Canvas.ColorControls.GreenMultiplier
};
break;
}
game.Track.AddLine(added);
if (added is StandardLine)
{
var stl = added as StandardLine;
game.Track.TryConnectLines(stl, _last);
game.Track.TryConnectLines(stl, next);
}
if (game.Canvas.ColorControls.Selected != LineType.Scenery)
{
game.Track.TrackUpdated();
}
game.Invalidate();
}
}
base.OnMouseUp(pos);
}
private void RemoveExtensions(StandardLine input)
{
UpdateExtensions(input, false);
}
private void AddExtensions(StandardLine input)
{
UpdateExtensions(input, true);
}
