private static void TestAbstractStack()
{
IAbstractStack<int> abstractStack = new AbstractStack<int>();
// Should return true
var isEmpty = abstractStack.IsEmpty();
abstractStack.Push(1);
abstractStack.Push(2);
abstractStack.Push(3);
abstractStack.Push(4);
// Should have 4 elements
// Should remove first element/last added element - (4)
var removedElement = abstractStack.Pop();
// Should return first element/last added element - (3)
var firstElement = abstractStack.Peek();
// Should return 3
var count = abstractStack.Count;
// Should return false
isEmpty = abstractStack.IsEmpty();
}
public static ClientAPI.AbstractStack CreateEmptyAbstractStack()
{
/*TODO: unclear how to maintain invariant count == 0 => top is undefined */
//System.Nullable<int>();
AbstractStack s1 = new AbstractStack(-1, 0, false);
return(s1);
}
public void PushTest()
{
int initTop = 0; // TODO: Initialize to an appropriate value
int initCount = 0; // TODO: Initialize to an appropriate value
bool initContainsX = true; // TODO: Initialize to an appropriate value
AbstractStack target = new AbstractStack(initTop, initCount, initContainsX); // TODO: Initialize to an appropriate value
int x = 5; // TODO: Initialize to an appropriate value
target.Push(x);
//Assert.Inconclusive("A method that does not return a value cannot be verified.");
}
public static ClientAPI.AbstractStack CreateAbstractStackWithElements(int top, int count, bool contains)
{
/*TODO: unclear how to maintain invariant count == 0 => top is undefined */
//System.Nullable<int>();
int oldTop = top;
PexAssume.IsTrue((count == 0 ? (top == -1 && contains == false) : oldTop == top));
//PexAssume.IsTrue(top != 0);
AbstractStack s1 = new AbstractStack(top, count, contains);
return(s1);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
// Método responsável pela animação das cartas, e pela transação entre a pilha mão do jogador e as demais pilhas do jogo.
IEnumerator Move(AbstractStack destinyStack, Vector3 destinyPosition)
{
Stack <GameObject> cloneHand = CloneHand(); // Clona o condetudo da mão e a esvazia.
GameObject[] handArray = cloneHand.ToArray(); // Converte este clone para um array.
while (handArray[0].transform.position != destinyPosition) // Fica no laço enquando não chegar na posição de destino.
{
//Vector2 offset = (Vector2)handArray[0].transform.position;
handArray[0].transform.position = Vector3.MoveTowards(handArray[0].transform.position, // Move a carta da posição atual para posição final, 18pixels por segundo.
destinyPosition, Time.deltaTime * 18f);
yield return(new WaitForEndOfFrame()); // Aguarda o fim do frame neste Thread.
}
handArray[0].transform.position = destinyPosition; // Cria ilusão de exatidão no movimento.
for (int i = 0; i < handArray.Length; i++)
{
destinyStack.Push(ref cloneHand);
}
GameRulesManager.GetInstance().Organize(); // Reorganiza as cartas, atribuindo a LayerMask para ignorar o Raycast.
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
// Método de conveniência, apenas para enxugar o código de partes repetitivas no método abaixo
private void OrganizeCards(ref GameObject card, Vector2 position, int sortingOrder, AbstractStack stack, string layermask, int stackorder)
{
card.transform.position = position;
card.GetComponent <SpriteRenderer>().sortingOrder = sortingOrder + 1; // Altera a ordem de renderização para a sequencia da pilha, de forma a carta de traz não ser desenhada na carta da frente.
card.GetComponent <Card>().originalStack = stack; // Atribui referência da pilha atual na carta.
card.layer = LayerMask.NameToLayer(layermask); // Atribui Layer para Raycast.
card.GetComponent <Card>().orderInStack = stackorder; // Marca a ordem da carta na pinha.
card.transform.SetParent(null); // "Lipa" qualquer relação de parentesco
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
// Métodos auxiliar, para fazer as cartas irem para pilha de destino.
public void MoveTo(AbstractStack destinyStack, Vector3 destinyPosition)
{
StartCoroutine(Move(destinyStack, destinyPosition)); // faz animação e envia as cartas para sua pilha de destino
GameRulesManager.GetInstance().Organize("Default"); // Organiza as cartas em suas respectivas pilhas, atualizando os status.
}
// Evento quando para de arrastar, liberando o botão do mouse
public void OnEndDrag(PointerEventData eventData)
{
if (_catch) // Confirma se está de fato arrastando carta.
{
if (eventData.pointerCurrentRaycast.gameObject == null) // Checa se a carta está posicionada em cima de um objecto válido.
{
ReturnToOrigin(); // Se não estiver, chama função para devolver as cartas a pilha de origem.
return; // Devolvendo as cartas, sai da função.
}
if (eventData.pointerCurrentRaycast.gameObject.CompareTag("Card")) // Caso o objeto seja válido (verificado aima), verifica se é uma carta (pelo tag).
{
// Estamos tratando nesta parte, das cartas abaixo do cursor do mouse, e NÃO nas cartas arrastadas!
GameObject card = eventData.pointerCurrentRaycast.gameObject; // Recebe referência da a carta apontada abaixo do cursor do mouse (resultado do raycast).
int orderToFit = card.GetComponent <Card>().orderInStack; // Grava a posição da carta de baixo, na variavel orderToFit.
AbstractStack destinyStack = card.GetComponent <Card>().originalStack; // Recebe referência da pilha original que está armazenada nas informações da carta.
if ((destinyStack.type == AbstractStack.TypeOfStack.Intermediate && orderToFit == 0)) // Compara se é uma pilha intermediária e se está apontando para a carta do topo da pilha.
{
if (destinyStack.Validate(GameRulesManager.GetInstance().handStack.stack)) // Faz a validação das cartas que estão na mão do jogador
{
Vector3 position = card.transform.position; // Recebe a posição da carta do topo da pilha (já validado assim, acima).
position.y -= GameRulesManager.GetInstance().stackOffsetPosition; // Aplica o offset de distancia entre as cartas no eixo Y.
MoveTo(destinyStack, position); // Move as cartas da mão do jogador para a pilha destino.
return;
}
}
else if (destinyStack.type != AbstractStack.TypeOfStack.Intermediate) // Caso, esteja apontado para uma carta em uma pilha que NÃO é intermediária (regras das outras pilhas).
{
if (destinyStack.Validate(GameRulesManager.GetInstance().handStack.stack)) // Faz a validação das cartas que estão na mão do jogador, para as pilhas definitivas ou slots individuais
{
Vector3 position = card.transform.position; // Recebe a posição física que a carta deverá ter na pilha.
MoveTo(destinyStack, position); // Move as cartas da mão do jogador para a pilha destino.
return;
}
}
}
else if (eventData.pointerCurrentRaycast.gameObject.CompareTag("Area")) // Caso o objeto seja válido (verificado aima), e não seja uma carta, mas sim uma pilha ainda vazia.
{
GameObject area = eventData.pointerCurrentRaycast.gameObject; // Recebe a referência desta pilha física.
AbstractStack destinyStack = area.GetComponent <StackArea>().stackCards; // Recebe referência da pilha contida nesta pilha física.
if (destinyStack.type != AbstractStack.TypeOfStack.Intermediate) // Caso tratar-se de pilhas definitivas ou slots individuais.
{
if (destinyStack.Validate(GameRulesManager.GetInstance().handStack.stack)) // Faz a validação das cartas que estão na mão do jogador nas regras de pilha definitiva e slots individuais.
{
Vector3 position = area.transform.position; // Recebe a posição física que a carta deverá ter na pilha.
MoveTo(destinyStack, position); // Move as cartas da mão do jogador para a pilha destino.
return;
}
}
else if (destinyStack.type == AbstractStack.TypeOfStack.Intermediate && destinyStack.stack.Count == 0) // Caso seja uma pilha definitiva fazia
{
GameObject card = GameRulesManager.GetInstance().handStack.stack.Peek(); // Pega uma carta da mão do jogador, apenas para ter acesso a medidas, para calcular as posições
Bounds coordinates = area.GetComponent <BoxCollider2D>().bounds; // Coordenadas das áreas de depósito de cartas.
Vector2 offset = new Vector2(coordinates.center.x, coordinates.max.y - (card.GetComponent <BoxCollider2D>().bounds.size.y / 2)); // Cria um offset para alinar as cartas.
MoveTo(destinyStack, offset); // Move as cartas da mão do jogador para a pilha destino.
return;
}
}
ReturnToOrigin(); // Se chegar até aqui, é porque nenhum dos casos anteriores foi validado, portanto, retorna para pilha de origem.
} // que utilizaremos para saber se a carta de baixo é a ultima carta da pilha
this._catch = false; // Assinala que não está mais arrastando carta
//GameRulesManager.GetInstance().Organize("Ignore Raycast");
}