/// <summary>
/// returns the world postions ceter of provide gridcors
/// </summary>
/// <param name="grid"></param>
/// <returns></returns
/// >
private Vector3 CoordsGridToWorld(GridCoords grid)
{
float x = grid.x * gridSize + gridSize / 2 + gridOffset.x;
float y = grid.y * gridSize + gridSize / 2 + gridOffset.y;
return(new Vector3(x, 0, y));
}
protected virtual void CheckIfInTile()
{
if (_currentDropZone != null)
{
_spriteRenderer.sprite = angleSprite;
return;
}
_isInTile = GridCoords.IsInTile(transform.position, out _currentTile);
if (_isInTile)
{
_spriteRenderer.sprite = upSprite;
if (markerPinnedOnTile != null)
{
markerPinnedOnTile(this);
}
//int sortingOrder = (int)(5000f - (transform.position.y * 32));
//bool overlap = ObjectsManager.instance.ObjectOverlap(this);
//if (overlap)
//{
// sortingOrder += 1;
//}
//SetOrderInLayer(sortingOrder, false);
}
else
{
_spriteRenderer.sprite = angleSprite;
}
}
} // ends the Start() function
/// <summary>
/// This function allows the towers to be spawned when the mouse is clicked.
/// </summary>
void Update()
{
SetHelperToMouse();
if (Input.GetButtonDown("Fire2"))
{
/// <summary>
/// Sets the grid helper to the world coordinates.
/// </summary>
GridCoords grid = CoordsWorldToGrid(gridHelper.position);
if (IsValidGridCoords(grid))
{
/// <summary>
/// Shows whether or not there is a tower in the current space on the grid.
/// </summary>
Tower existingTower = LookupTower(grid);
if (existingTower == null)
{
Tower tower = Instantiate(towerPrefab, gridHelper.position, Quaternion.identity);
towers[grid.x, grid.y] = tower;
}
}
}
} // ends the Update() function
public void Rebuild()
{
_grid = new bool[size, height, size];
for (var x = 0; x < _grid.GetLength(0); x++)
{
for (var t = 0; t < _grid.GetLength(1); t++)
{
for (var y = 0; y < _grid.GetLength(2); y++)
{
if (Random.value * 100 < obstacleFrequency)
{
_grid[x, t, y] = true;
}
}
}
}
var center = Mathf.RoundToInt(size / 2);
_start = new GridCoords(0, 0, 0);
_end = new GridCoords(size - 1, height - 1, size - 1);
if (size > 0 && height > 0)
{
_path = SpacetimePathFinder.FindPath(
_grid, _start, _end, 1, 1, 1
);
}
}
public void UpdateObject(WorldObject obj)
{
if (this.Grids.ContainsKey(obj.Grid.Value)) //Already associated
{
Grid current = this.Grids[obj.Grid.Value];
if (current.Contains(obj)) //Same grid
{
return;
}
if (current.TryRemove(obj))
{
current.SendAll(obj.BuildDestroy());
}
}
GridCoords coords = new GridCoords(obj.Location, obj.Map);
if (this.Grids.ContainsKey(coords.Key))
{
this.Grids[coords.Key].TryAdd(obj);
}
else
{
AddOrGet(obj, true);
}
}
/// <summary>
/// spawns a tower on the grid on right click acording to whatever tower is selcted
/// </summary>
private void SpawnTowerOnRightClick()
{
if (Input.GetButtonDown("Fire2"))
{
GridCoords grid = CoordsWorldToGrid(gridHelper.position);
if (IsValidGridCoords(grid))
{
Tower exstingTower = LookUpTower(grid);
if (exstingTower == null)
{
if (buildDarkTower == true)
{
Tower tower = Instantiate(towerPrefab, gridHelper.position, Quaternion.identity);
towers[grid.x, grid.y] = tower;
}
if (buildLightTower == true)
{
Tower tower = Instantiate(towerPrefabLight, gridHelper.position, Quaternion.identity);
towers[grid.x, grid.y] = tower;
}
if (buildNatrueTower == true)
{
Tower tower = Instantiate(towerPrefabNature, gridHelper.position, Quaternion.identity);
towers[grid.x, grid.y] = tower;
}
}
}
}
}
/// <summary>
/// Method which handles a shot being fired within a Game
/// </summary>
/// <param name="game"></param>
/// <param name="shot"></param>
/// <returns></returns>
public Game FireShot(Game game, GridCoords shot)
{
var indices = ArrayMapper.GetArrayIndicesForCoords(shot);
var target = game.GameGrid.Cells[indices.X, indices.Y];
switch (target.Status)
{
case GridCellStatus.OpenSea:
game = ShotMissed(game, indices);
break;
case GridCellStatus.ShipIntact:
game = ShotLanded(game, indices);
break;
case GridCellStatus.ShotLanded:
AlreadyAttempted(game);
break;
case GridCellStatus.ShotMissed:
AlreadyAttempted(game);
break;
}
;
return(game);
}
private bool ValidateDestination(string dest, out TileCoordinates destCoords)
{
destCoords = new TileCoordinates(0, 0);
bool valid = GridCoords.FromTileNameToTilePosition(dest, out destCoords);
return(valid);
}
/// <summary>
/// checks if towers on vaild cords
/// </summary>
/// <param name="grid"></param>
/// <returns></returns>
private Tower LookUpTower(GridCoords grid)
{
if (!IsValidGridCoords(grid))
{
return(null);
}
return(towers[grid.x, grid.y]);
}
} // ends the LookupTower() function
/// <summary>
/// This function checks to see if the grid coordinates are valid.
/// </summary>
/// <param name="grid">The grid to check.</param>
/// <returns>Whether or not the coordinates are valid.</returns>
private bool IsValidGridCoords(GridCoords grid)
{
if (grid.x < 0) return false;
if (grid.y < 0) return false;
if (grid.x >= towers.GetLength(0)) return false;
if (grid.y >= towers.GetLength(1)) return false;
return true;
} // ends the IsValidGridCoords() function
// Fonction qui essaie d'exécuter la commande à partir de la syntaxe fournie.
// Si la syntaxe est invalide, la commande ne s'exécute pas, et renvoie un message d'erreur au CommandManager.
public override bool TryExecution(string shipName, string coordinatesText, string productCode, out string errorMessage)
{
// Variables locales temporaires
bool success = false;
bool validShip = false;
Ship targetShip = null;
bool coordsInDeployPoint = false;
Vector2 shipGridCoords = Vector2.zero;
errorMessage = "";
//Validation 1 : -Vérifier avec le ShipManager si le vaisseau entré est trouvable.
if (ShipManager.instance != null)
{
validShip = ShipManager.instance.FindShipByCallsign(shipName, out targetShip);
}
// Validation 2 : Vérifier avec deploymanager si les coordonnées du vaisseaux sont dans un point de déploiement.
if (targetShip != null)
{
shipGridCoords = GridCoords.FromWorldToGrid(targetShip.transform.position);
if (DeployManager.instance != null)
{
coordsInDeployPoint = DeployManager.instance.IsInDeployPoint(shipGridCoords);
}
else
{
coordsInDeployPoint = false;
}
}
//Confirmation finale 1 : Le vaisseau est valide?
if (!validShip)
{
success = false;
errorMessage = "Invalid ship name : " + shipName;
}
// Confirmation finale 2 : Les coordonnées sont dans un point de déploiement?
else if (!coordsInDeployPoint)
{
success = false;
errorMessage = "Coordinates are outisde of Deploy Point : " + coordinatesText;
}
// Si tout est valide, exécution de la commande et envoie du bool succès au CommandManager
else
{
success = true;
ExecuteCommand(targetShip);
}
return(success);
}
public override bool TryExecution(string shipName, List <string> route, out string errorMessage)
{
// Variables locales temporaires
bool success = false;
bool validShip = false;
bool validCoords = false;
string coordsError = "";
Ship targetShip = null;
errorMessage = "";
//Validation 1 : -Vérifier avec le ShipManager si le vaisseau entré est trouvable.
if (ShipManager.instance != null)
{
validShip = ShipManager.instance.FindShipByCallsign(shipName, out targetShip);
}
foreach (var pos in route)
{
TileCoordinates coords = default;
validCoords = (GridCoords.FromTileNameToTilePosition(pos, out coords));
if (!validCoords)
{
coordsError = "Position " + pos + " does not exist.";
break;
}
}
//TODO: Confirmation finale 1 : Le vaisseau est valide?
if (!validShip)
{
success = false;
errorMessage = "Invalid ship name : " + shipName;
}
else if (!validCoords)
{
errorMessage = "MOVE syntax error : \n\n" + coordsError;
if (MessageManager.instance != null)
{
MessageManager.instance.GenericMessage(errorMessage, true);
}
success = false;
}
// Si tout est valide, exécution de la commande et envoie du bool succès au CommandManager
else
{
success = true;
ExecuteCommand(targetShip, route);
}
return(success);
}
private void CheckForClients()
{
TileCoordinates currentTile = GridCoords.FromWorldToTilePosition(transform.position);
GridTile tile = GridCoords.CurrentGridInfo.gameGridTiles[currentTile.tileX, currentTile.tileY];
GridTile_Planet planet = tile.GetComponent <GridTile_Planet>();
if (planet != null)
{
CheckForClients(planet);
}
}
public override void PlaceGridObject(Vector2 gridCoordinates)
{
GridCoordinates = gridCoordinates;
ParentTile = GridCoords.FromGridToTile(gridCoordinates);
this.transform.position = GridCoords.FromGridToWorld(gridCoordinates);
if (gridObjectPositionAdded != null)
{
gridObjectPositionAdded(this);
}
}
//****************************************************************************************************
//
//****************************************************************************************************
public void Reset()
{
m_TYPE = WEB_MAP_TYPE.Satellite;
m_size = 512;
m_hres = false;
m_coordGeo = Vector3.zero;
m_coordGrid = new GridCoords(int.MaxValue, int.MaxValue);
}
//****************************************************************************************************
//
//****************************************************************************************************
public void Set(WebMapParams otherParams)
{
m_TYPE = otherParams.m_TYPE;
m_size = otherParams.m_size;
m_hres = otherParams.m_hres;
m_coordGeo = otherParams.m_coordGeo;
m_coordGrid = otherParams.m_coordGrid;
}
public bool IsInDeployTile(TileCoordinates tileCoords)
{
Vector2 worldCoords = GridCoords.FromTilePositionToWorld(tileCoords);
foreach (var deployTile in _allDeployTiles)
{
if (deployTile.IsInTile(worldCoords))
{
return(true);
}
}
return(false);
}
public void Move(Vector2 gridCoords)
{
if (pickupCoroutine != null)
{
StopCoroutine(pickupCoroutine);
pickupCoroutine = null;
}
//When MOVE command is called, it converts gridCoords to WorldCoords and sets isMoving to true
displayedGridCoords = gridCoords;
targetWorldCoords = GridCoords.FromGridToWorld(gridCoords);
isMoving = true;
}
public void GetArrayIndicesForCoords_WhenArgumentsAreValid_ExpectSuccessfulMapping()
{
// Arrange
_gridCoordsArgument = new GridCoords(5, "D");
_arrayIndicesResponse = new Indices(4, 3);
// Act
var result = ArrayMapper.GetArrayIndicesForCoords(_gridCoordsArgument);
// Assert
Assert.AreEqual(this._arrayIndicesResponse.X, result.X);
Assert.AreEqual(this._arrayIndicesResponse.Y, result.Y);
}
/// <summary>
/// Returns a pair of array indices for a given set of Grid Coordinates
/// </summary>
/// <returns></returns>
public static Indices GetArrayIndicesForCoords(GridCoords coords)
{
Condition.Requires(coords).IsNotNull("coords");
Condition.Requires(coords.X).IsGreaterOrEqual(1);
Condition.Requires(coords.Y).IsShorterOrEqual(1);
var x = coords.X - 1;
var y = AlphabetHelper.GetAlphabetPositionOfLetter(coords.Y.ToString()) - 1;
var indices = new Indices(x, y);
return(indices);
}
// Fonction qui permet de vérifier si une coordonnée donnée se trouve dans un point de déploiement
public bool IsInDeployPoint(Vector2 gridCoords)
{
Vector2 worldCoords = GridCoords.FromGridToWorld(gridCoords);
foreach (var deployPoint in _allDeployPoints)
{
if (deployPoint.IsInRadius(worldCoords))
{
return(true);
}
}
return(false);
}
public void GetCoordsForArrayIndices_WhenArgumentsAreValid_ExpectSuccessMapping()
{
// Arrange
_arrayIndicesArgument = new Indices(6, 3);
_gridCoordsResponse = new GridCoords(7, "D");
// Act
var result = ArrayMapper.GetCoordsForArrayIndices(_arrayIndicesArgument);
// Assert
Assert.IsInstanceOfType(result, typeof(GridCoords));
Assert.AreEqual(this._gridCoordsResponse.X, result.X);
Assert.AreEqual(this._gridCoordsResponse.Y, result.Y);
}
private void Awake()
{
if (instance != null && instance != this)
{
Destroy(this.gameObject);
return;
}
else
{
instance = this;
}
_gridCoords = GetComponent <GridCoords>();
_pathFinder = GetComponent <PathFinder>();
}
/// <summary>
/// makes the visual fllow the mouse so u can see where tower spanes
/// </summary>
private void SetHelperToMouse()
{
Ray ray = cam.ScreenPointToRay(Input.mousePosition); // creat a ray from the camera through
if (Physics.Raycast(ray, out RaycastHit hit, 50, objectsThatSupportTowers))
{ //
GridCoords gridPos = CoordsWorldToGrid(hit.point);
bool isVaildPos = IsValidGridCoords(gridPos);
gridHelper.gameObject.SetActive(isVaildPos);
Vector3 worldPos = CoordsGridToWorld(gridPos);
worldPos.y = hit.point.y + +0.01f;
gridHelper.position = worldPos;
// tell new agent to go where we clicked
}
}
public void GetArrayIndicesForCoords_WhenTheXCoordIsInvalid_ExpectArgumentException()
{
// Arrange
_gridCoordsArgument = new GridCoords(-1, "E");
// Act
try
{
var result = ArrayMapper.GetArrayIndicesForCoords(_gridCoordsArgument);
}
catch (Exception ex)
{
// Assert
Assert.IsInstanceOfType(ex, typeof(ArgumentOutOfRangeException));
throw;
}
}
// Vérifier si la souris se trouve sur la grille
private bool MouseIsOverGrid(out Vector3 mousePos)
{
// Convertir position de souris en pixels en une position en WORLD COORDS
Vector3 mousePosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
mousePosition.z = 0f;
mousePos = mousePosition;
// Assigner le texte
_coordsText = GridCoords.FromWorldToGrid(mousePos).ToString();
// Vérifier si la position se trouve dans les bounds de la grille.
if (_currentGridInfo.gameGridWorldBounds.Contains(mousePosition))
{
return(true);
}
return(false);
}
private void SetHelperToMouse()
{
Ray ray = cam.ScreenPointToRay(Input.mousePosition); // create a ray from the camera, throught the mouse position
if (Physics.Raycast(ray, out RaycastHit hit, 50, objectsThatSupportTowers)) // shoot ray into scene, detect hit
{
GridCoords gridPos = CoordsWorldToGrid(hit.point);
bool isValidPos = IsValidGridCoords(gridPos);
gridHelper.gameObject.SetActive(isValidPos);
Vector3 worldPos = CoordsGridToWorld(gridPos);
worldPos.y = hit.point.y + .01f;
gridHelper.position = worldPos;
}
}
//****************************************************************************************************
//
//****************************************************************************************************
public GridCoords GetGridCoordsFromRelativePosition(Vector3 pos)
{
GridCoords coords = new GridCoords();
Vector3 gridLocalPos = (pos + m_virtualPos) - m_TLCorner;
coords.X = ( int )(gridLocalPos.x / m_tilesSize); if (gridLocalPos.x < 0)
{
coords.X += (1 << zoom) - 1;
}
coords.Y = ( int )(-gridLocalPos.z / m_tilesSize); if (gridLocalPos.z > 0)
{
coords.Y += (1 << zoom) - 1;
}
coords.Clamp(1 << zoom, 1 << zoom);
return(coords);
}
protected override void CheckIfInTile()
{
base.CheckIfInTile();
if (_currentDropZone != null)
{
_tileText.enabled = false;
return;
}
if (_isInTile)
{
_tileText.text = GridCoords.GetTileName(_currentTile);
_tileText.enabled = true;
}
else
{
_tileText.enabled = false;
}
}
} // ends the IsValidGridCoords() function
/// <summary>
/// This function sets the grid helper to the mouse and allows it to move with the mouse.
/// </summary>
private void SetHelperToMouse()
{
/// <summary>
/// creates a ray from the camera to the mouse
/// </summary>
Ray ray = cam.ScreenPointToRay(Input.mousePosition); // create a ray from the camera, to the mouse
if (Physics.Raycast(ray, out RaycastHit hit))//, 50, objectsThatSupportTowers))
{
GridCoords gridPos = CoordsWorldToGrid(hit.point);
bool isValidPos = IsValidGridCoords(gridPos);
gridHelper.gameObject.SetActive(isValidPos);
Vector3 worldPos = CoordsGridToWorld(gridPos);
worldPos.y = hit.point.y + .01f;
gridHelper.position = worldPos;
}
} // ends the SetHelperToMouse()
