public void PostMoveData(PieceMoveData moveData)
{
//if(moveData.GetHashCode() != hashCode);
Debug.Log("Post MoveData.");
moveDataQueue.Enqueue(moveData);
onRecievedMoveData.OnNext(moveData);
}
public void TryMove(int _posX, int _posY, string _gameId)
{
PieceMoveData data = new PieceMoveData(_posX, _posY, ChessPieceData.ChessPieceId, _gameId, ChessPieceData.PlayerId);
Network.SendDataToServer("TryMove", data);
ChessPieceManagerRef.DeselectPiece(); //maybe
}
// 現在はColumnSelectorを継承しているが, ColumnSelectorの内部処理は分離してPureC#にした方がいいかも
protected override void OnColumnSelected(IntegerVector2 start, IntegerVector2 via, IntegerVector2 last)
{
IGame game = GameController.Instance.Game;
if (game == null)
{
return;
}
PieceName pieceName = game.Board.GetPiece(start).Name;
PieceMoveData pieceMoveData = new PieceMoveData(string.Empty, start, pieceName, last);
GameController.Instance.ServerDelegate.PostMoveData(pieceMoveData);
}
/// <summary>
/// Getting input feed that input to logic
/// </summary>
private void OnPieceSwap(PieceMoveData pieceMoveData)
{
m_startCountDown = true;
m_hintTimer = 0;
//check if origin and destination inside bound
if (m_boardState.IsOutside(pieceMoveData.Origin) || m_boardState.IsOutside(pieceMoveData.Destination))
{
m_input.Begin();
return;
}
m_hintEnabled = false;
m_logic.Begin();
m_logic.DoSwap(pieceMoveData);
}
public bool GetHint(out PieceMoveData moveData)
{
m_boardState.CopyState(m_boardStateTemp);
//check horizontal swipe
for (int x = 0; x < m_boardStateTemp.BoardSize.x - 1; x++)
{
for (int y = 0; y < m_boardStateTemp.BoardSize.y; y++)
{
Vector2Int positionA = new Vector2Int(x, y);
Vector2Int positionB = new Vector2Int(x + 1, y);
if (GetHint(positionA, positionB, m_boardStateTemp))
{
moveData = new PieceMoveData(-1, positionA, positionB);
return(true);
}
}
}
for (int y = 0; y < m_boardStateTemp.BoardSize.y - 1; y++)
{
for (int x = 0; x < m_boardStateTemp.BoardSize.x; x++)
{
Vector2Int positionA = new Vector2Int(x, x);
Vector2Int positionB = new Vector2Int(x, y + 1);
if (GetHint(positionA, positionB, m_boardStateTemp))
{
moveData = new PieceMoveData(-1, positionA, positionB);
return(true);
}
}
}
moveData = new PieceMoveData();
return(false);
}
public void AddPieceMoveLogs(PieceMoveData moveData)
{
pieceMoveLogs.Add(moveData);
}
void TargetRequestRetransmission(NetworkConnection target, PieceMoveData data)
{
retransmissionCallback?.Invoke(data);
retransmissionCallback = null;
}
void RpcPostMoveData(PieceMoveData moveData)
{
onRecievedMoveData.OnNext(moveData);
}
void CmdPostMoveData(PieceMoveData data)
{
RpcPostMoveData(data);
}
public void PostMoveData(PieceMoveData moveData)
{
CmdPostMoveData(moveData);
}
public void PostMoveData(PieceMoveData moveData)
{
pieceMoveDataBroadcaster.Broadcast(moveData);
}
private IEnumerator UpdateVisuals(Queue <BoardUpdateData> boardUpdateDatas)
{
int numMatches = 0;
int numVisualUpdateTarget = boardUpdateDatas.Count;
int numVisualUpdate = 0;
while (boardUpdateDatas.Count > 0)
{
BoardUpdateData boardUpdateData = boardUpdateDatas.Dequeue();
//do move pieces
if (boardUpdateData.Moves.Count > 0)
{
IPiece[] movedPieces = new IPiece[boardUpdateData.Moves.Count]; //Todo use buffering instead
for (int i = 0; i < boardUpdateData.Moves.Count; i++)
{
PieceMoveData moveData = boardUpdateData.Moves[i];
IPiece movedPiece;
if (moveData.NewPieceID >= 0)
{
movedPiece = m_pieceFactory.CreatePiece(moveData.NewPieceID);
movedPiece.Init(moveData.Origin.x, moveData.Origin.y);
}
else
{
movedPiece = m_visualState[moveData.Origin.x, moveData.Origin.y];
}
movedPiece.Move(moveData.Destination);
movedPieces[i] = movedPiece;
}
//update pieces position
for (int i = 0; i < boardUpdateData.Moves.Count; i++)
{
PieceMoveData moveData = boardUpdateData.Moves[i];
m_visualState[moveData.Destination.x, moveData.Destination.y] = movedPieces[i];
}
yield return(new WaitForSeconds(Constants.PieceFallDuration));
}
//handle matches
numMatches += boardUpdateData.Matches.Length;
numVisualUpdate++;
if (boardUpdateData.Matches.Length > 0)
{
for (int i = 0; i < boardUpdateData.Matches.Length; i++)
{
MatchData matchData = boardUpdateData.Matches[i];
for (int j = 0; j < matchData.Matches.Length; j++)
{
Vector2Int matchPosition = matchData.Matches[j];
IPiece movedPiece = m_visualState[matchPosition.x, matchPosition.y];
movedPiece.StartDisappear();
}
OnVisualMatchEvent.Invoke(matchData);
}
OnVisualStackEndedEvent.Invoke(numMatches, numVisualUpdate, numVisualUpdateTarget);
yield return(new WaitForSeconds(Constants.PieceMatchDuration));
}
else
{
OnVisualStackEndedEvent.Invoke(numMatches, numVisualUpdate, numVisualUpdateTarget);
}
}
m_stateEndEvent.Invoke(this);
OnBoardUpdateCompleted.Invoke();
//visual candy if there's combo
if (numMatches > 1)
{
float multiplier = 1f / m_boardState.BoardSize.magnitude;
for (int x = 0; x < m_boardState.BoardSize.x; x++)
{
for (int y = 0; y < m_boardState.BoardSize.y; y++)
{
m_visualState[x, y].Hint((x + y) * multiplier, .2f);
}
}
}
}
/// <summary>
/// This will also check if swap possible
/// </summary>
public void DoSwap(PieceMoveData pieceMoveData)
{
m_boardState.CopyState(m_boardStateTemp);
Queue <BoardUpdateData> boardUpdateData = new Queue <BoardUpdateData>();
//swap
m_boardStateTemp.State[pieceMoveData.Origin.x, pieceMoveData.Origin.y] = m_boardState.State[pieceMoveData.Destination.x, pieceMoveData.Destination.y];
m_boardStateTemp.State[pieceMoveData.Destination.x, pieceMoveData.Destination.y] = m_boardState.State[pieceMoveData.Origin.x, pieceMoveData.Origin.y];
//
GetAllMatches(m_boardStateTemp, m_currentStateMatchData);
boardUpdateData.Enqueue(new BoardUpdateData(new List <PieceMoveData>()
{
pieceMoveData, pieceMoveData.Inverse
}, CopyMatchData(m_currentStateMatchData))); //move pieces towards move
if (m_currentStateMatchData.Count > 0)
{
//grab lowest position that can be filled for each column
int[] columnLowest = new int[m_boardStateTemp.BoardSize.x];
for (int i = 0; i < m_boardStateTemp.BoardSize.x; i++)
{
columnLowest[i] = m_boardStateTemp.BoardSize.y - 1;
}
while (m_currentStateMatchData.Count > 0)
{
for (int i = 0; i < m_currentStateMatchData.Count; i++)
{
MatchData matchData = m_currentStateMatchData[i];
for (int j = 0; j < matchData.Matches.Length; j++)
{
Vector2Int matchPosition = matchData.Matches[j];
//mark empty space
m_boardStateTemp.State[matchPosition.x, matchPosition.y] = Blank;
//mark column that can be filled
columnLowest[matchPosition.x] = Mathf.Min(columnLowest[matchPosition.x], matchPosition.y);
}
}
//drop all pieces to bottom
List <PieceMoveData> currentPieceDropDatas = new List <PieceMoveData>();
for (int x = 0; x < m_boardStateTemp.BoardSize.x; x++)
{
int lowestColumn = columnLowest[x];
//only do piece adjusting on column that have a match
//move pieces downwards and register matches
for (int y = lowestColumn; y < m_boardStateTemp.BoardSize.y; y++)
{
int value = m_boardStateTemp.State[x, y];
if (value != Blank)
{
m_boardStateTemp.State[x, lowestColumn] = value;
currentPieceDropDatas.Add(new PieceMoveData(-1, new Vector2Int(x, y), new Vector2Int(x, lowestColumn)));
lowestColumn++;
columnLowest[x] = lowestColumn;
}
}
//drop new pieces to fill the blank spaces
for (int y = lowestColumn; y < m_boardStateTemp.BoardSize.y; y++)
{
int value = Random.Range(0, m_pieceFactory.Prefabs.Length);
m_boardStateTemp.State[x, y] = value;
currentPieceDropDatas.Add(new PieceMoveData(value, new Vector2Int(x, m_boardStateTemp.BoardSize.y + (y - lowestColumn)), new Vector2Int(x, y)));
}
}
GetAllMatches(m_boardStateTemp, m_currentStateMatchData);
boardUpdateData.Enqueue(new BoardUpdateData(currentPieceDropDatas, CopyMatchData(m_currentStateMatchData)));
}
//drop gems also handle matches if there's any
m_boardStateTemp.CopyState(m_boardState);
}
else
{
//no matches
boardUpdateData.Enqueue(new BoardUpdateData(new List <PieceMoveData>()
{
pieceMoveData, pieceMoveData.Inverse
}, new MatchData[0])); //move piece back
}
OnSwapResult.Invoke(boardUpdateData);
}
