public override void Show(Ship ship, Character character)
{
int numberofpoints = 0;
for (int i = Owner.point; i < Owner.Elements.Count; i++)
{
if (Owner.Elements[i] is PointElement)
{
numberofpoints++;
}
else
{
break;
}
}
int t_diff = Environment.TickCount - Owner.LastTick;
if (numberofpoints > 1 && t_diff > -1)
{
WaypointStructure current = new WaypointStructure(ship.Position, ship.Yaw);
PointElement A = Owner.Elements[Owner.point + 0] as PointElement;
PointElement B = Owner.Elements[Owner.point + 1] as PointElement;
ship.WideMovement(character, current, A.structure, B.structure);
}
else if (numberofpoints > 0 && t_diff > -1)
{
WaypointStructure current = new WaypointStructure(ship.Position, ship.Yaw);
PointElement A = Owner.Elements[Owner.point + 0] as PointElement;
ship.WideMovement(character, current, A.structure);
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
var point = new PointElement(100, 100, imageView.ImageElement)
{
Tag = "point"
};
point.OnElementChangeDoneEvent += Point_OnElementChangeDoneEvent;
imageView.AddPoint(point);
imageView.AddRectangle(new RectElement(100, 100, 100, 100));
imageView.AddLine(new LineElement(new Point(10, 10), new Point(100, 200)));
//var a = new TimePlotSeries("sd", Colors.Lime, 2);
//var times = new DateTime[] {DateTime.Now,DateTime.Now+TimeSpan.FromMinutes(10), DateTime.Now + TimeSpan.FromMinutes(20),
// DateTime.Now+TimeSpan.FromMinutes(30)};
//var values = new double[] { 10, 5, 10, 20 };
//a.SetData(times, values,DisplayMode.Normal);
//plot.Series.Add(a);
//plot.RefreshDataAndPlot();
//var b = new TimePlotSeries("sd", Colors.Lime, 2);
//var times1 = new DateTime[] {DateTime.Now,DateTime.Now+TimeSpan.FromMinutes(10), DateTime.Now + TimeSpan.FromMinutes(20),
// DateTime.Now+TimeSpan.FromMinutes(30)};
//var values2 = new double[] { 10, 5, 10, 20 };
//b.SetData(times1,values2,DisplayMode.NormalizationAndLogarithm);
////b.SetDisplayMode(DisplayMode.NormalizationAndLogarithm);
//timePlot.Series.Add(b);
//timePlot.UpdateData();
}
/// <summary>
/// прорисовать точку входа
/// </summary>
private void PaintOpen(int posCurrent, List <Candle> candles, int index, decimal price)
{
if (NeadToPaintEmu == false)
{
return;
}
if (_points == null)
{
_points = new List <PointElement>();
}
PointElement point = _points.Find(element => element.TimePoint == candles[index].TimeStart);
if (point != null)
{
return;
}
point = new PointElement(candles[index].TimeStart.ToString(), "Prime");
point.TimePoint = candles[index].TimeStart;
point.Style = MarkerStyle.Cross;
point.Y = price;
point.Size = 15;
if (posCurrent == 1)
{
point.Color = Color.DarkSeaGreen;
}
else
{
point.Color = Color.DarkOrchid;
}
_points.Add(point);
_tab.SetChartElement(point);
}
public void AddElement(Vector3 offset)
{
var elem = new PointElement();
elem.Position = Host.Placement.Location + offset;
Elements.Add(elem);
}
/// <summary>
/// Handler class which handles with point elements
/// </summary>
/// <param name="element"></param>
/// <param name="hOperator">Handler operator</param>
/// <param name="point">Point element to be handled</param>
public PointHandler(ShapeElement element, HandlerOperator hOperator,
PointElement point) : base(element, hOperator)
{
this.FillColor = Color.BlueViolet;
this.linkedPoint = point;
this.element = element;
this.RePosition(element);
}
/// <summary>
/// Handler class which handles with adding new point operation
/// </summary>
/// <param name="element">Current element</param>
/// <param name="hndlOperator">Handler Operator</param>
/// <param name="point">New point</param>
/// <param name="index">index of the handler </param>
public NewPointHandler(ShapeElement element, HandlerOperator hndlOperator,
PointElement point, int index) : base(element, hndlOperator)
{
this.element = element;
Index = index;
this.FillColor = Color.YellowGreen;
this.linkedPoint = point;
this.RePosition(element);
}
public override void Check(Ship ship)
{
int tdiff = Environment.TickCount - Owner.LastTick;
if (Owner.state == 0)
{
if (tdiff > 1000)
{
UpdateMovment(tdiff, ship);
int speed = (int)ship.Status.WalkingSpeed;
double distance = ComputeDistance(ship);
if (distance < speed)
{
int t_add = (int)((distance / (double)speed) * 1000);
ship.Yaw = this.structure.rotation;
ship.Position = this.structure.point;
Owner.LastTick = Environment.TickCount + t_add;
Owner.NextPoint(ship);
Owner.state = 1;
}
else
{
Owner.LastTick = Environment.TickCount;
}
}
}
else
{
if (tdiff > 0)
{
UpdateMovment(tdiff, ship);
Regiontree.UpdateRegion(ship, false);
int numberofpoints = 0;
for (int i = Owner.point; i < Owner.Elements.Count; i++)
{
if (Owner.Elements[i] is PointElement)
{
numberofpoints++;
}
else
{
break;
}
}
Owner.state = 0;
if (numberofpoints > 1)
{
WaypointStructure current = new WaypointStructure(ship.Position, ship.Yaw);
PointElement A = Owner.Elements[Owner.point + 0] as PointElement;
PointElement B = Owner.Elements[Owner.point + 1] as PointElement;
ship.WideMovement(current, A.structure, B.structure);
}
}
}
}
public void LoggingSubjectNameAndGenderTest()
{
var log = new StringLog();
Random rng = new Random();
var subject0 = new PointElement("Susan");
subject0.Data.Add(new ElementGender(Base.Gender.Feminine));
var subject1 = new PointElement("Bob");
subject1.Data.Add(new ElementGender(Base.Gender.Masculine));
log.WriteMarkup("{SUBJECT[0|Name]} is {GENDER[0|genderless|male|female]}. {SUBJECT[1|Name]} is {GENDER[1|genderless|male|female]}.", rng, subject0, subject1);
Assert.AreEqual("Susan is female. Bob is male.", log.ToString());
}
/// <summary>
/// Sets up handlers for polygon handler
/// </summary>
/// <param name="polygon">Polygon to be handled</param>
public void Setup(Polygon polygon)
{
if (this.canRotate)
{
this.handlers.Add(new RotationHandler(this, HandlerOperator.Rotation));
}
PointElement pointElement = null;
int counter = 0;
int minx = 0;
int miny = 0;
int maxx = 0;
int maxy = 0;
foreach (PointElement point in polygon.Points)
{
counter++;
this.handlers.Add(new PointHandler(this, HandlerOperator.Polygon, point));
if (pointElement != null)
{
minx = Math.Min(point.X, pointElement.X);
miny = Math.Min(point.Y, pointElement.Y);
maxx = Math.Max(point.X, pointElement.X);
maxy = Math.Max(point.Y, pointElement.Y);
PointElement newPoint = new PointElement(minx + (int)((maxx - minx) / 2),
miny + (int)((maxy - miny) / 2));
this.handlers.Add(new NewPointHandler(this, HandlerOperator.NewPoint,
newPoint, counter));
}
pointElement = point;
}
if (counter > 0)
{
PointElement newPoint = new PointElement(pointElement.X + 7, pointElement.Y + 7);
this.handlers.Add(new NewPointHandler(this, HandlerOperator.NewPoint,
newPoint, counter + 1));
}
this.handlers.Add(new RedimensionHandler(this, HandlerOperator.RedimSouthEast));
this.handlers.Add(new RedimensionHandler(this, HandlerOperator.RedimSouth));
this.handlers.Add(new RedimensionHandler(this, HandlerOperator.RedimEast));
this.handlers.Add(new RedimensionHandler(this, HandlerOperator.RedimWest));
this.handlers.Add(new RedimensionHandler(this, HandlerOperator.RedimSouthWest));
this.handlers.Add(new RedimensionHandler(this, HandlerOperator.RedimNorthWest));
this.handlers.Add(new RedimensionHandler(this, HandlerOperator.RedimNorth));
this.handlers.Add(new RedimensionHandler(this, HandlerOperator.RedimNorthEast));
}
/// <summary>
/// Adds new point element in polygon
/// </summary>
public void AddPoint()
{
PolygonHandlerCollection phCol = (this.handlerCol as PolygonHandlerCollection);
if (phCol != null)
{
PointElement point = phCol.GetNewPoint();
int index = phCol.GetNewPointIndex();
if (index > 0)
{
(this.selectedElement as Polygon).points.Insert(index - 1, point);
this.handlerCol = new PolygonHandlerCollection(this.selectedElement);
}
}
}
private static void AddMilestone(GanttView gantt, Element parent, DateTime date, DateTime?basePlanDate, string id, string tag)
{
string type = "Milestone";
gantt.CreatePointElement(parent, date, id, type, tag);
if (basePlanDate != null && basePlanDate.Value != date)
{
string direction = basePlanDate.Value > date ? "Right" : "Left";
PointElement small = gantt.CreatePointElement(parent, date, null, type, "BasePlanSmall");
small.AddAttribute("direction", direction);
PointElement large = gantt.CreatePointElement(parent, basePlanDate.Value, null, type, "BasePlanLarge");
large.AddAttribute("direction", direction);
}
}
public static void LogScriptTest()
{
var log = new StringLog();
Random rng = new Random();
log.WriteMarkup("This is a <B>Test</B>, which could read {RANDOM[option one|option two|flibble]}!", rng);
var subject0 = new PointElement("Susan");
subject0.Data.Add(new ElementGender(Base.Gender.Feminine));
var subject1 = new PointElement("Bob");
subject1.Data.Add(new ElementGender(Base.Gender.Masculine));
log.WriteLine();
log.WriteMarkup("{SUBJECT[0|Name]} is {GENDER[0|genderless|male|female]}. {SUBJECT[1|Name]} is {GENDER[1|genderless|male|female]}.", rng, subject0, subject1);
Core.Print(log.ToString());
}
private static void AddTrendPoints(WidgetBase chart)
{
var point = new PointElement
{
StartValue = 79,
DisplayValue = "Previous",
Color = "#666666".FromHtml(),
Thickness = 2,
Dashed = true,
DashLen = 3,
DashGap = 3,
UseMarker = true,
MarkerColor = "#F1F1F1".FromHtml(),
MarkerBorderColor = "#666666".FromHtml(),
MarkerRadius = 7
};
chart.TrendPoints.Add(point);
}
/// <summary>
/// Removes existing NewPointHandlers and creates a new NewPointHandler
/// for each point in pointset
/// </summary>
/// <param name="pointSet">Set of point</param>
public void ReCreateCreationHandlers(Polygon pointSet)
{
for (int i = 0; i < this.handlers.Count; i++)
{
if (this.handlers[i] is NewPointHandler)
{
handlers.RemoveAt(i--);
}
}
PointElement pointElement = null;
int counter = 0;
int minx = 0;
int miny = 0;
int maxx = 0;
int maxy = 0;
foreach (PointElement point in pointSet.points)
{
counter++;
this.handlers.Add(new PointHandler(this, HandlerOperator.Polygon, point));
if (pointElement != null)
{
minx = Math.Min(point.X, pointElement.X);
miny = Math.Min(point.Y, pointElement.Y);
maxx = Math.Max(point.X, pointElement.X);
maxy = Math.Max(point.Y, pointElement.Y);
PointElement newPoint = new PointElement(minx + (int)((maxx - minx) / 2),
miny + (int)((maxy - miny) / 2));
this.handlers.Add(new NewPointHandler(this, HandlerOperator.NewPoint,
newPoint, counter));
}
pointElement = point;
}
if (counter > 0)
{
PointElement newPoint = new PointElement(pointElement.X + 7, pointElement.Y + 7);
this.handlers.Add(new NewPointHandler(this, HandlerOperator.NewPoint,
newPoint, counter + 1));
}
}
private static unsafe InputAccess GetInputAccess(PointElementName name, List <PointElement> elements, byte *data,
int stride)
{
foreach (var element in elements)
{
if (element.Name == name)
{
if (element.Type == PointElementType.Float || element.Type == PointElementType.Double)
{
var elementSize = PointElement.GetSize(element.Type);
return(new InputAccess()
{
Size = elementSize, Stride = stride, Data = data + element.Offset
});
}
else
{
throw new Exception($"Point Cloud {name} field has unsupported type {element.Type}");
}
}
}
throw new Exception($"Point Cloud does not have {name} field");
}
public void PaintPoint(PointElement point)
{
throw new NotImplementedException();
}
public static Path FromFile(string filename, Ship ship)
{
ushort speed = (ushort)ship.Status.WalkingSpeed;
float lastx = ship.Position.x;
float lasty = ship.Position.y;
float lastz = ship.Position.z;
Rotator lastyaw = ship.Yaw;
Path path = new Path();
using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
using (XmlTextReader reader = new XmlTextReader(fs))
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.Name.ToUpperInvariant())
{
case "POINT":
lastx = float.Parse(reader["x"], CultureInfo.InvariantCulture);
lasty = float.Parse(reader["y"], CultureInfo.InvariantCulture);
lastz = float.Parse(reader["z"], CultureInfo.InvariantCulture);
lastyaw = int.Parse(reader["yaw"], CultureInfo.InvariantCulture);
PointElement p = new PointElement(path,
lastx, lasty, lastz, lastyaw);
break;
case "RESETPOSITION":
lastx = float.Parse(reader["x"], CultureInfo.InvariantCulture);
lasty = float.Parse(reader["y"], CultureInfo.InvariantCulture);
lastz = float.Parse(reader["z"], CultureInfo.InvariantCulture);
lastyaw = int.Parse(reader["yaw"], CultureInfo.InvariantCulture);
ResetElement r = new ResetElement(path,
lastx, lasty, lastz, lastyaw);
break;
case "SET":
speed = ushort.Parse(reader["speed"], CultureInfo.InvariantCulture);
SetElement s = new SetElement(path, speed);
break;
case "SHIPYARD":
ShipYard y = new ShipYard(path,
new Point(lastx, lasty, lastz), lastyaw,
new Point(
float.Parse(reader["x"], CultureInfo.InvariantCulture),
float.Parse(reader["y"], CultureInfo.InvariantCulture),
float.Parse(reader["z"], CultureInfo.InvariantCulture)),
byte.Parse(reader["to"], CultureInfo.InvariantCulture),
uint.Parse(reader["shiptime"], CultureInfo.InvariantCulture),
uint.Parse(reader["docktime"], CultureInfo.InvariantCulture));
break;
case "START":
ship.Position = new Point(lastx, lasty, lastz);
ship.Yaw = ship.Yaw;
path.resetpoint = path.Elements.Count;
ship.Status.WalkingSpeed = speed;
break;
}
break;
}
}
}
return path;
}
private DefaultHeaderData ReadHeader()
{
var result = new DefaultHeaderData();
using (var file = MemoryMappedFile.CreateFromFile(FilePath, FileMode.Open))
{
int elementOffset = 0;
using (var view = file.CreateViewStream(0, 4096, MemoryMappedFileAccess.Read))
{
var buffer = new byte[4096];
int length = view.Read(buffer, 0, buffer.Length);
using (var stream = new MemoryStream(buffer, 0, length, false))
{
var byteLine = new byte[128];
bool first = true;
while (true)
{
int byteCount = stream.Read(byteLine, 0, byteLine.Length);
int index = -1;
for (int i = 0; i < byteCount; i++)
{
if (byteLine[i] == '\n' || byteLine[i] == '\r')
{
index = i;
break;
}
}
if (index == -1)
{
throw new Exception("Bad PLY file");
}
var line = Encoding.ASCII.GetString(byteLine, 0, index);
byte next = byteLine[index + 1];
stream.Position -= byteLine.Length - (index + (next == '\r' || next == '\n' ? 2 : 1));
if (first && line != "ply")
{
throw new Exception("Bad PLY file format");
}
first = false;
if (line.StartsWith("format"))
{
var format = line.Split(new[] { ' ' });
if (format[1] != "binary_little_endian" || format[2] != "1.0")
{
throw new Exception($"Unsupported PLY format: {line}");
}
}
else if (line.StartsWith("property"))
{
var props = line.Split(new[] { ' ' }, 3);
if (props[1] != "list")
{
PointElementType?type = null;
PointElementName?name = null;
if (props[1] == "uint8")
{
type = PointElementType.Byte;
}
if (props[1] == "float32")
{
type = PointElementType.Float;
}
if (props[1] == "float64")
{
type = PointElementType.Double;
}
if (props[1] == "uchar")
{
type = PointElementType.Byte;
}
if (props[1] == "float")
{
type = PointElementType.Float;
}
if (props[1] == "double")
{
type = PointElementType.Double;
}
if (props[2] == "x")
{
name = PointElementName.X;
}
if (props[2] == "y")
{
name = PointElementName.Y;
}
if (props[2] == "z")
{
name = PointElementName.Z;
}
if (props[2] == "red")
{
name = PointElementName.R;
}
if (props[2] == "green")
{
name = PointElementName.G;
}
if (props[2] == "blue")
{
name = PointElementName.B;
}
if (props[2] == "intensity")
{
name = PointElementName.I;
}
if (props[2] == "scalar_intensity")
{
name = PointElementName.I;
}
if (!type.HasValue)
{
throw new Exception($"PLY file has unsupported property type {props[1]}");
}
if (name.HasValue)
{
result.Elements.Add(new PointElement()
{
Type = type.Value, Name = name.Value, Offset = elementOffset
});
}
elementOffset += PointElement.GetSize(type.Value);
}
}
else if (line.StartsWith("element vertex"))
{
var vertex = line.Split(new[] { ' ' }, 3);
result.DataCount = long.Parse(vertex[2]);
}
else if (line.StartsWith("end_header"))
{
break;
}
}
result.DataOffset = stream.Position;
}
}
result.DataStride = elementOffset;
}
return(result);
}
public static Path FromFile(string filename, Ship ship)
{
ushort speed = (ushort)ship.Status.WalkingSpeed;
float lastx = ship.Position.x;
float lasty = ship.Position.y;
float lastz = ship.Position.z;
Rotator lastyaw = ship.Yaw;
Path path = new Path();
using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
using (XmlTextReader reader = new XmlTextReader(fs))
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.Name.ToUpperInvariant())
{
case "POINT":
lastx = float.Parse(reader["x"], CultureInfo.InvariantCulture);
lasty = float.Parse(reader["y"], CultureInfo.InvariantCulture);
lastz = float.Parse(reader["z"], CultureInfo.InvariantCulture);
lastyaw = int.Parse(reader["yaw"], CultureInfo.InvariantCulture);
PointElement p = new PointElement(path,
lastx, lasty, lastz, lastyaw);
break;
case "RESETPOSITION":
lastx = float.Parse(reader["x"], CultureInfo.InvariantCulture);
lasty = float.Parse(reader["y"], CultureInfo.InvariantCulture);
lastz = float.Parse(reader["z"], CultureInfo.InvariantCulture);
lastyaw = int.Parse(reader["yaw"], CultureInfo.InvariantCulture);
ResetElement r = new ResetElement(path,
lastx, lasty, lastz, lastyaw);
break;
case "SET":
speed = ushort.Parse(reader["speed"], CultureInfo.InvariantCulture);
SetElement s = new SetElement(path, speed);
break;
case "SHIPYARD":
ShipYard y = new ShipYard(path,
new Point(lastx, lasty, lastz), lastyaw,
new Point(
float.Parse(reader["x"], CultureInfo.InvariantCulture),
float.Parse(reader["y"], CultureInfo.InvariantCulture),
float.Parse(reader["z"], CultureInfo.InvariantCulture)),
byte.Parse(reader["to"], CultureInfo.InvariantCulture),
uint.Parse(reader["shiptime"], CultureInfo.InvariantCulture),
uint.Parse(reader["docktime"], CultureInfo.InvariantCulture));
break;
case "START":
ship.Position = new Point(lastx, lasty, lastz);
ship.Yaw = ship.Yaw;
path.resetpoint = path.Elements.Count;
ship.Status.WalkingSpeed = speed;
break;
}
break;
}
}
}
return(path);
}
