/// <summary>
/// 删除链接方块
/// </summary>
/// <param name="chunk"></param>
/// <param name="localPosition"></param>
/// <param name="direction"></param>
/// <param name="listLink"></param>
public void DestoryLinkBlock(Chunk chunk, Vector3Int localPosition, BlockDirectionEnum direction, List <Vector3Int> listLink)
{
Vector3Int baseWorldPosition = localPosition + chunk.chunkData.positionForWorld;
//获取数据
BlockBean blockData = chunk.GetBlockData(localPosition);
//延迟一帧执行 等当前方块已经删除了
chunk.chunkComponent.WaitExecuteEndOfFrame(1, () =>
{
if (blockData != null)
{
BlockMetaDoor blockDoorData = FromMetaData <BlockMetaDoor>(blockData.meta);
if (blockDoorData != null)
{
//如果是子级 则不生成
if (blockDoorData.level > 0)
{
baseWorldPosition = blockDoorData.linkBasePosition.GetVector3Int();
//删除基础方块
chunk.SetBlockForWorld(baseWorldPosition, BlockTypeEnum.None);
}
}
}
//如果不是子级 则说明是基础方块 从这里开始删除方块
for (int i = 0; i < listLink.Count; i++)
{
Vector3Int linkPosition = listLink[i];
Vector3Int closeWorldPosition = baseWorldPosition + linkPosition;
chunk.SetBlockForWorld(closeWorldPosition, BlockTypeEnum.None);
}
});
}
/// <summary>
/// 获取方块的方位
/// </summary>
/// <param name="blockDirection"></param>
/// <returns></returns>
public DirectionEnum GetDirection(BlockDirectionEnum blockDirection)
{
int direction = (((int)blockDirection) % 100) / 10;
switch (direction)
{
case 1:
return(DirectionEnum.UP);
case 2:
return(DirectionEnum.Down);
case 3:
return(DirectionEnum.Left);
case 4:
return(DirectionEnum.Right);
case 5:
return(DirectionEnum.Forward);
case 6:
return(DirectionEnum.Back);
}
return(DirectionEnum.None);
}
public override Mesh GetCompleteMeshData(Chunk chunk, Vector3Int localPosition, BlockDirectionEnum blockDirection)
{
int unitTen = MathUtil.GetUnitTen((int)blockDirection);
Vector3[] otherVerts = null;
switch (unitTen)
{
case 1:
case 2:
return(base.GetCompleteMeshData(chunk, localPosition, blockDirection));
case 3:
otherVerts = RotateOtherMeshVerts(-90);
break;
case 4:
otherVerts = RotateOtherMeshVerts(90);
break;
case 5:
otherVerts = RotateOtherMeshVerts(0);
break;
case 6:
otherVerts = RotateOtherMeshVerts(180);
break;
}
Mesh mesh = blockMeshData.GetOtherMesh(0);
mesh.SetVertices(otherVerts);
return(mesh);
}
public override void BuildBlock(Chunk chunk, Vector3Int localPosition)
{
BlockDirectionEnum blockDirection = chunk.chunkData.GetBlockDirection(localPosition.x, localPosition.y, localPosition.z);
int unitTen = MathUtil.GetUnitTen((int)blockDirection);
switch (unitTen)
{
case 1:
case 2:
base.BuildBlock(chunk, localPosition);
break;
case 3:
AddOtherMeshData(chunk, localPosition, -90);
break;
case 4:
AddOtherMeshData(chunk, localPosition, 90);
break;
case 5:
AddOtherMeshData(chunk, localPosition, 0);
break;
case 6:
AddOtherMeshData(chunk, localPosition, 180);
break;
}
}
/// <summary>
/// 添加顶点
/// </summary>
/// <param name="localPosition"></param>
/// <param name="direction"></param>
/// <param name="listVerts"></param>
/// <param name="vertsAdd"></param>
public virtual void AddVerts(Vector3Int localPosition, BlockDirectionEnum direction, List <Vector3> listVerts, Vector3[] vertsAdd)
{
for (int i = 0; i < vertsAdd.Length; i++)
{
listVerts.Add(RotatePosition(direction, localPosition + vertsAdd[i], GetCenterPosition(localPosition)));
}
}
/// <summary>
/// 摧毁方块-设置新方块之前
/// </summary>
public virtual void DestoryBlock(Chunk chunk, Vector3Int localPosition, BlockDirectionEnum direction)
{
DestoryBlockModel(chunk, localPosition);
//取消注册
chunk.UnRegisterEventUpdate(localPosition, TimeUpdateEventTypeEnum.Sec);
chunk.UnRegisterEventUpdate(localPosition, TimeUpdateEventTypeEnum.Min);
}
/// <summary>
/// 检测是否需要构建面
/// </summary>
/// <param name="chunk"></param>
/// <param name="localPosition"></param>
/// <param name="direction"></param>
/// <param name="closeDirection"></param>
/// <returns></returns>
public override bool CheckNeedBuildFace(Chunk chunk, Vector3Int localPosition, BlockDirectionEnum direction, DirectionEnum closeDirection)
{
if (localPosition.y == 0)
{
return(false);
}
GetCloseRotateBlockByDirection(chunk, localPosition, direction, closeDirection, out Block closeBlock, out Chunk closeBlockChunk, out Vector3Int closeLocalPosition);
if (closeBlock == null || closeBlock.blockType == BlockTypeEnum.None)
{
if (closeBlockChunk != null && closeBlockChunk.isInit)
{
//只是空气方块
return(true);
}
else
{
//还没有生成chunk
return(false);
}
}
BlockShapeEnum blockShape = closeBlock.blockInfo.GetBlockShape();
switch (blockShape)
{
case BlockShapeEnum.Cube:
case BlockShapeEnum.CubeLeaves:
return(false);
default:
return(true);
}
}
/// <summary>
/// 获取完整的mesh数据
/// </summary>
/// <returns></returns>
public override Mesh GetCompleteMeshData(Chunk chunk, Vector3Int localPosition, BlockDirectionEnum direction)
{
Mesh mesh = new Mesh();
mesh.vertices = vertsAddLeft
.Concat(vertsAddRight)
.Concat(vertsAddUp)
.Concat(vertsAddDown)
.Concat(vertsAddForward)
.Concat(vertsAddBack)
.ToArray();
mesh.triangles = trisAdd
.Concat(trisAdd.Add(4))
.Concat(trisAdd.Add(8))
.Concat(trisAdd.Add(12))
.Concat(trisAdd.Add(16))
.Concat(trisAdd.Add(20))
.ToArray();
mesh.uv = uvsAddLeft
.Concat(uvsAddRight)
.Concat(uvsAddUp)
.Concat(uvsAddDown)
.Concat(uvsAddForward)
.Concat(uvsAddBack)
.ToArray();
mesh.RecalculateBounds();
mesh.RecalculateNormals();
return(mesh);
}
/// <summary>
/// 获取完整的mesh数据
/// </summary>
/// <returns></returns>
public override Mesh GetCompleteMeshData(Chunk chunk, Vector3Int localPosition, BlockDirectionEnum direction)
{
Mesh mesh = new Mesh();
Vector3[][] arrayVertsData = vertsAddHalfDown;
Vector2[][] arrayUvsData = uvsAddHalfDown;
mesh.vertices = arrayVertsData[0]
.Concat(arrayVertsData[1])
.Concat(arrayVertsData[2])
.Concat(arrayVertsData[3])
.Concat(arrayVertsData[4])
.Concat(arrayVertsData[5])
.ToArray();
mesh.triangles = trisAdd
.Concat(trisAdd.Add(4))
.Concat(trisAdd.Add(8))
.Concat(trisAdd.Add(12))
.Concat(trisAdd.Add(16))
.Concat(trisAdd.Add(20))
.ToArray();
mesh.uv = arrayUvsData[0]
.Concat(arrayUvsData[1])
.Concat(arrayUvsData[2])
.Concat(arrayUvsData[3])
.Concat(arrayUvsData[4])
.Concat(arrayUvsData[5])
.ToArray();
mesh.RecalculateBounds();
mesh.RecalculateNormals();
return(mesh);
}
/// <summary>
/// 旋转点位
/// </summary>
/// <param name="vert"></param>
/// <returns></returns>
public virtual Vector3 RotatePosition(BlockDirectionEnum direction, Vector3 position, Vector3 centerPosition)
{
if (block.blockInfo.rotate_state == 0)
{
//不旋转
return(position);
}
else if (block.blockInfo.rotate_state == 1)
{
//已中心点旋转
Vector3 angles = GetRotateAngles(direction);
//旋转6面
Vector3 rotatePosition = VectorUtil.GetRotatedPosition(centerPosition, position, angles);
return(rotatePosition);
}
else if (block.blockInfo.rotate_state == 2)
{
//已中心点旋转
Vector3 angles = GetRotateAngles(direction);
//旋转6面
Vector3 rotatePosition = VectorUtil.GetRotatedPosition(centerPosition, position, angles);
return(rotatePosition);
}
else if (block.blockInfo.rotate_state == 3)
{
return(position);
}
return(position);
}
public override void DestoryBlock(Chunk chunk, Vector3Int localPosition, BlockDirectionEnum direction)
{
base.DestoryBlock(chunk, localPosition, direction);
DestoryLinkBlock(chunk, localPosition, direction, new List <Vector3Int>()
{
Vector3Int.up
});
}
/// <summary>
/// 获取方块
/// </summary>
public void GetBlockForLocal(int x, int y, int z, out Block block, out BlockDirectionEnum direction)
{
int yIndex = y / chunkWidth;
ChunkSectionData chunkSection = chunkSectionDatas[yIndex];
chunkSection.GetBlock(x, y % chunkWidth, z, out int blockType, out byte blockDirection);
block = BlockHandler.Instance.manager.GetRegisterBlock(blockType);
direction = (BlockDirectionEnum)blockDirection;
}
/// <summary>
/// 互动
/// </summary>
public override void Interactive(GameObject user, Vector3Int worldPosition, BlockDirectionEnum direction)
{
//暂时解除控制
ControlForPlayer controlForPlayer = GameControlHandler.Instance.manager.controlForPlayer;
ControlForCamera controlForCamera = GameControlHandler.Instance.manager.controlForCamera;
controlForPlayer.EnabledControl(false);
controlForCamera.EnabledControl(false);
CameraHandler.Instance.SetCameraAxis(-70, 0);
//获取链接数据
WorldCreateHandler.Instance.manager.GetBlockForWorldPosition(worldPosition, out Block targetBlock, out BlockDirectionEnum targetDirection, out Chunk targetChunk);
BlockBean blockData = targetChunk.GetBlockData(worldPosition - targetChunk.chunkData.positionForWorld);
BlockMetaBed blockMetaData = GetLinkBaseBlockData <BlockMetaBed>(blockData.meta);
//获取身体的旋转角度
float angleY = direction == BlockDirectionEnum.UpForward
? 0 : direction == BlockDirectionEnum.UpBack
? 180 : direction == BlockDirectionEnum.UpLeft
? 90 : direction == BlockDirectionEnum.UpRight
? -90 : 0;
//获取身体偏移位置
float moveX = direction == BlockDirectionEnum.UpLeft
? 0.5f : direction == BlockDirectionEnum.UpRight
? -0.5f : 0;
float moveZ = direction == BlockDirectionEnum.UpForward
? 0.5f : direction == BlockDirectionEnum.UpBack
? -0.5f : 0;
Player player = GameHandler.Instance.manager.player;
player.transform.position = blockMetaData.GetBasePosition() + new Vector3(0.5f, 0.5f, 0.5f);
player.transform.eulerAngles = new Vector3(0, 180, 0);
player.character.transform.localEulerAngles = new Vector3(-90, angleY, 0);
player.character.transform.localPosition = new Vector3(moveX, 0, moveZ);
//设置时间
GameTimeHandler.Instance.SetGameTime(6, 0);
Action callBackForFinish = () =>
{
//恢复控制
controlForPlayer.EnabledControl(true);
controlForCamera.EnabledControl(true);
player.character.transform.localEulerAngles = new Vector3(0, 0, 0);
player.character.transform.localPosition = new Vector3(0, 0, 0);
};
GameTimeHandler.Instance.WaitExecuteSeconds(3, callBackForFinish);
//保存位置
UserDataBean userData = GameDataHandler.Instance.manager.GetUserData();
userData.userPosition.SetWorldType(WorldCreateHandler.Instance.manager.worldType);
userData.userPosition.SetPosition(player.transform.position);
GameDataHandler.Instance.manager.SaveUserData(userData);
}
// Turn changed. If it is now enemy turn, go to turn start coroutine
void onTurnChange(bool playerTurn)
{
currentBlock = BlockDirectionEnum.None;
currentComboDirection = BlockDirectionEnum.None;
if (!playerTurn)
{
StartCoroutine(ExecuteWhenTurnStart());
}
}
/// <summary>
/// 构建面
/// </summary>
/// <param name="blockData"></param>
/// <param name="corner"></param>
/// <param name="up"></param>
/// <param name="right"></param>
/// <param name="reversed"></param>
/// <param name="verts"></param>
/// <param name="uvs"></param>
/// <param name="tris"></param>
public virtual void BuildFace(Chunk chunk, Vector3Int localPosition, Vector3[] vertsAdd, Vector2[] uvsAdd, Color[] colorsAdd, int[] trisAdd)
{
BlockDirectionEnum direction = BlockDirectionEnum.UpForward;
if (block.blockInfo.rotate_state != 0)
{
direction = chunk.chunkData.GetBlockDirection(localPosition.x, localPosition.y, localPosition.z);
}
BaseAddTris(chunk, localPosition, direction, trisAdd);
BaseAddVertsUVsColors(chunk, localPosition, direction, vertsAdd, uvsAdd, colorsAdd);
}
/// <summary>
/// 添加顶点 UV Colors
/// </summary>
/// <param name="localPosition"></param>
/// <param name="direction"></param>
/// <param name="listVerts"></param>
public virtual void AddVertsUVsColors(Vector3Int localPosition, BlockDirectionEnum direction,
List <Vector3> listVerts, List <Vector2> listUVs, List <Color> listColors,
Vector3[] vertsAdd, Vector2[] uvsAdd, Color[] colorsAdd)
{
for (int i = 0; i < vertsAdd.Length; i++)
{
listVerts.Add(RotatePosition(direction, localPosition + vertsAdd[i], GetCenterPosition(localPosition)));
listUVs.Add(uvsAdd[i]);
listColors.Add(colorsAdd[i]);
}
}
/// <summary>
/// 获取方块
/// </summary>
/// <param name="pos">世界坐标</param>
/// <returns></returns>
public void GetBlockForWorldPosition(Vector3Int pos, out Block block, out BlockDirectionEnum direction, out Chunk chunk)
{
chunk = GetChunkForWorldPosition(pos);
if (chunk == null)
{
block = BlockHandler.Instance.manager.GetRegisterBlock(BlockTypeEnum.None);
direction = BlockDirectionEnum.UpForward;
return;
}
chunk.chunkData.GetBlockForLocal(pos - chunk.chunkData.positionForWorld, out block, out direction);
}
/// <summary>
/// 刷新周围方块
/// </summary>
public virtual void RefreshBlockRange(Chunk chunk, Vector3Int localPosition, BlockDirectionEnum direction)
{
Vector3Int worldPosition = localPosition + chunk.chunkData.positionForWorld;
RefreshBlockClose(worldPosition + Vector3Int.up);
RefreshBlockClose(worldPosition + Vector3Int.down);
RefreshBlockClose(worldPosition + Vector3Int.left);
RefreshBlockClose(worldPosition + Vector3Int.right);
RefreshBlockClose(worldPosition + Vector3Int.forward);
RefreshBlockClose(worldPosition + Vector3Int.back);
}
/// <summary>
/// 获取该方块完整的mesh数据
/// </summary>
public virtual Mesh GetCompleteMeshData(Chunk chunk, Vector3Int localPosition, BlockDirectionEnum direction)
{
Mesh mesh = new Mesh();
mesh.vertices = vertsAdd;
mesh.colors = colorsAdd;
mesh.triangles = trisAdd;
mesh.uv = uvsAdd;
mesh.RecalculateBounds();
mesh.RecalculateNormals();
return(mesh);
}
/// <summary>
/// 道具放置
/// </summary>
public override void ItemUse(
Vector3Int targetWorldPosition, BlockDirectionEnum targetBlockDirection, Block targetBlock, Chunk targetChunk,
Vector3Int closeWorldPosition, BlockDirectionEnum closeBlockDirection, Block closeBlock, Chunk closeChunk,
BlockDirectionEnum direction, string metaData)
{
base.ItemUse(targetWorldPosition, targetBlockDirection, targetBlock, targetChunk, closeWorldPosition, closeBlockDirection, closeBlock, closeChunk, direction, metaData);
CreateLinkBlock(closeChunk, closeWorldPosition - closeChunk.chunkData.positionForWorld, new List <Vector3Int>()
{
Vector3Int.up
});
}
public override void DestoryBlock(Chunk chunk, Vector3Int localPosition, BlockDirectionEnum direction)
{
base.DestoryBlock(chunk, localPosition, direction);
DirectionEnum rotateDirection = blockShape.GetRotateDirection(direction, DirectionEnum.Back);
Vector3Int offsetBack = GetCloseOffsetByDirection(rotateDirection);
DestoryLinkBlock(chunk, localPosition, direction, new List <Vector3Int>()
{
offsetBack
});
}
/// <summary>
/// 创建链接的方块
/// </summary>
public virtual void CreateLinkBlock(Chunk chunk, Vector3Int localPosition, List <Vector3Int> listLink)
{
//获取数据
BlockBean blockData = chunk.GetBlockData(localPosition);
if (blockData != null)
{
BlockMetaDoor blockDoorData = FromMetaData <BlockMetaDoor>(blockData.meta);
if (blockDoorData != null)
{
//如果是子级 则不生成
if (blockDoorData.level > 0)
{
return;
}
}
}
//判断是否在指定的link坐标上有其他方块，如果有则生成道具
bool hasBlock = false;
for (int i = 0; i < listLink.Count; i++)
{
Vector3Int linkPosition = listLink[i];
Vector3Int closeWorldPosition = localPosition + chunk.chunkData.positionForWorld + linkPosition;
chunk.GetBlockForWorld(closeWorldPosition, out Block closeBlock, out BlockDirectionEnum closeDirection, out Chunk closeChunk);
if (closeBlock != null && closeBlock.blockType != BlockTypeEnum.None)
{
hasBlock = true;
break;
}
}
if (hasBlock)
{
//创建道具
chunk.SetBlockForLocal(localPosition, BlockTypeEnum.None);
ItemsHandler.Instance.CreateItemCptDrop(this, chunk, localPosition + chunk.chunkData.positionForWorld);
}
else
{
//创建link方块
for (int i = 0; i < listLink.Count; i++)
{
Vector3Int linkPosition = listLink[i];
Vector3Int closeWorldPosition = localPosition + chunk.chunkData.positionForWorld + linkPosition;
BlockMetaDoor blockDoor = new BlockMetaDoor();
blockDoor.level = 1;
blockDoor.linkBasePosition = new Vector3IntBean(localPosition + chunk.chunkData.positionForWorld);
BlockDirectionEnum blockDirection = chunk.chunkData.GetBlockDirection(localPosition.x, localPosition.y, localPosition.z);
chunk.SetBlockForWorld(closeWorldPosition, blockType, blockDirection, ToMetaData(blockDoor));
}
}
}
/// <summary>
/// 互动
/// </summary>
public override void Interactive(GameObject user, Vector3Int worldPosition, BlockDirectionEnum blockDirection)
{
base.Interactive(user, worldPosition, blockDirection);
//只有player才能打开
if (user == null || user.GetComponent <Player>() == null)
{
return;
}
UIGameUserDetails uiGameUserDetails = UIHandler.Instance.OpenUIAndCloseOther <UIGameUserDetails>(UIEnum.GameUserDetails);
uiGameUserDetails.ui_ViewSynthesis.SetDataType(ItemsSynthesisTypeEnum.Base);
uiGameUserDetails.SetSelectType(1);
}
public void ContinueCombo()
{
currentComboDirection = Random.Range(0, 100) > 50 ? BlockDirectionEnum.Left : BlockDirectionEnum.Right;
if (currentComboDirection == BlockDirectionEnum.Left)
{
comboIconLeft.SetActive(true);
}
else
{
comboIconRight.SetActive(true);
}
}
public override Mesh GetCompleteMeshData(Chunk chunk, Vector3Int localPosition, BlockDirectionEnum blockDirection)
{
switch (blockDirection)
{
case BlockDirectionEnum.UpForward:
return(base.GetCompleteMeshData(chunk, localPosition, blockDirection));
case BlockDirectionEnum.DownForward:
Mesh mesh = blockMeshData.GetOtherMesh(0);
return(mesh);
}
return(null);
}
public void StartBlock()
{
currentBlock = Random.Range(0, 100) > 50 ? BlockDirectionEnum.Left : BlockDirectionEnum.Right;
if (currentBlock == BlockDirectionEnum.Left)
{
blockIconLeft.SetActive(true);
}
else
{
blockIconRight.SetActive(true);
}
}
/// <summary>
/// 构建方块的六个面
/// </summary>
/// <param name="chunk"></param>
/// <param name="position"></param>
/// <param name="blockData"></param>
/// <param name="verts"></param>
/// <param name="uvs"></param>
/// <param name="tris"></param>
public override void BuildBlock(Chunk chunk, Vector3Int localPosition)
{
base.BuildBlock(chunk, localPosition);
if (block.blockType != BlockTypeEnum.None)
{
//只有在能旋转的时候才去查询旋转方向
BlockDirectionEnum direction = BlockDirectionEnum.UpForward;
if (block.blockInfo.rotate_state != 0)
{
direction = chunk.chunkData.GetBlockDirection(localPosition.x, localPosition.y, localPosition.z);
}
//Left
if (CheckNeedBuildFace(chunk, localPosition, direction, DirectionEnum.Left))
{
BuildFace(chunk, localPosition, direction, DirectionEnum.Left, vertsAddLeft, uvsAddLeft, colorsAdd, trisAdd);
}
//Right
if (CheckNeedBuildFace(chunk, localPosition, direction, DirectionEnum.Right))
{
BuildFace(chunk, localPosition, direction, DirectionEnum.Right, vertsAddRight, uvsAddRight, colorsAdd, trisAdd);
}
//Bottom
if (CheckNeedBuildFace(chunk, localPosition, direction, DirectionEnum.Down))
{
BuildFace(chunk, localPosition, direction, DirectionEnum.Down, vertsAddDown, uvsAddDown, colorsAdd, trisAdd);
}
//Top
if (CheckNeedBuildFace(chunk, localPosition, direction, DirectionEnum.UP))
{
BuildFace(chunk, localPosition, direction, DirectionEnum.UP, vertsAddUp, uvsAddUp, colorsAdd, trisAdd);
}
//Forward
if (CheckNeedBuildFace(chunk, localPosition, direction, DirectionEnum.Forward))
{
BuildFace(chunk, localPosition, direction, DirectionEnum.Forward, vertsAddForward, uvsAddForward, colorsAdd, trisAdd);
}
//Back
if (CheckNeedBuildFace(chunk, localPosition, direction, DirectionEnum.Back))
{
BuildFace(chunk, localPosition, direction, DirectionEnum.Back, vertsAddBack, uvsAddBack, colorsAdd, trisAdd);
}
}
}
public virtual void BaseAddVertsUVsColors(Chunk chunk, Vector3Int localPosition, BlockDirectionEnum direction, DirectionEnum face,
Vector3[] vertsAdd, Vector2[] uvsAdd, Color[] colorsAdd)
{
AddVertsUVsColors(localPosition, direction,
chunk.chunkMeshData.verts, chunk.chunkMeshData.uvs, chunk.chunkMeshData.colors,
vertsAdd, uvsAdd, colorsAdd);
if (block.blockInfo.collider_state == 1)
{
AddVerts(localPosition, direction, chunk.chunkMeshData.vertsCollider, vertsAdd);
}
if (block.blockInfo.trigger_state == 1)
{
AddVerts(localPosition, direction, chunk.chunkMeshData.vertsTrigger, vertsAdd);
}
}
public override void Interactive(GameObject user, Vector3Int worldPosition, BlockDirectionEnum blockDirection)
{
base.Interactive(user, worldPosition, blockDirection);
//只有player才能打开
if (user == null || user.GetComponent <Player>() == null)
{
return;
}
//打开箱子UI
UIGameBox uiGameBox = UIHandler.Instance.OpenUIAndCloseOther <UIGameBox>(UIEnum.GameBox);
uiGameBox.SetData(worldPosition);
//打开盒子
OpenBox(worldPosition);
}
// Called when user chooses a direction for continuing the combo attack or blocking
// Using block direction enum to compare with monster block, should probably rename enum :P
// ** Convert int to block direction**
public void ComboDirectionalButtonClicked(int direction)
{
uiManager.DisableDirectionalCanvas();
if (battleManager.isPlayerTurn)
{
currentCombo = (BlockDirectionEnum)direction;
battleManager.PlayerComboDirectionChosen();
}
else
{
currentBlock = (BlockDirectionEnum)direction;
battleManager.PlayerBlockDirectionChosen();
}
}
