//-------------------------------------------------------------------------------------------------------------------------------------------------
// Métodos das interfaces herdadas.
// Evento invocado no momento em que começa a arrastar a carta
public void OnBeginDrag(PointerEventData eventData)
{
this._clickOffset = (Vector2)this.transform.position - MousePosition; // Calcula o offset do clique do mouse na carta.
//RaycastResult hit = eventData.pointerCurrentRaycast; // Recebe o resultado do Raycast.
// Etapa de validação para saber se pode pegar a carta
int quantity = orderInStack + 1; // Pela ordem da carta na pilha, descobre-se a quantidade que tenta pegar.
if (GameRulesManager.GetInstance().handStack.Validate(originalStack.stack, quantity)) // Se validar pelas regras da pilha da mão.
{
this.originalPosition = transform.position; // Atribui a posição física original.
GameRulesManager.GetInstance().handStack.Push(ref originalStack.stack, quantity); // Adiciona a(s) carta(s) na pilha da mão.
// Atribui hierarquia de parentesco nas cartas que serão movidas, se houver mais de uma
if (quantity > 1)
{
GameObject[] cardsArray = GameRulesManager.GetInstance().handStack.stack.ToArray();
for (int i = quantity - 2; i >= 0; i--) // Menos 2, porque itera duas cartas por vez, e o indice começa em zero.
{
cardsArray[i + 1].transform.SetParent(cardsArray[i].transform); // Faz a de baixo, filha da de cima.
}
}
this._catch = true; // Assinala o estado como segurando carta.
GameRulesManager.GetInstance().Organize("Default");
}
}
public void SetRepresentedRules(GameRules rulesData, GameRulesManager gameRulesManagerInstance)
{
GameRulesManagerInstance = gameRulesManagerInstance;
RepresentedRules = rulesData;
RulesNameLabel.text = rulesData.RuleSetName;
SelectionButton.onClick.RemoveAllListeners();
SelectionButton.onClick.AddListener(() => { GameRulesManagerInstance.SetRulesFromPreset(RepresentedRules); });
}
private void Start()
{
_gameRulesManager = FindObjectOfType <GameRulesManager>();
Debug.Assert(_gameRulesManager != null);
Debug.Assert(_pauseView && _ingameView);
_pauseView.Hide();
_ingameView.Show();
//SoundManager.Instance.StartGameMainTheme();
}
//create and maintain singleton
void Awake()
{
if (_instance == null)
{
_instance = this;
}
else if (_instance != this)
{
Destroy(gameObject);
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
// Método que Clona a pilha mão do jogador para um objeto temporário, e limera o conteudo da pilha mão de jogador
private Stack <GameObject> CloneHand()
{
Stack <GameObject> result = new Stack <GameObject>(); // Cria um objeto temporário to tipo pilha de GameObjects.
GameObject[] handArray = GameRulesManager.GetInstance().handStack.stack.ToArray(); // Converte o conteudo para um array.
for (int i = handArray.Length - 1; i >= 0; i--) // Clona o conteudo de mão do jogador para o objeto temporário.
{
result.Push(handArray[i]);
}
GameRulesManager.GetInstance().handStack.stack.Clear(); // Limpa o conteudo de mão de jogador.
return(result); // Retorna o objeto temporário.
}
private void Start()
{
//I hate doing this but it's easier then drag-and-dropping the character to the placeholder for each level so just let it
_character = FindObjectOfType <CharacterMovement>();
if (_character == null)
{
Debug.LogError("Character is missing!");
return;
}
GameRulesManager gameManager = GameRulesManager.Instance;
gameManager.OnKnightSpawned += OnKnightSpawn;
gameManager.OnOneSecondLeft += OnOneSecondLeft;
}
public GameObject gameOverMenu = null; // Painel de Game Over.
//-------------------------------------------------------------------------------------------------------------------------------------------------
// Métodos herdados de MonoBehaviour
// Use this for initialization
void Awake()
{
//---------------------------------------------------------------------------------------------------------------
// Singleton - Design Pattern
if (_Instance != null)
{
Destroy(gameObject);
Debug.LogError("Mais de uma instancia de GameManager!!! Algo muito errado aconteceu!!!");
return;
}
_Instance = this;
//---------------------------------------------------------------------------------------------------------------
// Inicialização das pilhas
for (int i = 0; i < _intermediateStacks.Length; i++)
{
_intermediateStacks[i] = new IntermediateStack(AbstractStack.TypeOfStack.Intermediate); // Inicialização das pilhas intermediárias.
}
for (int i = 0; i < _definitiveStacks.Length; i++)
{
_definitiveStacks[i] = new DefinitiveStack(AbstractStack.TypeOfStack.definitive); // Inicialização das pilhas definitivas.
}
for (int i = 0; i < _singleSlotStacks.Length; i++)
{
_singleSlotStacks[i] = new SingleSlotStack(AbstractStack.TypeOfStack.SingleSlot); // Inicialização das pilhas de cartas soltas.
}
//---------------------------------------------------------------------------------------------------------------
// Inicialização das areas físicas das pilhas
for (int index = 0; index < _intermediateStackArea.Length; index++)
{
_intermediateStackArea[index].GetComponent <StackArea>().stackCards = _intermediateStacks[index]; // Inicializa referências das areas de pilhas intermediárias.
}
for (int index = 0; index < _definitiveStackArea.Length; index++)
{
_definitiveStackArea[index].GetComponent <StackArea>().stackCards = _definitiveStacks[index]; // Inicializa referências das areas de pilhas definitivas.
}
for (int index = 0; index < _singleSlotStackArea.Length; index++)
{
_singleSlotStackArea[index].GetComponent <StackArea>().stackCards = _singleSlotStacks[index]; // Inicializa referências das areas de pilhas slot individual.
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
// 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.
}
public void Start()
{
rules = GameRulesManager._instance;
print("can be dragged starting value: " + canBeDragged);
oldParent = this.transform.parent;
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
// 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.
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
// Métodos auxiliar, para fazer as cartas voltarem para pilha de origem.
public void ReturnToOrigin()
{
StartCoroutine(Move(originalStack, originalPosition)); // faz animação e devolve as cartas para sua pilha de origem.
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");
}
public void Start()
{
rules = GameRulesManager._instance;
}
