private float AddTableDamage(float dmgAmt, MetaDataNode data, Vector3Int cellPos, Vector2 worldPos, AttackType attackType)
{
data.Damage += GetReducedDamage(cellPos, dmgAmt, attackType);
BasicTile tile = null;
if (data.Damage >= GetMaxDamage(cellPos))
{
//watch out! must not accidentally destroy other objects like player!
tile = tileChangeManager.RemoveTile(cellPos, LayerType.Objects) as BasicTile;
// SoundManager.PlayNetworkedAtPos("TableHit", worldPos, 1f);
//Spawn remains:
if (Random.value < 0.25f)
{
SpawnRods(worldPos);
}
else if (Random.value > 0.75f)
{
SpawnMetal(worldPos);
}
}
return(CalculateAbsorbDamaged(cellPos, attackType, data, tile));
}
protected virtual Tile CreateTile(int row, int column, int position, string @string, int?points) => BasicTile.TryCreate(row, column, position, @string, points, _basicTilesValues) ?? DigramTile.TryCreate(row, column, position, @string, points, _basicTilesValues) ?? PrefixTile.TryCreate(row, column, position, @string, points, _basicTilesValues) ?? SuffixTile.TryCreate(row, column, position, @string, points, _basicTilesValues) ?? EitherOrTile.TryCreate(row, column, position, @string, points, _basicTilesValues) ?? (Tile) new InvalidTile(row, column, position, @string, points, _basicTilesValues);
public override bool AreUnderfloorSame(Matrix4x4 thisTransformMatrix, BasicTile basicTile, Matrix4x4 TransformMatrix)
{
if ((basicTile as PipeTile) != null)
{
var TilePipeTile = (PipeTile)basicTile;
var TheConnection = TilePipeTile.Connections.Copy();
int Offset = PipeFunctions.GetOffsetAngle(TransformMatrix.rotation.eulerAngles.z);
TheConnection.Rotate(Offset);
var thisConnection = Connections.Copy();
int thisOffset = PipeFunctions.GetOffsetAngle(thisTransformMatrix.rotation.eulerAngles.z);
thisConnection.Rotate(thisOffset);
for (int i = 0; i < thisConnection.Directions.Length; i++)
{
if (thisConnection.Directions[i].Bool && TheConnection.Directions[i].Bool)
{
return(true);
}
}
return(false);
}
return(base.AreUnderfloorSame(thisTransformMatrix, basicTile, TransformMatrix));
}
public void Touch(GameObject targetObject, BasicTile targetTile, GameObject source, Screens.Board board)
{
if (targetObject != null)
{
if (targetObject.HasComponents(typeof(Pushable), typeof(Movable)))
{
Pushable pushComponent = targetObject.GetComponent <Pushable>();
var pushDirection = Direction.GetDirection(source.Position, targetObject.Position);
if (!(pushComponent.Direction == Pushable.Directions.Horizontal && (pushDirection == Direction.Down || pushDirection == Direction.Up)) &&
!(pushComponent.Direction == Pushable.Directions.Vertical && (pushDirection == Direction.Left || pushDirection == Direction.Right)) &&
pushComponent.Mode == Pushable.Modes.All || (pushComponent.Mode == Pushable.Modes.PlayerOnly && source.HasComponent <PlayerControlled>()) || (pushComponent.Mode == Pushable.Modes.CreatureOnly && !source.HasComponent <PlayerControlled>())
)
{
targetObject.GetComponent <Movable>().RequestMove(pushDirection, board, targetObject);
}
}
targetObject.SendMessage(new Messages.Touched(source, targetObject, targetTile, board));
}
if (targetTile != null)
{
targetTile.SendMessage(new Messages.Touched(source, targetObject, targetTile, board));
}
}
private float AddFloorDamage(float dmgAmt, MetaDataNode data, Vector3Int cellPos, Vector2 worldPos, AttackType attackType)
{
data.Damage += GetReducedDamage(cellPos, dmgAmt, attackType);
BasicTile tile = null;
if (data.Damage >= 30 && data.Damage < 70)
{
TryScorch(cellPos);
}
else if (data.Damage >= GetMaxDamage(cellPos))
{
tile = tileChangeManager.RemoveTile(cellPos, LayerType.Floors) as BasicTile;
if (Random.value < 0.25f)
{
if (tile is BasicTile basicTile)
{
var toSpawn = basicTile.SpawnOnDeconstruct;
Spawn.ServerPrefab(toSpawn, worldPos, count: basicTile.SpawnAmountOnDeconstruct);
}
}
// SoundManager.PlayNetworkedAtPos("FloorHit", worldPos, 1f);
}
return(CalculateAbsorbDamaged(cellPos, attackType, data, tile));
}
/// <summary>
/// Set a tile in the world using a BasicTile.
/// </summary>
/// <param name="tilePosition">The position to set the tile at.</param>
/// <param name="tile">The BasicTile object to set.</param>
public async Task SetTileAt(Vector3Int tilePosition, BasicTile tile)
{
// Await the operation
SetTileOperation operation = new SetTileOperation(tilePosition, tile, this);
await AddChunkOperation(operation);
}
internal NewNode(int HCost, BasicTile t)
{
GCost = 0;
FCost = 0;
this.HCost = HCost;
tileRef = t;
}
public Touched(GameObject sourceObject, GameObject targetObject, BasicTile targetTile, Screens.Board board)
{
SourceObject = sourceObject;
TargetObject = targetObject;
TargetTile = targetTile;
Board = board;
}
/// <summary>
/// Set a tile at the given position.
/// </summary>
/// <param name="tilePosition">The position at which to set the tile.</param>
/// <param name="tile">The Tile object to set</param>
public void SetTileAt(Vector3Int tilePosition, BasicTile tile)
{
if (!IsValidPosition(tilePosition))
{
Debug.LogError($"Position {tilePosition} is not valid for Chunk at {position}");
return;
}
// If the tile is null, trying to remove the tile
if (tile == null)
{
RemoveTileAt(tilePosition);
return;
}
// Set the new tile in the Chunk's tiles list
Vector3Int localPosition = TileToLocalChunkPosition(tilePosition);
tiles[PositionToIndex(localPosition)] = tile.Id;
// Set the new tile in the Tilemap
Tilemap.SetTile(tilePosition, tile);
// Set the Chunk as Dirty
IsDirty = true;
// Reset the ChunkData for this position
chunkData.ErasePositionProperty(tilePosition);
}
public SetTileOperation(Vector3Int tilePosition, BasicTile tile, World world) : base("set",
world.TileToChunkPosition(tilePosition))
{
TilePosition = tilePosition;
Tile = tile;
TileId = tile.Id;
}
private List <GameObject> getNewNeighbors(GameObject tile)
{
BasicTile currentTileScript = tile.GetComponent(typeof(BasicTile)) as BasicTile;
List <GameObject> newNeighbors = new List <GameObject>();
for (int x = currentTileScript.xLoc - 1; x <= currentTileScript.xLoc + 1; x++)
{
for (int z = currentTileScript.zLoc - 1; z <= currentTileScript.zLoc + 1; z++)
{
if (currentTileScript.xLoc == x && currentTileScript.zLoc == z)
{
continue;
}
BasicTile tilescript = tileArray[x, z].GetComponent(typeof(BasicTile)) as BasicTile;
// Ignore edges(planeLevel 4) and already normalized tiles
if (tilescript.planeLevel != 4 && !tilescript.normalized)
{
newNeighbors.Add(tileArray[x, z]);
tilescript.normalized = true;
}
}
}
return(newNeighbors);
}
public TileMouseDrop(GameObject performer, GameObject usedObject, Intent intent, Vector2Int targetCellPos,
InteractableTiles targetInteractableTiles, BasicTile basicTile, Vector2 targetVector) : base(performer, usedObject, intent)
{
this.targetCellPos = targetCellPos;
this.targetInteractableTiles = targetInteractableTiles;
this.basicTile = basicTile;
this.targetVector = targetVector;
}
public void CloseTowerOptions()
{
towerOptions.SetActive(false);
currentTile.towerHolder.RadiusVisible(false);
currentTile = null;
TurretButtonsVisible(true);
}
// TODO Creature is wearing hardsuit
// Creature is wearing clown shoes
private static void ClownStepAtPos(Vector3 worldPos, BasicTile tile)
{
var WalkingSoundCategory = tile.ClownFootstepSoundCategory;
PlayNetworkedAtPos(Instance.ClownFootsteps[WalkingSoundCategory][RANDOM.Next(Instance.ClownFootsteps[WalkingSoundCategory].Count)],
worldPos, (float)Instance.GetRandomNumber(0.7d, 1.2d),
Global: false, polyphonic: true);
}
// This is the internal version of GetTileAt, it does not work using Operations
public async Task _SetTileAt(Vector3Int tilePosition, BasicTile tile)
{
// Get a chunk at the corresponding Chunk position for the given tile position
Vector3Int chunkPosition = TileToChunkPosition(tilePosition);
Chunk chunk = await GetOrCreateChunk(chunkPosition);
chunk.SetTileAt(tilePosition, tile);
}
public TBAGW.EnemyAIInfo ToEnemy(TBAGW.MapZone mz, List <BasicTile> playerZone)
{
TBAGW.EnemyAIInfo temp = mz.zoneEncounterInfo.enemies.Find(e => e.enemyName.Equals(name, StringComparison.OrdinalIgnoreCase) ||
name.Equals(e.enemyCharBase.CharacterName, StringComparison.OrdinalIgnoreCase) ||
name.Equals(e.enemyCharBase.displayName, StringComparison.OrdinalIgnoreCase));
if (temp == null)
{
return(null);
}
bool bGenerateLocation = true;
Vector2 pos = new Vector2(location.x * 64, location.y * 64);
BasicTile tile = new BasicTile();
if (mz.Contains(pos))
{
tile = GameProcessor.loadedMap.possibleTilesGameZoneForEnemyINITIALIZATION(mz.zoneTiles).Except(playerZone).ToList().Find(t => t.positionGrid == new Vector2(location.x, location.y));
if (tile != default(TBAGW.BasicTile))
{
Console.WriteLine("From LuaScriptBattle, script enemy has correct spawn location!");
bGenerateLocation = false;
//int randomNum = GamePlayUtility.Randomize(0, temp.Count);
//var randomTile = temp[randomNum];
}
}
if (bGenerateLocation)
{
Console.WriteLine("From LuaScriptBattle, script enemy has incorrect spawn location!");
var tiles = GameProcessor.loadedMap.possibleTilesGameZoneForEnemyINITIALIZATION(mz.zoneTiles).Except(playerZone).ToList();
if (tiles.Count < PlayerSaveData.heroParty.Count)
{
return(null);
}
int randomNum = GamePlayUtility.Randomize(0, tiles.Count);
tile = tiles[randomNum];
}
CombatProcessor.encounterEnemies.Add(temp.enemyCharBase);
CombatProcessor.encounterEnemies.Last().spriteGameSize = new Rectangle(((Rectangle)tile.mapPosition).X, ((Rectangle)tile.mapPosition).Y, ((Rectangle)tile.mapPosition).Width, ((Rectangle)tile.mapPosition).Height);
CombatProcessor.encounterEnemies.Last().position = CombatProcessor.encounterEnemies.Last().spriteGameSize.Location.ToVector2();
CombatProcessor.encounterEnemies.Last().rotationIndex = rot % 4;
CombatProcessor.encounterEnemies.Last().UpdatePosition();
//temp.enemyCharBase.spriteGameSize = new Rectangle(((Rectangle)tile.mapPosition).X, ((Rectangle)tile.mapPosition).Y, ((Rectangle)tile.mapPosition).Width, ((Rectangle)tile.mapPosition).Height);
//item.spriteGameSize.Width = 64;
//item.spriteGameSize.Height = 64;
//temp.enemyCharBase.spriteGameSize = new Rectangle(((Rectangle)tile.mapPosition).X, ((Rectangle)tile.mapPosition).Y, ((Rectangle)tile.mapPosition).Width, ((Rectangle)tile.mapPosition).Height);
//temp.enemyCharBase.rotationIndex = rot % 4;
//temp.enemyCharBase.position = temp.enemyCharBase.spriteGameSize.Location.ToVector2();
//GameProcessor.encounterEnemies = enemies;
//CombatProcessor.encounterEnemies.Add(temp.enemyCharBase);
//CombatProcessor.encounterEnemies.Last().spriteGameSize = new Rectangle(((Rectangle)tile.mapPosition).X, ((Rectangle)tile.mapPosition).Y, ((Rectangle)tile.mapPosition).Width, ((Rectangle)tile.mapPosition).Height);
return(null);
}
void ShowCost()
{
foreach (GameObject g in grid)
{
Node n = g.GetComponent <Node>();
BasicTile t = g.GetComponent <BasicTile>();
if (n == finish)
{
/*t.gCost.text = n.gCost.ToString();
* t.fCost.text = n.fCost.ToString();
* t.hCost.text = n.hCost.ToString();*/
continue;
}
if (n.hCost == 0 || !t.walkable)
{
/*if (t.gCost.enabled)
* {
* t.gCost.enabled = false;
* t.hCost.enabled = false;
* t.fCost.enabled = false;
* }
* t.arrow.gameObject.SetActive(false);*/
continue;
} /*else if (n.hCost != 0 && !t.gCost.enabled)
* {
* t.gCost.enabled = true;
* t.hCost.enabled = true;
* t.fCost.enabled = true;
* t.arrow.gameObject.SetActive(true);
* }
*
* t.gCost.text = n.gCost.ToString();
* t.fCost.text = n.fCost.ToString();
* t.hCost.text = n.hCost.ToString();*/
Node next;
next = n.parent;
Vector3 toMove = next.transform.position;
toMove.x += 2f;
toMove.z -= 2f;
t.next = toMove;
t.nextTile = next.GetComponent <BasicTile>();
if (next == null)
{
UnityEngine.Debug.Log("My position is: " + n.x + " " + n.y);
}
/*Vector3 direction = next.transform.position - n.transform.position;
* float angle = Mathf.Atan2(direction.z, direction.x) * Mathf.Rad2Deg;
* t.arrow.localRotation = Quaternion.Euler(0, 0, angle);*/
}
}
public static BasicTile PointToTile(LuaPoint lp)
{
if (CombatProcessor.zoneTiles.Count != 0)
{
BasicTile randomTile = CombatProcessor.zoneTiles.Find(t => t.positionGrid == lp.toVector2());
return(randomTile);
}
return(null);
}
public bool SaveBoard(string name, string description, string folderPath)
{
try
{
//Make filepath
string fullPath = folderPath;
if (!folderPath.EndsWith("/"))
{
fullPath += "/";
}
fullPath += name + ".mwm";
//Save the actual file
Directory.CreateDirectory(folderPath);
using (FileStream stream = new FileStream(fullPath, FileMode.Create))
{
using (BinaryWriter writer = new BinaryWriter(stream))
{
//4bytes; File Version
writer.Write((uint)1);
//string; Level Name
writer.Write(name);
//string; Description
writer.Write(description);
//byte; cols
writer.Write((byte)GetNumberOfColumns());
//byte; rows
writer.Write((byte)GetNumberOfRows());
//4 bytes per tile
for (int c = 0, cols = GetNumberOfColumns(); c < cols; ++c)
{
for (int r = 0, rows = GetNumberOfRows(); r < rows; ++r)
{
BasicTile tile = GetTileOnPos(c, r);
ushort type = TileTypes.GetTileInfo(tile.tag).Number;
byte col = (byte)tile.Colour;
byte other = 100;
//4bytes -> 2byte type; 1bytes color; 1byte other
writer.Write(type);
writer.Write(col);
writer.Write(other);
}
}
//Close the write (automaticly also closes the stream)
writer.Close();
}
}
UnityGrowl.Show("Saved !\nYour level has succesfully been saved.");
return(true);
}
catch
{
UnityGrowl.Show("Save error\nAn error has occured during saving.\nMake sure the map/file is not read-only.", 5);
return(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="performer">performer of the interaction</param>
/// <param name="usedObject">object in hand</param>
/// <param name="intent">intent of the performer</param>
/// <param name="targetCellPos">cell position being targeted on the interactable tiles</param>
/// <param name="targetInteractableTiles">interactable tiles containing the tile being targeted</param>
/// <param name="basicTile">info of the tile being targeted</param>
/// <param name="handSlot">slot being used</param>
/// <param name="targetVector">vector pointing from perform to the targeted position</param>
public TileApply(GameObject performer, GameObject usedObject, Intent intent, Vector2Int targetCellPos,
InteractableTiles targetInteractableTiles, BasicTile basicTile, ItemSlot handSlot, Vector2 targetVector) : base(performer, usedObject, intent)
{
this.targetCellPos = targetCellPos;
this.targetInteractableTiles = targetInteractableTiles;
this.basicTile = basicTile;
this.handSlot = handSlot;
this.targetVector = targetVector;
}
//yeah,This needs to be moved out into its own class
public virtual bool AreUnderfloorSame(Matrix4x4 thisTransformMatrix, BasicTile basicTile, Matrix4x4 TransformMatrix)
{
if (basicTile == this)
{
return(true);
}
return(false);
}
//yeah,This needs to be moved out into its own class
public virtual bool IsTileRepeated(Matrix4x4 thisTransformMatrix, BasicTile basicTile, Matrix4x4 TransformMatrix, MetaDataNode metaDataNode)
{
if (basicTile == this)
{
return(true);
}
return(false);
}
public override bool IsTileRepeated(Matrix4x4 thisTransformMatrix, BasicTile basicTile, Matrix4x4 TransformMatrix, MetaDataNode metaDataNode)
{
var incomingConnection = GetRotatedConnection(this, thisTransformMatrix);
if (CanAddPipe(metaDataNode, incomingConnection) == false)
{
return(true);
}
return(false);
}
public static LuaPoint RandomMapPosition()
{
if (CombatProcessor.zoneTiles.Count != 0)
{
BasicTile randomTile = CombatProcessor.zoneTiles[GamePlayUtility.Randomize(0, CombatProcessor.zoneTiles.Count - 1)];
LuaPoint p = new LuaPoint(randomTile.positionGrid.X, randomTile.positionGrid.Y);
return(p);
}
return(null);
}
/// <summary>
/// Play Footstep at given world position.
/// </summary>
//TODO creature has claws
// Creature is barefoot (with humanlike foot)
private static void BarefootAtPosition(Vector3 worldPos, BasicTile tile, GameObject performer)
{
var WalkingSoundCategory = tile.BarefootWalkingSoundCategory;
PlayNetworkedAtPos(
Instance.BareFootsteps[WalkingSoundCategory][
RANDOM.Next(Instance.BareFootsteps[WalkingSoundCategory].Count)],
worldPos, (float)Instance.GetRandomNumber(0.7d, 1.2d),
Global: false, polyphonic: true, sourceObj: performer);
}
/// <summary>
///
/// </summary>
/// <param name="performer">performer of the interaction</param>
/// <param name="usedObject">object in hand</param>
/// <param name="intent">intent of the performer</param>
/// <param name="targetCellPos">cell position being targeted on the interactable tiles</param>
/// <param name="targetInteractableTiles">interactable tiles containing the tile being targeted</param>
/// <param name="basicTile">info of the tile being targeted</param>
/// <param name="handSlot">slot being used</param>
/// <param name="targetVector">vector pointing from perform to the targeted position</param>
public TileApply(GameObject performer, GameObject usedObject, Intent intent, Vector2Int targetCellPos,
InteractableTiles targetInteractableTiles, BasicTile basicTile, ItemSlot handSlot, Vector2 targetPosition, ApplyType type = ApplyType.HandApply) : base(performer, usedObject, intent)
{
this.targetCellPos = targetCellPos;
this.targetInteractableTiles = targetInteractableTiles;
this.basicTile = basicTile;
this.handSlot = handSlot;
this.targetPosition = targetPosition;
this.applyType = type;
}
public void Sell()
{
GameLogic.Instance.ChangePoints(currentTile.towerHolder.currentItem.priceToSell);
currentTile.towerHolder.RadiusVisible(false);
towerOptions.SetActive(false);
currentTile.RemoveTurret();
currentTile = null;
TurretButtonsVisible(true);
}
public virtual bool IsPassableAt(Vector3Int from, Vector3Int to)
{
if (from == to)
{
return(true);
}
BasicTile tileTo = tilemap.GetTile <BasicTile>(to);
return(TileUtils.IsPassable(tileTo));
}
private void Constrain(Vector2Int coordinates, BasicTile tile)
{
var cell = _cells[coordinates];
cell.PossibleTiles.Remove(tile);
if (cell.PossibleTiles.Count == 1)
{
cell.SetCollapsed();
}
}
public void OpenTowerOptions(BasicTile tile)
{
towerOptions.SetActive(true);
currentTile = tile;
currentTile.towerHolder.RadiusVisible(true);
sellPrice.text = "Sell for " + tile.towerHolder.currentItem.priceToSell.ToString() + "$";
TurretButtonsVisible(false);
SetupButtons(tile.towerHolder.currentItem);
}
public override void SetState(BasicTile.State newState)
{
State previous = state;
base.SetState(newState);
if (newState == State.NONE)
{
if (tile != null) tile.SetActive(false);
}
else
{
if (previous != state)
{
if (tile == null)
{
tile = GameObject.Instantiate<GameObject>(tilePrefab);
tile.transform.parent = parent;
tile.transform.localPosition = new Vector3(x, y);
}
else if (!tile.activeSelf) tile.SetActive(true);
tile.GetComponent<MeshRenderer>().material.color = color;
}
}
}
bool IsDiagonal(BasicTile initial, BasicTile final)
{
int yChange = final.YPosition - initial.YPosition, xChange = final.XPosition - initial.XPosition;
if (yChange != 0 && xChange != 0)
return true;
else
return false;
}
public bool Accessible(BasicTile originTile, bool unitsBlock, int team)
{
bool diagonal = false, aroundCorner = false,
sameHeight = originTile.PresentHeight == presentHeight;
Orientation moveDirection = new MovementPlane.Movement(xPosition - originTile.XPosition, yPosition - originTile.YPosition).orientation;
diagonal = IsDiagonal(originTile, this);
/*if (!diagonal)
{
if (xPosition - originTile.XPosition == 1)
moveDirection = Orientation.Forward;
else if (xPosition - originTile.XPosition == -1)
moveDirection = Orientation.Backward;
else if (yPosition - originTile.YPosition == 1)
moveDirection = Orientation.Left;
else if (yPosition - originTile.YPosition == -1)
moveDirection = Orientation.Right;
else
{
moveDirection = Orientation.Directionless;
print("Caution, weird moves");
}
}*/
if (type == TileKind.Empty || type == TileKind.Impassable)
{
return false;
}
else if (!(originTile.PresentHeight == presentHeight + 1
|| originTile.PresentHeight == presentHeight
|| originTile.PresentHeight == presentHeight - 1))
{
return false;
}
else if (isOccupied && unitsBlock && team != CharacterStepping.team)
{
return false;
}
else if (diagonal)
{
aroundCorner = IsAroundCorner(originTile, this);
if (aroundCorner)
{
return false;
}
else if (!sameHeight || type != TileKind.Flat || originTile.type != TileKind.Flat)
{
return false;
}
else if (unitsBlock)
{
if (moveDirection == Orientation.ForwardRight && grid.Grid(xPosition, yPosition + 1).GetComponent<BasicTile>().IsOccupied && grid.Grid(xPosition - 1, yPosition).GetComponent<BasicTile>().IsOccupied)
{
return false;
}
else if (moveDirection == Orientation.BackwardRight && grid.Grid(xPosition, yPosition + 1).GetComponent<BasicTile>().IsOccupied && grid.Grid(xPosition + 1, yPosition).GetComponent<BasicTile>().IsOccupied)
{
return false;
}
else if (moveDirection == Orientation.BackwardLeft && grid.Grid(xPosition, yPosition - 1).GetComponent<BasicTile>().IsOccupied && grid.Grid(xPosition + 1, yPosition).GetComponent<BasicTile>().IsOccupied)
{
return false;
}
else if (moveDirection == Orientation.ForwardLeft && grid.Grid(xPosition, yPosition - 1).GetComponent<BasicTile>().IsOccupied && grid.Grid(xPosition - 1, yPosition).GetComponent<BasicTile>().IsOccupied)
{
return false;
}
else
{
return true;
}
}
else
{
return true;
}
}
else if (originTile.type == TileKind.Flat && type == TileKind.Flat && sameHeight)
{
return true;
}
else if (originTile.type == TileKind.Stair)
{
if (moveDirection != InvertOrientation(originTile.orientation) && moveDirection != originTile.orientation && originTile.orientation == orientation)
{
if (type == TileKind.Stair
&& sameHeight)
{
return true;
}
}
/*if (!(originTile.orientation == moveDirection || InvertOrientation(originTile.orientation) == moveDirection))
{
return false;
}*/
else if (originTile.orientation == moveDirection)
{
if (type == TileKind.Flat && sameHeight)
{
return true;
}
else if (type == TileKind.Stair
&& orientation == moveDirection && originTile.PresentHeight == presentHeight - 1)
{
return true;
}
else if (type == TileKind.Stair
&& InvertOrientation(orientation) == moveDirection && sameHeight)
{
return true;
}
else
{
return false;
}
}
else if (InvertOrientation(originTile.orientation) == moveDirection)
{
if (type == TileKind.Flat
&& originTile.PresentHeight == presentHeight + 1)
{
return true;
}
else if (type == TileKind.Stair && orientation == InvertOrientation(moveDirection)
&& originTile.PresentHeight == presentHeight + 1)
{
return true;
}
else if (type == TileKind.Stair
&& orientation == moveDirection && sameHeight)
{
return true;
}
else
{
return false;
}
}
else if (moveDirection != InvertOrientation(originTile.orientation) && moveDirection != originTile.orientation)
{
print("Move thing");
if (type == TileKind.Stair
&& sameHeight)
{
return true;
}
}
else
{
return false;
}
}
else if (originTile.type == TileKind.Flat && type == TileKind.Stair)
{
//print(orientation + " " + moveDirection + " " + this);
if (orientation == moveDirection && originTile.PresentHeight == presentHeight - 1)
{
return true;
}
else if (InvertOrientation(orientation) == moveDirection && sameHeight)
{
return true;
}
else
{
return false;
}
}
return false;
}
public bool WithinZMovesFromThis(int z, BasicTile targetTile, bool lineOfSight)
{
int targetX = targetTile.XPosition,
targetY = targetTile.YPosition,
tileX = presentTile.GetComponent<BasicTile>().XPosition,
tileY = presentTile.GetComponent<BasicTile>().YPosition,
deltaX = Mathf.Abs(targetX - tileX),
deltaY = Mathf.Abs(targetY - tileY);
bool isWithinRange = false, isVisible = true;
if (targetX == tileX)
isWithinRange = 2 * deltaY <= z ? true : false;
else if (targetY == tileY)
isWithinRange = 2 * deltaX <= z ? true : false;
else if (deltaY < deltaX)
isWithinRange = deltaY * 2 + (deltaX - deltaY) * 3 <= z ? true : false;
else if (deltaX < deltaY)
isWithinRange = deltaX * 2 + (deltaY - deltaX) * 3 <= z ? true : false;
else if (deltaX == deltaY)
isWithinRange = deltaX * 3 <= z ? true : false;
else
{
print("WEIRD SHIT MAYN");
isWithinRange = false;
}
if (lineOfSight)
{
/*if (z <= 3)
{
isVisible = target.Accessible(presentTile.GetComponent<BasicTile>(), false, team);
}
else
{*/
RaycastHit hitInfo = new RaycastHit();
Ray ray = new Ray(presentTile.transform.position + new Vector3(0f, 1f, 0f), targetTile.gameObject.transform.position - presentTile.transform.position);
Debug.DrawRay(presentTile.transform.position + new Vector3(0f, 1f, 0f), targetTile.gameObject.transform.position - presentTile.transform.position, Color.green, 60f);
int mask = 1 << 8;
bool hit = Physics.Raycast(ray, out hitInfo, 1000f, mask);
if (hit)
{
print(targetTile + " " + hitInfo.collider.gameObject + " " + hit);
isVisible = false;
}
//}
}
if (lineOfSight)
return isWithinRange && isVisible;
else
return isWithinRange;
}
public Movement(BasicTile.Orientation direction)
{
orientation = direction;
xMovement = 0;
yMovement = 0;
switch (direction)
{
case BasicTile.Orientation.Forward:
xMovement = 1;
yMovement = 0;
break;
case BasicTile.Orientation.ForwardRight:
xMovement = 1;
yMovement = -1;
break;
case BasicTile.Orientation.Right:
xMovement = 0;
yMovement = -1;
break;
case BasicTile.Orientation.BackwardRight:
xMovement = -1;
yMovement = -1;
break;
case BasicTile.Orientation.Backward:
xMovement = -1;
yMovement = 0;
break;
case BasicTile.Orientation.BackwardLeft:
xMovement = -1;
yMovement = 1;
break;
case BasicTile.Orientation.Left:
xMovement = 0;
yMovement = 1;
break;
case BasicTile.Orientation.ForwardLeft:
xMovement = 1;
yMovement = 1;
break;
}
}
public void AssignMovementPlaneValues(GameObject presTile, bool isClickable, bool ifAttack, TileObject parent, Movement[] planeRoute = null, int moveCost = 0, int initDamage = 0, BasicTile.Orientation knockbackDir = BasicTile.Orientation.Directionless, int knockBackValue = 0, int aoeDist = 0)
{
presentTile = presTile;
route = planeRoute;
isAttack = ifAttack;
parentUnit = parent;
damage = initDamage;
movementCost = moveCost;
planeEnabled = isClickable;
knockbackDirection = knockbackDir;
knockback = knockBackValue;
aOERange = aoeDist;
//routeLine = gameObject.AddComponent<LineRenderer>();
/*GameObject text = new GameObject();
coordinates = text.AddComponent<TextMesh>();
text.transform.parent = transform;
text.transform.localPosition += new Vector3(0f, 1f, 0f);
text.transform.localRotation = Quaternion.Euler(0f, 90f, 0f);
coordinates.text = "(" + presentTile.GetComponent<BasicTile>().XPosition + ", " + presentTile.GetComponent<BasicTile>().YPosition + ")";
coordinates.fontSize = 1;*/
}
bool IsAroundCorner(BasicTile initial, BasicTile final)
{
if (grid.Grid(initial.XPosition, final.YPosition).GetComponent<BasicTile>().type != TileKind.Flat
||
grid.Grid(final.XPosition, initial.YPosition).GetComponent<BasicTile>().type != TileKind.Flat
||
grid.Grid(initial.XPosition, final.YPosition).GetComponent<BasicTile>().PresentHeight != initial.PresentHeight
||
grid.Grid(final.XPosition, initial.YPosition).GetComponent<BasicTile>().PresentHeight != initial.PresentHeight)
{
return true;
}
else
return false;
}
public IEnumerator Knockback(int knockBackTiles, BasicTile.Orientation direction)
{
MovementPlane.Movement move = new MovementPlane.Movement(direction);
int diagonalFactor;
if (direction == BasicTile.Orientation.Forward || direction == BasicTile.Orientation.Right ||
direction == BasicTile.Orientation.Backward || direction == BasicTile.Orientation.Left)
diagonalFactor = 2;
else
diagonalFactor = 3;
//print("knocking " + this + " " + knockBackTiles + " " + diagonalFactor + " " + move.orientation);
for (int i = 0; i < knockBackTiles / diagonalFactor; i++)
{
float moveProgress = 0f;
int X = presentTile.GetComponent<BasicTile>().XPosition,
Y = presentTile.GetComponent<BasicTile>().YPosition;
print(move.xMovement + " " + move.yMovement + " " + direction);
nextTile = grid.Grid(X + move.xMovement, Y + move.yMovement);
if (!nextTile.GetComponent<BasicTile>().Accessible(presentTile.GetComponent<BasicTile>(), true, team))
{
Damage(knockBackTiles - i * diagonalFactor);
break;
}
while (moveProgress <= 1f)
{
print("knocking " + presentTile + " " + nextTile + " " + moveProgress);
orientation = move.orientation;
transform.localPosition = CalculateMovement(moveProgress);
moveProgress += Time.deltaTime * speed;
yield return null;
}
print("Ending this NOW");
presentTile.GetComponent<BasicTile>().IsOccupied = false;
presentTile.GetComponent<BasicTile>().CharacterStepping = null;
presentTile = nextTile;
presentTile.GetComponent<BasicTile>().IsOccupied = true;
presentTile.GetComponent<BasicTile>().CharacterStepping = this;
nextTile = null;
moveProgress = 0f;
}
isMoving = false;
FinishedMoving();
animatedMesh.Play("Armature|WAIT01.001");
yield break;
}
public void KnockbackFunction(int knockBackTiles, BasicTile.Orientation direction)
{
isMoving = true;
StartCoroutine(Knockback(knockBackTiles, direction));
}
public int this[BasicTile.State state]
{
get
{
if (state == BasicTile.State.PLAYER_0) return player0;
if (state == BasicTile.State.PLAYER_1) return player1;
return none;
}
}
