// void moveTowardsNetworkTransform(){
// //if the piece is grabbed by the local player, instantly move it
// if(networkPiece.grabbedByLocalPlayer && false){
// transform.position = networkPiece.transform.position;
// transform.rotation = networkPiece.transform.rotation;
// }
// //if not, smoothly move it towards the network position (in world space)
// else {
// transform.rotation = networkPiece.transform.rotation;
// Vector3 dir = networkPiece.transform.position - transform.position;
// transform.Translate(dir * 0.4f, Space.World);
// }
// if(transform.position.z > 0.01f) transform.position = new Vector3(transform.position.x, transform.position.y, 0.0f);
// }
public void Setup(PieceData data)
{
GetComponent <MeshFilter>().mesh = data.mesh;
MeshCollider collider = gameObject.AddComponent <MeshCollider>();
collider.sharedMesh = data.colliderMesh;
}
// Start is called before the first frame update
void Start()
{
matrixTest = new PieceData[16, 10];
nativeTest = new NativeArray <PieceData>(160, Allocator.Temp);
for (int x = 0; x < 16; x++)
{
for (int y = 0; y < 10; y++)
{
matrixTest[x, y] = new PieceData()
{
x = x,
y = y
};
}
}
int index = 0;
foreach (var item in matrixTest)
{
nativeTest[index] = item;
index++;
}
Debug.Log($"X: {nativeTest[96].x} | Y: {nativeTest[96].y}");
nativeTest.Dispose();
}
void SetType(PieceData type)
{
// update the graphics and all that.
this.type = type;
spriteRenderer.sprite = type.sprite;
spriteRenderer.color = type.color;
}
public void AddPieceToList(APiece piece)
{
if (SelectedPieces.Contains(piece))
{
int indexOfDuplicate = SelectedPieces.IndexOf(piece);
SelectedPieces.RemoveRange(indexOfDuplicate + 1, SelectedPieces.Count - indexOfDuplicate - 1);
}
else
{
if (SelectedPieces.Count >= 1)
{
PieceData previousPieceData = SelectedPieces[0].GetComponent <PieceData>();
PieceData currentPieceData = piece.GetComponent <PieceData>();
if (previousPieceData.Color == currentPieceData.Color && MyUtils.IsTileAdjacent(SelectedPieces[SelectedPieces.Count - 1].ParentTile, piece.ParentTile) && previousPieceData.Type != EPieceType.Bomb)
{
SelectedPieces.Add(piece);
}
}
else
{
SelectedPieces.Add(piece);
}
}
UpdateHighlight();
}
/// <summary>
/// Searchs the normal moves.
/// </summary>
/// <param name="piece">Piece.</param>
/// <param name="moves">Moves.</param>
private void SearchNormalMoves(PieceData piece, MoveSet moves)
{
TileNode cur = node;
// extend out by the range and search for more.
for (int r = 0; r < piece.range; r++)
{
// move to next tile
cur = cur.adjacent[piece.direction];
// check if current tile is one you can move to
if (CheckCurrentTileMove(cur))
{
moves.AddMove(node, false, cur);
}
// check if any more moves can be made after (not including range)
if (!CheckFurtherMovement(cur))
{
break;
}
// run checks to see if hooking is possible
if (CheckHookMove(cur, piece))
{
moves.AddMove(node, true, cur, cur.adjacent[hook.direction]);
}
}
}
void Start()
{
_propertyBlock = new MaterialPropertyBlock();
_matrices = new Matrix4x4[_count];
_data = new PieceData[_count];
_colors = new Vector4[_count];
for (int i = 0; i < _count; i++)
{
_matrices[i] = Matrix4x4.identity;
_data[i] = new PieceData();//
_data[i].rot = Quaternion.Euler(
360f * Random.value,
360f * Random.value,
360f * Random.value
);
_data[i].scale = new Vector3(
0.1f, 0.2f + 5.0f * Random.value, 0.1f
);
_colors[i] = new Vector4(
Random.value,
Random.value * 0.8f,
Random.value * 0.4f,
1f
);
}
//SetScale();
}
private void createPieces(PieceData type)
{
GameObject piece = Instantiate(piecePrefab, container.transform);
PieceInfo script = piece.GetComponent <PieceInfo>();
script.SetValues(type);
pieces.Add(piece);
}
public void testConstructorPieceData_OK()
{
PieceData myPlayer = new PieceData(22, 1, 1);
Assert.AreEqual(myPlayer.jugador, 1);
Assert.AreEqual(myPlayer.posicionEnMano, 1);
Assert.AreEqual(myPlayer.valor, 22);
}
/// <summary>
/// Takes a piece owned by an opposing player.
/// </summary>
/// <param name="piece"></param>
public void TakePiece(PieceData piece)
{
// Can only take pieces owned by other players
if (piece.colour != colour && piece.type == PieceData.Type.Normal)
{
takenPieces.Add(piece);
}
}
public void PromoteTo(int pos, EPieceType piece)
{
EChessTeam color = GetColorFromPos(pos);
PieceData data = GetPieceFromPos(pos, color);
SetBitValue(EPieceTypeToBitBoardIndex(data.piece, color), pos, false);
SetBitValue(EPieceTypeToBitBoardIndex(piece, color), pos, true);
}
public GameObject Create(PieceData pieceData)
{
GameObject gridItemObject = Create();
ConstructPiece(pieceData, gridItemObject);
return(gridItemObject);
}
public void Construct(PieceData pieceData)
{
this.pieceData = pieceData;
text.text = pieceData.Text;
GridItemMover gridItemMover = GetComponent <GridItemMover>();
gridItemMover.SetupRownAndColumn(pieceData.PlaceInGrid, 0, 0);
}
public static Inventory.IItem FromDataToInventory(PieceData data)
{
return(new InventoryPiece()
{
piece = ReadData(data),
quantity = data.Quantity
});
}
void SetUpGameFromData()
{
UIViewController.DeactivateUIView("MainView");
UIViewController.DeactivateUIView("ResultsView");
if (!_bgAssets)
{
_bgAssets = true;
for (int i = 0; i < BGSprites.Count; i++)
{
BGSprites[i].enabled = true;
}
}
ClearAllObjects();
if (_redTeam != null)
{
_redTeam.Reset();
}
if (_blueTeam != null)
{
_blueTeam.Reset();
}
CreateFlags();
// create teams
List <Piece> redPieces = new List <Piece>();
_redTeam = new Team(TeamColor.RED, null, _redFlag.Position);
List <Piece> bluePieces = new List <Piece>();
_blueTeam = new Team(TeamColor.BLUE, null, _blueFlag.Position);
List <Piece> currentPieceList;
Team team;
for (int i = 0; i < OnlineManager.Instance.GameData.pieces.Count; i++)
{
PieceData pieceData = OnlineManager.Instance.GameData.pieces[i];
if (pieceData.team_name == "red")
{
team = _redTeam;
currentPieceList = redPieces;
}
else
{
team = _blueTeam;
currentPieceList = bluePieces;
}
CreatePiece(currentPieceList, pieceData);
}
_redTeam.Pieces = redPieces;
_redTeam.SetPieceLookups();
_blueTeam.Pieces = bluePieces;
_blueTeam.SetPieceLookups();
_startTime = DateTime.UtcNow;
}
public void PieceIsCorrectlyRetrieved()
{
List <PieceData> pieceDataList = CreatePieceDataList(3);
PieceDataSorter pieceSorter = CreatePieceDataSorter(pieceDataList);
PieceData pieceData = pieceSorter.GetRandomPieceData();
Assert.IsNotNull(pieceData);
}
void Load()
{
int count = (int)TutorialPiece.None;
for (int i = 0; i < count; i++)
{
m_Pieces[(TutorialPiece)i] = new PieceData();
}
}
public void EachTimeDataIsRetrievedItIsRemovedFromList()
{
List <PieceData> pieceDataList = CreatePieceDataList(3);
PieceDataSorter pieceSorter = CreatePieceDataSorter(pieceDataList);
PieceData retrievedPieceData = pieceSorter.GetRandomPieceData();
Assert.IsFalse(pieceDataList.Contains(retrievedPieceData));
}
private void GeneratePieceMesh(PieceData p)
{
//use HashSet to prevent double vertices
HashSet <Vector2> vertices2DSet = new HashSet <Vector2>();
HashSet <Vector2> vertices2DColliderSet = new HashSet <Vector2>();
foreach (Neighbour n in p.neighbours)
{
//if this 'neighbour' is the boundary, set edgeType to straight
if (n.id == -1)
{
n.edgeType = PEdge.EdgeType.Straight;
}
//else if the edgeType wasn't set to something yet, set it here
//and also set the corresponding neighbours edgeType to the opposite type
else if (n.edgeType == PEdge.EdgeType.Nothing)
{
PieceData neighbourPiece = GetPieceData(n.id);
Neighbour meAsNeighbour = neighbourPiece.GetNeigbourWithID(p.id);
if (randomBool(p.id))
{
n.edgeType = PEdge.EdgeType.Shaped;
meAsNeighbour.edgeType = PEdge.EdgeType.ShapedInverse;
}
else
{
n.edgeType = PEdge.EdgeType.ShapedInverse;
meAsNeighbour.edgeType = PEdge.EdgeType.Shaped;
}
}
PEdge edge = new PEdge(p.baseVertices[n.v1], p.baseVertices[n.v2], n.edgeType, meshDetail);
PEdge edgeLowDetail = new PEdge(p.baseVertices[n.v1], p.baseVertices[n.v2], n.edgeType, colliderDetail);
edge.points.ForEach(point => vertices2DSet.Add(point));
edgeLowDetail.points.ForEach(point => vertices2DColliderSet.Add(point));
}
List <Vector2> vertices2D = vertices2DSet.ToList();
List <Vector2> vertices2DCollider = vertices2DColliderSet.ToList();
//create final visual mesh
Triangulator triangulator = new Triangulator(vertices2D);
int[] triangles = triangulator.Triangulate();
Vector3[] vertices = vertices2D.ConvertAll(v2 => new Vector3(v2.x, v2.y, 0f)).ToArray();
p.mesh = MeshFunctions.ExtrudeFlatPiece(vertices, triangles, thickness);
ProjectUV(p.mesh, p.position);
//create final collider mesh
triangulator = new Triangulator(vertices2DCollider);
int[] colliderTriangles = triangulator.Triangulate();
Vector3[] colliderVertices = vertices2DCollider.ConvertAll(v2 => new Vector3(v2.x, v2.y, 0f)).ToArray();
p.colliderMesh = MeshFunctions.ExtrudeFlatPieceNoSplit(colliderVertices, colliderTriangles, thickness);
}
/// <summary>
/// Setter for the pieceData.
/// </summary>
/// <param name="pieceDataToSet"> The pieceData to override the current data. </param>
public void SetPieceData(PieceData pieceDataToSet)
{
pieceData.playerIdx = pieceDataToSet.playerIdx;
pieceData.currentIndex = pieceDataToSet.currentIndex;
pieceData.madeFirstMove = pieceDataToSet.madeFirstMove;
pieceData.isKing = pieceDataToSet.isKing;
pieceData.isDead = pieceDataToSet.isDead;
pieceData.hasPostPlayAction = pieceDataToSet.hasPostPlayAction;
}
/// <summary>
/// Searchs the reverse hook moves.
/// </summary>
/// <param name="piece">Piece.</param>
/// <param name="moves">Moves.</param>
private void SearchReverseHookMoves(PieceData piece, MoveSet moves)
{
TileNode cur = node.adjacent[hook.direction];
TileNode hooked = node.adjacent[hook.direction];
#region reverse hook condition
// can't revese hook your own pieces
if (piece.colour == owningColour)
{
return;
}
// must have tower of 6 to hook
if (pieces.Count != 6)
{
return;
}
// check if able to move on the given tile
if (!CheckCurrentTileMove(cur))
{
return;
}
// Can't jump or move along the way
if (cur.type == TileNode.Type.Way && cur.adjacent[piece.direction] != node)
{
return;
}
#endregion
// add hook'd
//moves.AddMove(node, false, hooked);
#region move search
// extend out by the range and search for more.
for (int r = 0; r < piece.range; r++)
{
// move to next tile
cur = cur.adjacent[piece.direction];
// check if current tile is one you can move to
if (CheckCurrentTileMove(cur))
{
moves.AddMove(node, true, hooked, cur);
}
// check if any more moves can be made after (not including range)
if (!CheckFurtherMovement(cur))
{
break;
}
}
#endregion
}
/// <summary>
/// 补充队列
/// </summary>
void FillNextPiece()
{
FillNextBag();
this.nextPieces.Enqueue(nextBag.Dequeue());
this.selectedPrefab = piecePrefabs[this.nextPieces.Peek()];
this.selectedData = pieceDatas[this.nextPieces.Peek()];
UpdatePreview();
}
void createPiecePrototypes()
{
moveNameMap = new Dictionary <string, Move> ();
moves = new List <Move> ();
piecePrefabs = new Dictionary <string, GameObject> ();
piecePrototypes = new Dictionary <string, Piece> ();
MoveData.loadMoveData();
PieceData.loadPieceData();
}
public void SetValues(PieceData data)
{
render = this.GetComponent <SpriteRenderer>();
color = data.color;
type = data.type;
isActive = data.isActive;
moved = data.moved;
value = data.value;
render.sprite = data.skin;
}
/// <summary>
/// Constructor for a new tower
/// </summary>
/// <param name="owner"></param>
/// <param name="startingPiece"></param>
/// <param name="startNode"></param>
public PieceTower(Player owner, PieceData startingPiece, TileNode startNode)
{
pieces = new List <PieceData>(6);
owningColour = owner.colour;
owningPlayer = owner;
AddPiece(startingPiece);
node = startNode;
MoveTo(startNode);
startingPiece.SetupTextures();
}
public void EachPieceDataTakenIsDifferent()
{
List <PieceData> pieceDataList = CreatePieceDataList(3);
PieceDataSorter pieceSorter = CreatePieceDataSorter(pieceDataList);
PieceData firstPieceData = pieceSorter.GetRandomPieceData();
PieceData secondPieceData = pieceSorter.GetRandomPieceData();
Assert.AreNotEqual(firstPieceData, secondPieceData);
}
public void PutPiece(PieceData pieza)
{
int StartPieceInt = pieza.valor;
int PiecePosition = pieza.posicionEnMano;
int PlayerPosition = pieza.jugador;
HidePieceInHand(PiecePosition, PlayerPosition);
ShowPieceInTable(StartPieceInt);
DecrementPlayerAvailablepPieces(PlayerPosition);
}
private void Awake()
{
if (_instance != null && _instance != this)
{
Destroy(this.gameObject);
}
else
{
_instance = this;
}
}
private IEnumerator Spawn()
{
//TODO: Play spawn VFX/particles
yield return(spawnDelay);
var currentPieceData = NextPieceData;
var pieceController = Instantiate(currentPieceData.prefab, spawnPosition, Quaternion.identity).GetComponent <PieceController>();
ActivePieces.AddNewPiece(pieceController);
NextPieceData = GetRandomData();
}
public void ShowPiece(PieceData pieza, int myPosition)
{
int PieceValue = pieza.valor;
int PiecePosition = pieza.posicionEnMano;
int PlayerPosition = pieza.jugador;
//Se muestra al jugador una pieza que se encuentra en su poder
PaintPiece(PieceValue, PiecePosition, PlayerPosition, myPosition);
// Se actualiza el valor de las piezas de las que dispone el jugador
UpdatePlayerAvailablesPiecesInformacion(PlayerPosition);
}
/// <summary>
/// CALLBACK METHODS
/// se encarga de enviar al jugador de la mesa
/// un objeto que contiene los datos de la pieza de domino
/// del jugador.
/// </summary>
public void ShowPiece(PieceData piece)
{
/// <summary>
///Se muestra al jugador una pieza que se encuentra en su poder
/// </summary>
domino.PaintPieceInPlayerHand(piece.PieceValue, piece.PiecePosition, piece.PlayerPosition);
/// <summary>
/// Se actualiza el valor de las piezas de las que dispone el jugador
/// </summary>
domino.IncrementPlayerAvailablePieces(piece.PlayerPosition);
}
void Load()
{
int count = (int)TutorialPiece.None;
for (int i = 0; i < count; i++)
{
m_Pieces[(TutorialPiece)i] = new PieceData();
}
}
