//------------------------------------------------------------------------------------------------------------------------------------------------- // 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; }