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; } }