public void setRotationDirection(AbsoluteDirection rotationDir)
{
//print(unitInfo.baseSpriteName)
if (unitInfo.rotationEnabled)
{
rotationDirection = rotationDir;
if (rotationIndicator)
{
// Rotation Indicator
rotationIndicator.transform.position = this.transform.position;
Vector2 q = TileController.hexCoordToPixelCoord(TileController.absoluteDirectionToObject(rotationDir).getUpDirection(), true).normalized;
rotationIndicator.transform.position = rotationIndicator.transform.position + new Vector3(q.x * 0.3f, q.y * 0.3f, 0.0f);
rotationIndicator.transform.rotation = Quaternion.AngleAxis(Mathf.Atan2(q.x, q.y) * 180.0f / Mathf.PI - 90.0f, new Vector3(0.0f, 0.0f, -1.0f));
}
for (int i = 0; i < unitInfo.movementObjects.Count; i++)
{
unitInfo.movementObjects[i].unitRotated(rotationDir);
}
}
/*else
* {
* throw new UnityException(unitInfo.unitName + " cannot rotate but rotate function was called on it");
* }*/
}
public void Turn(RelativeDirection direction)
{
AbsoluteDirection newDirection;
switch (direction)
{
case RelativeDirection.Right:
newDirection = (AbsoluteDirection)((int)(m_direction + 1) % 4);
break;
case RelativeDirection.Left:
newDirection = (AbsoluteDirection)((int)(m_direction + 3) % 4);
break;
case RelativeDirection.Back:
newDirection = (AbsoluteDirection)((int)(m_direction + 2) % 4);
break;
default:
newDirection = AbsoluteDirection.North;
break;
}
m_direction = newDirection;
NotifyObservers();
}
public void Turn(RelativeDirection paramDirection)
{
if (this.Speed != 0)
{
AbsoluteDirection newDirection;
switch (paramDirection)
{
case RelativeDirection.Right:
newDirection = (AbsoluteDirection)((int)(this.mDirection + 1) % 4);
break;
case RelativeDirection.Left:
newDirection = (AbsoluteDirection)((int)(this.mDirection + 3) % 4);
break;
case RelativeDirection.Back:
newDirection = (AbsoluteDirection)((int)(this.mDirection + 2) % 4);
break;
default:
newDirection = AbsoluteDirection.North;
break;
}
if (this.Speed < 0)
{
newDirection = (AbsoluteDirection)(((int)newDirection + 2) % 4);
}
this.mDirection = newDirection;
}
}
public static RotationDirectionObject absoluteDirectionToObject(AbsoluteDirection rot)
{
switch (rot)
{
case AbsoluteDirection.UP:
return(RotationDirectionObject.UP);
case AbsoluteDirection.UP_RIGHT:
return(RotationDirectionObject.UP_RIGHT);
case AbsoluteDirection.DOWN_RIGHT:
return(RotationDirectionObject.DOWN_RIGHT);
case AbsoluteDirection.DOWN:
return(RotationDirectionObject.DOWN);
case AbsoluteDirection.DOWN_LEFT:
return(RotationDirectionObject.DOWN_LEFT);
case AbsoluteDirection.UP_LEFT:
return(RotationDirectionObject.UP_LEFT);
}
return(null);
}
public void Update(IVehicleControl paramControl)
{
IVehicleControl control = ControlFactory.GetSingleton().VehicleControl;
AbsoluteDirection direction = control.GetDirection();
if (control.GetSpeed() < 0)
{
direction = (AbsoluteDirection)(((int)direction + 2) % 4);
}
string move = string.Empty;
if (control.GetSpeed() != 0)
{
move = control.GetName() + " heading " + direction.ToString() + " at speed: " + control.GetSpeed().ToString();
}
else
{
move = control.GetName() + " is parked facing " + direction.ToString();
}
SetControlPropertyThreadSafe(this.label1, "Text", move);
int maxSpeed = (control.GetSpeed() > 0) ? control.GetMaxSpeed() : control.GetMaxReverseSpeed();
SetControlPropertyThreadSafe(this.pBar, "Value", (maxSpeed == 0) ? 0 : control.GetSpeed() * 100 / maxSpeed);
}
public override void unitRotated(AbsoluteDirection direction)
{
adjustedDirections = new List <Vector2>();
for (int i = 0; i < directions.Count; i++)
{
adjustedDirections.Add(TileController.absoluteDirectionToObject(TileController.relativeToAbsoluteDirection(direction, directions[i])).getUpDirection());
}
}
public override void unitRotated(AbsoluteDirection direction)
{
adjustedJumpPositions = new List <Vector2>();
for (int i = 0; i < jumpPositions.Count; i++)
{
adjustedJumpPositions.Add(TileController.rotate(jumpPositions[i], direction));
}
}
public override void clickedInMode(HexTile clickedTile, UnitScript selectedUnit, int currentTeam)
{
AbsoluteDirection direction = TileController.getDirectionToTile(selectedUnit.getOccupyingHex(), clickedTile);
if (direction == AbsoluteDirection.NONE)
{
return;
}
Vector2 posDir = TileController.absoluteDirectionToRelativePos(direction);
int pos = -1;
for (int i = 0; i < directions.Count; i++)
{
if (posDir == adjustedDirections[i])
{
pos = i;
break;
}
}
if (pos == -1)
{
throw new UnityException("Issue: Charged move click on tile error, selected tile that has been marked but is NOT in any direction");
}
int j = 0;
while (j < ranges[pos] || ranges[pos] == -1)
{
HexTile tile = gameControllerRef.getTileController().getTileFromHexCoord(selectedUnit.getCoords() + posDir * (j + 1));
if (tile)
{
if (tile.getOccupyingUnit())
{
if (tile.getOccupyingUnitTeam() == selectedUnit.getTeam())
{
break;
}
else
{
gameControllerRef.captureUnit(tile.getOccupyingUnit());
}
}
}
else
{
break;
}
j++;
}
gameControllerRef.getTileController().transferUnit(selectedUnit.getOccupyingHex(), clickedTile);
gameControllerRef.switchInteractionState(InteractionStates.SelectingUnitToRotate);
}
public override void unitRotated(AbsoluteDirection direction)
{
adjustedSelectableLocations = new List <Vector2>();
for (int i = 0; i < selectableLocations.Count; i++)
{
adjustedSelectableLocations.Add(TileController.rotate(selectableLocations[i], direction));
}
adjustedRepositionLocations = new List <Vector2>();
for (int i = 0; i < repositionLocations.Count; i++)
{
adjustedRepositionLocations.Add(TileController.rotate(repositionLocations[i], direction));
}
}
public static AbsoluteDirection relativeToAbsoluteDirection(AbsoluteDirection currentDirection, RelativeDirection relativeDirection)
{
int currentDirIdx = (int)currentDirection;
int relativeDirIdx = (int)relativeDirection;
currentDirIdx += relativeDirIdx;
if (currentDirIdx >= 6)
{
currentDirIdx -= 6;
}
return((AbsoluteDirection)(currentDirIdx));
}
public override void unitRotated(AbsoluteDirection direction)
{
adjustedLocations = new List <List <Vector2> >();
for (int i = 0; i < relativeLocations.Count; i++)
{
List <Vector2> relPos = new List <Vector2>();
for (int j = 0; j < relativeLocations[i].Count; j++)
{
relPos.Add(TileController.rotate(relativeLocations[i][j], direction));
}
adjustedLocations.Add(relPos);
}
}
public override void unitRotated(AbsoluteDirection direction)
{
//Adjusting Positions
adjustedPathList = new List <List <PathPos> >();
for (int i = 0; i < pathList.Count; i++)
{
List <PathPos> pathPart = new List <PathPos>();
for (int j = 0; j < pathList[i].Count; j++)
{
pathPart.Add(new PathPos(TileController.rotate(pathList[i][j].pos, direction), pathList[i][j].moveable));
}
adjustedPathList.Add(pathPart);
}
}
public void Update(IVehicleControl paramControl)
{
AbsoluteDirection direction = paramControl.GetDirection();
if (paramControl.GetSpeed() < 0)
{
direction = (AbsoluteDirection)(((int)direction + 2) % 4);
}
string move = string.Empty;
if (paramControl.GetSpeed() != 0)
{
move = paramControl.GetName() + " heading " + direction.ToString() + " at speed: " + paramControl.GetSpeed().ToString();
}
else
{
move = paramControl.GetName() + " is parked facing " + direction.ToString();
}
System.Console.WriteLine(move);
}
public static Vector2 rotate(Vector2 originalRelativeLocation, AbsoluteDirection rotationTo)
{
RotationDirectionObject rotDirObj = absoluteDirectionToObject(rotationTo);
return(rotDirObj.getUpDirection() * originalRelativeLocation.y + rotDirObj.getRightDirection() * originalRelativeLocation.x);
}
public void Turn(RelativeDirection paramDirection)
{
AbsoluteDirection newDirection;
switch(paramDirection)
{
case RelativeDirection.Right:
newDirection = (AbsoluteDirection)((int)(this.mDirection + 1) %4);
break;
case RelativeDirection.Left:
newDirection = (AbsoluteDirection)((int)(this.mDirection + 3) %4);
break;
case RelativeDirection.Back:
newDirection = (AbsoluteDirection)((int)(this.mDirection + 2) %4);
break;
default:
newDirection = AbsoluteDirection.North;
break;
}
this.mDirection = newDirection;
this.NotifyObservers();
}
public abstract void unitRotated(AbsoluteDirection direction);
public static Vector2 absoluteDirectionToRelativePos(AbsoluteDirection rot)
{
return(absoluteDirectionToObject(rot).getUpDirection());
}
