public void CanConvertTo()
{
PointConverter r = new PointConverter();
Assert.IsTrue(r.CanConvertTo(typeof(string)));
Assert.IsFalse(r.CanConvertTo(typeof(Point)));
}
public IEnumerator JumpCoroutine(Unit unit, Point pointDestination)
{
Logcat.I($"Jump Coroutine, initial position {unit.GetPosition()}, final position {pointDestination}");
Vector3 destination = PointConverter.ToVector(pointDestination);
destination.y = unit.Height;
float JumpProgress = 0;
var startPos = unit.transform.position;
while (JumpProgress <= 1.0)
{
JumpProgress += Time.deltaTime / jumpingTime;
var height = Mathf.Sin(Mathf.PI * JumpProgress) * jumpingHeight;
if (height < 0f)
{
height = 0f;
}
unit.transform.position = Vector3.Lerp(startPos, destination, JumpProgress) + Vector3.up * height;
yield return(null);
}
unit.transform.position = destination;
PlacementHelper.Move(unit, pointDestination, new MovementActionValidator());
}
public static Object ParseValue(String value, Type type)
{
PointConverter pC = new PointConverter();
try
{
if (type == typeof(Point))
{
//{X=100,Y=580}
value = value.Replace("{X=", "").Replace("}", "").Replace("Y=", "");
return(new Point(int.Parse(value.Split(',')[0]), int.Parse(value.Split(',')[1])));
}
if (type == typeof(int))
{
return(int.Parse(value));
}
if (type == typeof(bool))
{
return(bool.Parse(value));
}
if (type == typeof(float))
{
return(float.Parse(value));
}
if (type == typeof(double))
{
return(double.Parse(value));
}
}
catch
{
return(null);
}
return(value);
}
[TestCase(-5, -12, 13, -1.96f, TestName = "RandomCoordinates2")] //theta is -Acos(-5/13)
public void TransformCartesianToPolar_ReturnsCorrectValues(float x, float y, float expectedR,
float expectedTheta)
{
var(r, theta) = PointConverter.TransformCartesianToPolar(x, y);
r.Should().BeApproximately(expectedR, (float)Epsilon);
theta.Should().BeApproximately(expectedTheta, (float)Epsilon);
}
public void TransformPolarToCartesian_ReturnsCorrectValues(float r, float theta, float expectedX,
float expectedY)
{
var(x, y) = PointConverter.TransformPolarToCartesian(r, theta);
x.Should().BeApproximately(expectedX, (float)Epsilon);
y.Should().BeApproximately(expectedY, (float)Epsilon);
}
internal static Point ReadAttributePoint(XmlNode node, string attributeName)
{
CheckAttributeExists(node, attributeName);
string text = node.Attributes[attributeName].Value;
return(PointConverter.ConvertFromString(null, System.Globalization.CultureInfo.CurrentCulture, text));
}
public static IEnumerator FallingMovement(Unit unit, Vector3 initialPosition, Vector3 finalPosition, float time)
{
if (unit == null)
{
yield return(null);
}
float elapsedTime = 0;
unit.transform.position = initialPosition;
while (elapsedTime < time)
{
float yPosition = Mathf.Lerp(unit.transform.position.y, finalPosition.y, elapsedTime / time);
if (yPosition < unit.Height)
{
yPosition = unit.Height;
}
unit.transform.position = new Vector3(unit.transform.position.x, yPosition, unit.transform.position.z);
elapsedTime += Time.deltaTime;
yield return(new WaitForEndOfFrame());
}
PlacementHelper.Move(unit, PointConverter.ToPoint(finalPosition), new MovementActionValidator());
yield return(null);
}
private GameObject Instanciate(Point position)
{
Vector3 vector = PointConverter.ToVector(position);
GameObject instance = MonoBehaviour.Instantiate(this.decal, vector, this.decal.transform.rotation);
this.decalInstances?.Add(instance);
return(instance);
}
public override void Execute()
{
CardinalDirections direction = Direction.GetCardinalDirection(this.Unit.GetPosition(), this.Target);
Vector3 point = PointConverter.ToVector(Direction.GetDirection(direction));
Destroy(Instantiate(lasserVFX, this.transform.position, RotationHelper.GetRotation(direction)), delay);
StartCoroutine(Attack(direction, point));
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object valueObject)
{
if (!(valueObject is string value))
{
throw new InvalidOperationException($"Cannot convert from type {valueObject.GetType()}");
}
return(new Wrapper.Point(PointConverter.ConvertFromString(value)));
}
/// <summary>
/// Extends ConvertTo so that methods that return a specific type object given a Type parameter can be
/// used as generic method and casting is not required.
/// <example>
/// pointconverter.ConvertTo<int>(context, culture, value);
/// </example>
/// </summary>
public static T ConvertTo <T>(this PointConverter pointconverter, System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, Object value)
{
if (pointconverter == null)
{
throw new ArgumentNullException("pointconverter");
}
return((T)pointconverter.ConvertTo(context, culture, value, typeof(T)));
}
/// <summary>
/// Extends ConvertTo so that methods that return a specific type object given a Type parameter can be
/// used as generic method and casting is not required.
/// <example>
/// typeconverter.ConvertTo<int>(value);
/// </example>
/// </summary>
public static T ConvertTo <T>(this PointConverter typeconverter, Object value)
{
if (typeconverter == null)
{
throw new ArgumentNullException("typeconverter");
}
return((T)typeconverter.ConvertTo(value, typeof(T)));
}
private void SpawnSplit(CardinalDirections direction, Vector3 otherPosition)
{
Vector3 position = otherPosition + PointConverter.ToVector(Direction.GetDirection(direction));
Quaternion rotation = RotationHelper.GetRotation(direction);
HoloBlastSplit bullet = Instantiate(this.blast, position, rotation);
Logcat.I($"Other position {otherPosition} Splitted bullet {position} rotation {rotation}");
bullet.SetUp(boardController, unitsMap, this.secondAttackDamage, secondKnockback, new Point((int)otherPosition.x, 0, (int)otherPosition.z));
}
public void SetUp()
{
pt = new Point(1, 2);
ptStr = pt.X + CultureInfo.InvariantCulture.TextInfo.ListSeparator + " " + pt.Y;
ptneg = new Point(-2, -3);
ptnegStr = ptneg.X + CultureInfo.InvariantCulture.TextInfo.ListSeparator + " " + ptneg.Y;
ptconv = (PointConverter)TypeDescriptor.GetConverter(pt);
}
public RadialGradientConverter(Boolean repeating)
: base(repeating)
{
var position = PointConverter.StartsWithKeyword(Keywords.At).Option(Point.Center);
var circle = WithOrder(WithAny(Assign(Keywords.Circle, true).Option(true), LengthConverter.Option()), position);
var ellipse = WithOrder(WithAny(Assign(Keywords.Ellipse, false).Option(false), LengthOrPercentConverter.Many(2, 2).Option()), position);
var extents = WithOrder(WithAny(Toggle(Keywords.Circle, Keywords.Ellipse).Option(false), Map.RadialGradientSizeModes.ToConverter()), position);
_converter = circle.Or(ellipse.Or(extents));
}
public override void Execute()
{
CardinalDirections direction = Direction.GetCardinalDirection(this.Unit.GetPosition(), this.Target);
Vector3 point = PointConverter.ToVector(Direction.GetDirection(direction));
this.transform.localPosition += point;
HoloBlast blast = MonoBehaviour.Instantiate(this.bullet, this.gameObject.transform.position, RotationHelper.GetRotation(direction));
blast.SetUp(this.UnitsMap, this.BoardController, this.Unit.GetPosition(), PlayerUtils.HoloBlastSplitDirections(direction), this.firstAttackDamage, this.secondAttackDamage, this.Knockback);
this.transform.localPosition -= point;
}
private void SpawnAttackParticles(Unit unit)
{
if (!this.ValidPositions.Contains(unit.GetPosition()))
{
return;
}
this.Target = unit.GetPosition();
this.FaceTargetDirection(this.Target);
this.SkillActionFX?.Play(PointConverter.ToVector(this.Target));
}
public IEnumerator LerpMovementPath(MonoBehaviour caller, Unit unit, List <Point> path)
{
Logcat.I($"Lerp Movement Path moving unit {unit.GetPosition()}");
path.ForEach(p => Logcat.I($"Lerp Path {p}"));
for (int i = 1; i < path.Count; i++)
{
yield return(LerpMovement(unit, unit.gameObject.transform.position, PointConverter.ToVector(path[i])));
}
yield return(null);
}
private void set_position(int x, int y)
{
PointConverter pc = new PointConverter();
Point pt = new Point();
pt.X = x;
pt.Y = y;
Cursor.Position = pt;
}
static GridUnitExtension()
{
_dipMultiplier = DipHelper.GetDipMultiplier();
_thicknessConverter = new ThicknessConverter();
_cornerRadiusConverter = new CornerRadiusConverter();
_sizeConverter = new SizeConverter();
_pointConverter = new PointConverter();
_rectConverter = new RectConverter();
_gridLengthConverter = new GridLengthConverter();
}
/// <summary>${WP_REST_RectConverter_method_WriteJson_D}</summary>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
Rect rect = (Rect)value;
PointConverter ponitConverter = new PointConverter();
writer.WriteStartObject();
writer.WritePropertyName("rightBottom");
writer.WriteRawValue(JsonConvert.SerializeObject(new Point(rect.Right,rect.Bottom), ponitConverter));
writer.WritePropertyName("leftTop");
writer.WriteRawValue(JsonConvert.SerializeObject(new Point(rect.Left, rect.Top), ponitConverter));
writer.WriteEndObject();
}
public void ConvertTo()
{
PointConverter r = new PointConverter();
Point rect = new Point(1, 2);
object o = r.ConvertTo(rect, typeof(string));
Assert.AreEqual(typeof(string), o.GetType());
Assert.AreEqual("1,2", (string)o);
}
// <SnippetPointConverterExample_csharp>
private Point pointConverterExample()
{
PointConverter pConverter = new PointConverter();
Point pointResult = new Point();
string string1 = "10,20";
// pointResult is equal to (10, 20)
pointResult = (Point)pConverter.ConvertFromString(string1);
return(pointResult);
}
public void ConvertTo()
{
PointConverter r = new PointConverter();
Point rect = new Point(1, 2);
object o = r.ConvertTo(null, CultureInfo.InvariantCulture, rect, typeof(string));
Assert.AreEqual(typeof(string), o.GetType());
Assert.AreEqual("1,2", (string)o);
}
public override void Execute()
{
CardinalDirections direction = Direction.GetCardinalDirection(this.Unit.GetPosition(), this.Target);
Vector3 point = PointConverter.ToVector(Direction.GetDirection(direction));
//// Logcat.I(this, $"Shooting with direction {direction} vector {point}");
this.transform.localPosition += point;
GausCannon gausCannon = MonoBehaviour.Instantiate(this.bullet, this.transform.position, RotationHelper.GetRotation(direction));
gausCannon.SetUp(this.UnitsMap, this.BoardController, this.Unit.GetPosition(), this.Knockback, this.damage);
this.transform.localPosition -= point;
}
private void FlipUnit(Unit unit, Vector3 initialPosition, Vector3 finalPosition)
{
Point initial = PointConverter.ToPoint(initialPosition);
Point final = PointConverter.ToPoint(finalPosition);
initial.y = 0;
final.y = 0;
CardinalDirections direction = Direction.GetCardinalDirection(initial, final);
//// Logcat.I($"Lerp - Flipping Unit. Unit type {unit.GetUnitType()} to {direction}. Initial position {initial}, final position {final}");
unit.FlipUnit(direction);
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(LEFTCLICK))
{
Vector3 vp = Camera.main.ScreenToWorldPoint(Input.mousePosition);
(int x, int y)point = PointConverter.VectorConverter(vp);
Debug.Log(point.x);
Debug.Log(point.y);
}
// var currentBoxCoordinates = GetCurrentPoint();
// bool success = false;
// var boxSpriteRenderer = this.gameObject.GetComponent<SpriteRenderer>();
// if (Input.GetMouseButtonDown(LEFTCLICK))
// {
// Vector3 vp = Camera.main.ScreenToWorldPoint(Input.mousePosition);
// var point = PointConverter.VectorConverter(vp);
// BoxCollider2D col = this.gameObject.GetComponent<BoxCollider2D>();
// if (col.OverlapPoint(vp))
// {
// if (GameState.BoxAvailableForAttack(currentBoxCoordinates))
// {
// success = GameState.AttackTile(point, spriteArray[GameState.currentPlayer]);
// }
// else if (boxSpriteRenderer.sprite == spriteArray[GameState.currentPlayer])
// {
// Debug.Log("asdads" + (boxSpriteRenderer.sprite == spriteArray[GameState.currentPlayer]).ToString());
// success = GameState.FortifyTile(point);
// }
// }
// }
// else if (Input.GetMouseButtonDown(RIGHTCLICK))
// {
// Vector3 vp = Camera.main.ScreenToWorldPoint(Input.mousePosition);
// var point = PointConverter.VectorConverter(vp);
// BoxCollider2D col = this.gameObject.GetComponent<BoxCollider2D>();
// if (col.OverlapPoint(vp))
// {
// if (boxSpriteRenderer.sprite == AvailableMoveBox)
// {
// success = GameState.BlockTile(point);
// if (success)
// boxSpriteRenderer.sprite = BlockedBox;
// }
// }
// }
// if (success)
// {
// GameState.switchTurn(EmptyTileBox);
// }
// UpdateBoxState(currentBoxCoordinates, boxSpriteRenderer);
}
/// <summary>${WP_REST_RectConverter_method_ReadJson_D}</summary>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return new Rect();
}
PointConverter ponitConverter = new PointConverter();
JObject obj = JObject.Load(reader);
Point rightBottom = JsonConvert.DeserializeObject<Point>(obj["rightBottom"].ToString());
Point leftTop = JsonConvert.DeserializeObject<Point>(obj["leftTop"].ToString());
return new Rect(rightBottom, leftTop);
}
public void ConvertFrom()
{
PointConverter r = new PointConverter();
object or = r.ConvertFrom("3, 4");
Assert.AreEqual(typeof(Point), or.GetType());
Assert.AreEqual(new Point(3, 4), or);
or = r.ConvertFrom("-1, -4");
Assert.AreEqual(typeof(Point), or.GetType());
Assert.AreEqual(new Point(-1, -4), or);
}
public void WriteXml(XmlWriter writer)
{
var pointConverter = new PointConverter();
var sizeConverter = new SizeConverter();
writer.WriteStartElement("WindowSettings");
writer.WriteElementString("WindowState", WindowState.ToString());
writer.WriteElementString("Location", pointConverter.ConvertToString(Location));
writer.WriteElementString("Size", sizeConverter.ConvertToString(Size));
writer.WriteElementString("Zoom", Zoom.ToString());
writer.WriteElementString("PositionInText", PositionInText.ToString());
writer.WriteEndElement();
}
public void ReadXml(XmlReader reader)
{
var pointConverter = new PointConverter();
var sizeConverter = new SizeConverter();
reader.Read(); // To skip the starting 'WindowSettings' element
WindowState = (FormWindowState)Enum.Parse(typeof(FormWindowState), reader.ReadElementContentAsString());
Location = (Point)pointConverter.ConvertFromString(reader.ReadElementContentAsString());
Size = (Size)sizeConverter.ConvertFromString(reader.ReadElementContentAsString());
Zoom = reader.ReadElementContentAsInt();
PositionInText = reader.ReadElementContentAsInt();
reader.Read(); // To skip the ending 'WindowSettings' element
}
static void Main(string[] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
MainForm mainForm = new MainForm();
object location = null;
if (args.Length > 0)
{
if (args[0].StartsWith("prev_instance:"))
{
// User clicked "New". Get location of previous
// instance and open new form slightly lower
// and to the right of previous form, unless
// previous form's Window State is maximized.
Point prevLoc = new Point();
try
{
PointConverter pc = new PointConverter();
prevLoc = (Point)(pc.ConvertFromString(args[0].Substring(14)));
}
catch (Exception ex)
{
MessageBox.Show("Error: " + ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//
if (prevLoc.X > 0)
{
// Open new form slightly lower and
// to the right of previous form.
location = new Point(prevLoc.X + 35, prevLoc.Y + 35);
mainForm.StartPosition = FormStartPosition.Manual;
// mainForm.GetSettings(new Point(prevLoc.X + 35, prevLoc.Y + 35));
}
}
else
{
mainForm.GetSettings(null);
// Windows Explorer selected this application
// to open a file. The first argument should
// be the path of the file to open.
mainForm.OpenFile(args[0]);
}
}
mainForm.GetSettings(location);
Application.Run(mainForm);
}
