public static void moveUnit(int moves, coordinates newPosition, coordinates newCoordinates)
{
unitUsed = true;
float width = Convert.ToSingle(Camera.main.orthographicSize * 2.0 * Screen.width / 10);
float height = Convert.ToSingle(Camera.main.orthographicSize * 2.0 * Screen.height / 10);
unit.Card.transform.position = new Vector3(width / 4.1925f + newPosition.x * (width / 15.68f), height / 1.7348f + newPosition.y * (width / 15.68f), 0);
unit.movesRemaining -= moves;
foreach (Unit u in Game_Details_UI.players[MainPresenter.currentPlayer].units.Where(s => s != null))
{
if (u.XLocation == unit.XLocation && u.YLocation == unit.YLocation)
{
u.XLocation = newCoordinates.x;
u.YLocation = newCoordinates.y;
break;
}
}
unit.XLocation = newCoordinates.x;
unit.YLocation = newCoordinates.y;
destroySpots();
if (unit.Name == "Arsonist" && (Math.Abs(newPosition.x) > 2 || newPosition.y > 2))
{
paused = true;
Button[] buttons = MainPresenter.showButtons(String.Format("{0}", MainPresenter.player.name), "Would you like to destroy a building?", "Yes", "No");
List <UnityAction> listeners = new List <UnityAction>();
listeners.Add(delegate { selectBuilding(MainPresenter.player, null, true); });
listeners.Add(delegate { finishAttack(unit, MainPresenter.player); });
MainPresenter.addListeners(buttons.ToList(), listeners);
}
}
public static coordinates convertCoordinates(coordinates c, int playerIndex)
{
//Change current coordinates according to the way board is flipped (which is based on current player from main presenter)
int x;
int y;
switch (playerIndex)
{
case 0:
break;
case 1:
x = c.x;
y = c.y;
c.x = y;
c.y = x;
c.x *= -1;
break;
case 2:
c.y *= -1;
c.x *= -1;
break;
case 3:
x = c.x;
y = c.y;
c.x = y;
c.y = x;
c.y *= -1;
break;
}
return(c);
}
public void Equality()
{
var a = new coordinates(2d, 3d);
var b = new coordinates(2d, 3d);
Assert.AreEqual(a, b);
}
public void InfixInequality()
{
var a = new coordinates(2d, 3d);
var b = new coordinates(3d, 2d);
Assert.True(a != b);
}
public static void makeSpace(coordinates c, selectionType type, int moves, coordinates o, UnityAction method)
{
float width = Convert.ToSingle(Camera.main.orthographicSize * 2.0 * Screen.width / 10);
float height = Convert.ToSingle(Camera.main.orthographicSize * 2.0 * Screen.height / 10);
//When setting selections make sure to add or subtract width / 15.68f and height / 8.8138f
GameObject selection = GameObject.Instantiate(MainPresenter.highlightedSpace, new Vector3(width / 4.1925f + c.x * (width / 15.68f), height / 1.7348f + c.y * (height / 8.8138f), 0), Quaternion.identity, MainPresenter.canvas.transform);
Button button = selection.GetComponent <Button>();
selections.Add(selection);
coordinatesSpotted.Add(c);
if (type == selectionType.move)
{
selection.GetComponent <Image>().color = new Color(0, 1, 0, 0.49f);
button.onClick.AddListener(delegate { moveUnit(moves, c, o); });
if (moves < unit.movesRemaining)
{
checkAdjacentSpaces(c, moves + 1, o, true);
}
}
else if (type == selectionType.attack)
{
selection.GetComponent <Image>().color = new Color(1, 0, 0, 0.49f);
button.onClick.AddListener(delegate { attackUnit(o); });
}
else
{
selection.GetComponent <Image>().color = new Color(1, 1, 0, 0.49f);
button.onClick.AddListener(method);
}
}
public void InfixEquality()
{
var a = new coordinates(2d, 3d);
var b = new coordinates(2d, 3d);
Assert.True(a == b);
}
public coordinates GetLatLngByAddress(string address)
{
try
{
var googleAPIKey = _config.Value.GoogleAPIKey;
var locationService = new GoogleLocationService(apikey: googleAPIKey);
MapPoint point = locationService.GetLatLongFromAddress(address);
if (point == null)
{
return(null);
}
else
{
var response = new coordinates
{
Latitude = point.Latitude,
Longitude = point.Longitude
};
return(response);
}
}
catch (Exception ex)
{
//return string.Format("Google Maps API Error {0}", ex.Message);
return(null);
}
}
public void Inequality()
{
var a = new coordinates(2d, 3d);
var b = new coordinates(3d, 2d);
Assert.AreNotEqual(a, b);
}
public RobotAction Tick(int robotId, RoundConfig config, GameState state)
{
RobotState self = state.robots[robotId];
RobotAction action = new RobotAction();
coordinates T_cd = new coordinates();
coordinates P_cd = new coordinates();
List <string> friendRobots = new List <string>()
{
"Ryzhov", "Haritonov", "Nikandrov", "Sinyavsky", "Frolov", "Orlov", "Kamshilov"
};
AttackToDefence(ref action, self);
if ((self.energy > 0.7 * config.max_energy) && (check == true))
{
T_cd = getNearestRobot(config, state, self);
P_cd = MoveTo(config, self, T_cd);
action.dX = P_cd.x;
action.dY = P_cd.y;
}
else
{
check = false;
T_cd = EnergyPoint(config, state, self);
P_cd = MoveTo(config, self, T_cd);
action.dX = P_cd.x;
action.dY = P_cd.y;
if (self.energy >= 0.999 * config.max_energy)
{
check = true;
}
}
action.targetId = -1;
return(action);
}
public void From_WorldVector_South()
{
var expected = new coordinates(2d, 3d * math.PI_DBL / 2d);
var actual = new coordinates(new double2(0d, -2d));
Assert.AreEqual(expected.r, actual.r, tolerance);
Assert.AreEqual(expected.theta.radians, actual.theta.radians, tolerance);
}
void changeOrientation(coordinates c, int moves)
{
coordinates originalCoordinates = c;
c = convertCoordinates(c, MainPresenter.currentPlayer);
checkAdjacentSpaces(c, moves, originalCoordinates, true);
}
public void ObjectEquality()
{
var a = new coordinates(2d, 3d);
var b = new coordinates(3d, 2d);
Assert.True(a.Equals(a));
Assert.False(a.Equals(b));
}
public static void spotCheck(coordinates c, int moves, coordinates o, bool adjacentAttack)
{
//Check if already in list of spots
foreach (coordinates cs in coordinatesSpotted)
{
if (cs.x == c.x && cs.y == c.y)
{
return;
}
}
//Check if that is the current unit's spot, if so skip it
coordinates unitLocation = new coordinates();
unitLocation.x = (int)unit.XLocation;
unitLocation.y = (int)unit.YLocation;
unitLocation = convertCoordinates(unitLocation, MainPresenter.currentPlayer);
if (c.x == unitLocation.x && c.y == unitLocation.y)
{
return;
}
foreach (coordinates cToAvoid in coordinatesToAttack)
{
coordinates attack = convertCoordinates(cToAvoid, MainPresenter.currentPlayer);
if (attack.x == c.x && attack.y == c.y)
{
//Check if unit is out of attacks and if enemy is adjacent
if (unit.attacksRemaining != 0 && unit.Name == "archer")
{
if (moves == 1)
{
makeSpace(c, selectionType.attack, moves, o, null);
}
else if (moves == 2)
{
makeSpace(c, selectionType.attack, moves, o, null);
}
}
else if (unit.attacksRemaining != 0 && moves == 1)
{
makeSpace(c, selectionType.attack, moves, o, null);
}
return;
}
}
if (unit.attacksRemaining != 0 && unit.Name == "archer" && moves < 2)
{
checkAdjacentSpaces(c, 2, o, false);
}
//Check if unit is out of moves and within their personal movement range (units cannot move into other player's castles)
if (unit.movesRemaining != 0 && (Math.Abs(c.x) <= 2 && c.y <= 2) && adjacentAttack)
{
makeSpace(c, selectionType.move, moves, o, null);
}
}
public void ToWorldVector()
{
var c = new coordinates(2d, math.PI_DBL / 2d);
var expected = new double2(0d, 2d);
var actual = c.ToWorldVector();
Assert.AreEqual(expected.x, actual.x, tolerance);
Assert.AreEqual(expected.y, actual.y, tolerance);
}
public void Hashing()
{
var a_1 = new coordinates(2d, 3d);
var a_2 = new coordinates(2d, 3d);
var b = new coordinates(3d, 2d);
Assert.True(a_1.GetHashCode() == a_2.GetHashCode());
Assert.True(a_1.GetHashCode() != b.GetHashCode());
}
public void From_WorldVector_SouthNegative_WithAngle()
{
var theta = new angle(-math.PI_DBL / 2d);
var expected = new coordinates(2d, theta);
var actual = new coordinates(new double2(0d, -2d));
Assert.AreEqual(expected.r, actual.r, tolerance);
Assert.AreEqual(expected.theta.radians, actual.theta.radians, tolerance);
}
public void ToWorldVector_PolarVector()
{
var c = new coordinates(1d, math.PI_DBL / 2d);
var v_polar = new double2(2d, 3d);
var expected = new double2(-2d, 4d);
var actual = c.ToWorldVector(v_polar);
Assert.AreEqual(expected.x, actual.x, tolerance);
Assert.AreEqual(expected.y, actual.y, tolerance);
}
public void PolarTransform_Vector()
{
var c = new coordinates(1d, math.PI_DBL / 2d);
var v_world = new double2(-2d, 3d);
var expected = new double2(2d, 3d);
var actual = c.PolarTransform(v_world);
Assert.AreEqual(expected.x, actual.x, tolerance);
Assert.AreEqual(expected.y, actual.y, tolerance);
}
public static string isPossible(int a, int b, int c, int d)
{
coordinates goal = new coordinates(c, d);
coordinates point = new coordinates(a, b);
int targettedXDifference = goal.X - point.X;
int targettedYDifference = goal.Y - point.Y;
return("notcompletedd");
}
public void ThetaHat()
{
var c = new coordinates(2d, math.PI_DBL / 2d);
// Increasing theta is in the negative-x direction.
var expected = new double2(-1d, 0d);
var actual = c.ThetaHat();
Assert.AreEqual(expected.x, actual.x, tolerance);
Assert.AreEqual(expected.y, actual.y, tolerance);
}
public void WorldTransform()
{
var c = new coordinates(1d, math.PI_DBL / 2d);
var v_polar = new double2(2d, 3d);
var T_world = c.WorldTransform();
var expected = new double2(-2d, 3d);
var actual = math.mul(T_world, v_polar);
Assert.AreEqual(expected.x, actual.x, tolerance);
Assert.AreEqual(expected.y, actual.y, tolerance);
}
public IntroEffects(Texture2D sparkTexture, Random random)
{
this.particleTexture = sparkTexture;
this.type = random.Next(3);
crd = new coordinates(
TestGame.Width * -0.5f,
TestGame.Width * -0.2f,
TestGame.Width * 2 / 3,
TestGame.Height * 1.4f,
TestGame.Height * 1.2f, 0);
}
public void Formatting()
{
var a_r = 2d;
var a_theta = new angle(3d);
var a = new coordinates(a_r, a_theta.radians);
Assert.AreEqual(
$"coordinates(r: {a_r}, theta: {a_theta})",
a.ToString()
);
}
private void buildOutPutPoint(coordinates column, neuronDirection direction, Int16 layer)
{
coordinates freeLocation = getClosestFreeSpace(column, layer);
matrix.mainMatrix[freeLocation.y].neuronLayer[freeLocation.x][freeLocation.z][freeLocation.t] = new Neurons.NeuronOutput(ref matrix, direction);
freeLocation = getClosestFreeSpace(column, layer);
matrix.mainMatrix[freeLocation.y].neuronLayer[freeLocation.x][freeLocation.z][freeLocation.t] = new Neurons.NeuronPyramidal(ref matrix, direction);
freeLocation = getClosestFreeSpace(column, layer);
matrix.mainMatrix[freeLocation.y].neuronLayer[freeLocation.x][freeLocation.z][freeLocation.t] = new Neurons.NeuronTransfer(ref matrix, direction);
}
private void buildProcessingNeuron(coordinates column, neuronDirection direction, Int16 layer)
{
coordinates freeLocation = getClosestFreeSpace(column, layer);
matrix.mainMatrix[freeLocation.y].neuronLayer[freeLocation.x][freeLocation.z][freeLocation.t] = new Neurons.NeuronExitor(direction, ref matrix);
freeLocation = getClosestFreeSpace(freeLocation, layer);
matrix.mainMatrix[freeLocation.y].neuronLayer[freeLocation.x][freeLocation.z][freeLocation.t] = new Neurons.NeuronInhibitor(direction, ref matrix);
freeLocation = getClosestFreeSpace(freeLocation, layer);
matrix.mainMatrix[freeLocation.y].neuronLayer[freeLocation.x][freeLocation.z][freeLocation.t] = new Neurons.NeuronExitor(direction, ref matrix);
}
public void RelativeToWorldVector()
{
var pos = new coordinates(2d, -math.PI_DBL / 2d);
var v_polar = new double2(-2d, -2d);
var expected = new coordinates(2d, math.PI_DBL);
var actual = pos.Update(v_polar);
Assert.AreEqual(expected.r, actual.r, tolerance);
Assert.AreEqual(
angle.wrap(expected.theta.radians),
angle.wrap(actual.theta.radians),
tolerance
);
}
protected coordinates Cortege(GameState gs, RobotState myself)
{
coordinates point = new coordinates();
foreach (RobotState r in gs.robots)
{
if ((r.isAlive == true) && (r.name == "Ryzhov"))
{
point.x = r.X;
point.y = r.Y;
}
}
return(point);
}
public CoordinateMarker(double mercatorX, double mercatorY, bool changeToDms = false)
{
InitializeComponent();
this._current = coordinates.Geodetic;
this.ChangeToDms = changeToDms;
this.MercatorLocation = new IRI.Ham.SpatialBase.Point(mercatorX, mercatorY);
//this.X = mercatorX;
//this.Y = mercatorY;
}
private void buildInputLayer()
{
List <PointF> inputNeuronLocations = utilities.getInputPoints(y, z, byteSize);
inputBytes = new List <coordinates[]>();
matrix = new Matrix();
matrix.inputPoints = inputNeuronLocations;
matrix.mainMatrix = new Layer[x];
matrix.mainMatrix[inputLayer] = new Layer(y, z, t);
coordinates[] tmpList = new coordinates[byteSize];
Int16 bitcount = 0;
foreach (PointF inploc in inputNeuronLocations)
{
if (matrix.mainMatrix[inputLayer].neuronLayer[(Int16)inploc.X] == null)
{
matrix.mainMatrix[inputLayer].neuronLayer[(Int16)inploc.X] = new Neurons.INeuron[y][];
}
if (matrix.mainMatrix[inputLayer].neuronLayer[(Int16)inploc.X][(Int16)inploc.Y] == null)
{
matrix.mainMatrix[inputLayer].neuronLayer[(Int16)inploc.X][(Int16)inploc.Y] = new Neurons.INeuron[t];
}
if (matrix.mainMatrix[inputLayer].neuronLayer[(Int16)inploc.X][(Int16)inploc.Y][0] == null)
{
matrix.mainMatrix[inputLayer].neuronLayer[(Int16)inploc.X][(Int16)inploc.Y][0] = new Neurons.NeuronInput(ref matrix, neuronDirection.up);
coordinates tmp = new coordinates();
tmp.y = inputLayer;
tmp.x = (Int16)inploc.X;
tmp.z = (Int16)inploc.Y;
tmp.t = 0;
buildInputLayerColumns(tmp);
tmpList[bitcount] = tmp;
if (bitcount == byteSize)
{
inputBytes.Add(tmpList);
bitcount = 0;
tmpList = new coordinates[byteSize];
}
}
bitcount++;
}
}
public coordinates EnergyPoint(RoundConfig config, GameState state, RobotState self)
{
int dt = config.width * config.height;
coordinates cd_point = new coordinates();
foreach (Point p in state.points)
{
if ((p.type == PointType.Energy) && (Distance(self.X, self.Y, p.X, p.Y) < dt))
{
cd_point.x = p.X;
cd_point.y = p.Y;
dt = Distance(self.X, self.Y, p.X, p.Y);
}
}
return(cd_point);
}
public virtual List<ptsPoint> getPoints(coordinates.CurvilinearCoordinates.StationOffsetElevation anSOE)
{
throw new NotImplementedException();
}
public override List<ptsPoint> getPoints(coordinates.CurvilinearCoordinates.StationOffsetElevation anSOE)
{
var returnList = new List<ptsPoint>();
foreach (var segment in allChildSegments)
{
returnList.AddRange(segment.getPoints(anSOE));
}
return returnList;
}
