예제 #1
0
    public override void RaiseEventTileSwitchAnimBegan(Match3Tile neighborTile)
    {
        base.RaiseEventTileSwitchAnimBegan(neighborTile);
        lastNeighborTile = neighborTile as NormalTile;

        movedByInput = true;
    }
예제 #2
0
    public override bool TryToMoveTile(AbstractTile srcTile, AbstractTile dstTile)
    {
        if (srcTile == dstTile || srcTile == null || dstTile == null)
        {
            return(false);
        }

        if (CanMoveTile(srcTile, dstTile.BoardPiece))
        {
            Match3Tile srcMatch3Tile = srcTile as Match3Tile;
            Match3Tile dstMatch3Tile = dstTile as Match3Tile;

            if (OnUserStartedTilesSwitch != null)
            {
                OnUserStartedTilesSwitch(srcMatch3Tile, dstMatch3Tile);
            }

            srcMatch3Tile.RaiseEventTileTappedFirst();

            srcMatch3Tile.IsTileSwitching = true;
            dstMatch3Tile.IsTileSwitching = true;
            BoardAnimations.SwitchTilesAnim(true, srcMatch3Tile, dstMatch3Tile);

            return(true);
        }

        return(false);
    }
예제 #3
0
    protected TileColorType GetMatchingColorBetweenDirections(Match3BoardPiece startPiece, Match3BoardPiece.LinkType dirA, Match3BoardPiece.LinkType dirB)
    {
        Match3BoardPiece pieceDirA = startPiece.GetNeighbor(dirA);
        Match3BoardPiece pieceDirB = null;

        if (dirA != dirB)
        {
            pieceDirB = startPiece.GetNeighbor(dirB);
        }
        else if (pieceDirA != null)
        {
            pieceDirB = pieceDirA.GetNeighbor(dirA);
        }

        if (pieceDirA != null && pieceDirB != null)
        {
            Match3Tile tileDirA = pieceDirA.Tile as Match3Tile;
            Match3Tile tileDirB = pieceDirB.Tile as Match3Tile;

            if (tileDirA != null && tileDirB != null && tileDirA.CanBeMatched && tileDirB.CanBeMatched && tileDirA.IsMatchWith(tileDirB))
            {
                return(tileDirA.TileColor);
            }
        }

        return(TileColorType.None);
    }
예제 #4
0
    IEnumerator DestroyColoredTiles()
    {
//		float offsetSize = Mathf.Abs(Board[0, 0].LocalPosition.x - Board[0, 1].LocalPosition.x) / 2f;
        if (OnTriggerColorBombTile != null)
        {
            OnTriggerColorBombTile(this);
        }

        if (destroyColor == TileColorType.None)
        {
            destroyColor = RuleEntry.genericColors[Random.Range(0, Match3BoardRenderer.maxNumBoardColors)];
        }

        for (int i = 0; i < Board.NumRows; i++)
        {
            for (int j = 0; j < Board.NumColumns; j++)
            {
                Match3Tile tile = Board[i, j].Tile as Match3Tile;
//				if (tile != null && !(tile is DropTile) && tile.TileColor == destroyColor)
                if (IsValidTarget(tile, destroyColor))
                {
                    tilesToDestroy.Add(tile);
                    if (iceTrailEffect != null)
                    {
                        Transform effectInstance = (Instantiate(iceTrailEffect) as GameObject).transform;
                        effectInstance.position = WorldPosition;                        // + new Vector3(0f, 0f, -5f);
                        effectInstance.parent   = cachedTransform.parent;

                        effectInstance.LookAt(tile.cachedTransform);

                        tile.IsUserMoveable = false;
                        StartCoroutine(MoveTargetTo(effectInstance, tile.cachedTransform, tilesDestroyEffect.destroyTileTime));
//						HOTween.To(effectInstance, tilesDestroyEffect.destroyTileTime, "localPosition", Board[i, j].LocalPosition);

                        Destroy(effectInstance.gameObject, tilesDestroyEffect.lifeTime * 1.5f);
                    }
                }
            }
        }

        yield return(new WaitForSeconds(tilesDestroyEffect.destroyTileTime));

        for (int i = 0; i < tilesToDestroy.Count; i++)
        {
            if (tilesToDestroy[i])
            {
                tilesToDestroy[i].IsMatched = true;
                tilesToDestroy[i].Destroy();
            }
        }

        if (tilesDestroyEffect.destroyTileTime < animation["effect_winterchill_idle"].length)
        {
            yield return(new WaitForSeconds(animation["effect_winterchill_idle"].length - tilesDestroyEffect.destroyTileTime));
        }

        base.TileDestroy(false);

        Match3BoardGameLogic.Instance.TryCheckStableBoard();
    }
예제 #5
0
    public void ExecuteInitialSpawnRule()
    {
        if (initialTileSpawnRule != null)
        {
            List <RuleEntry>     tempRuleEntryList;
            List <TileSpawnRule> immediateSpawnList = Match3BoardGameLogic.Instance.immediateSpawnList;

            //Check immediateSpawnList for available rules that can be applied, with respect to the eligibleSpawnList.
            for (int i = 0; i < immediateSpawnList.Count; i++)
            {
                if (eligibleSpawnList != null && eligibleSpawnList.Count > 0)
                {
                    tempRuleEntryList = immediateSpawnList[i].CompareRuleEntries(eligibleSpawnList);
                    immediateSpawnList.RemoveAt(i);
                }
                else
                {
                    tempRuleEntryList = immediateSpawnList[i].ruleEntries;
                }

                if (tempRuleEntryList != null)
                {
                    initialTileSpawnRule.ruleEntries = tempRuleEntryList;
                    break;
                }
            }

            // Execute the initial spawn rule only if we have at least one RuleEntry.
            if (initialTileSpawnRule.ruleEntries.Count > 0)
            {
                Match3Tile newTile = initialTileSpawnRule.SpawnNewTile(true);
                Match3BoardRenderer.Instance.AttachTileToBoardAt(this, newTile, false, true);
            }
        }
    }
    public Match3Tile SpawnTileAt(int rowIdx, int columnIdx, bool offBoardTile = false, bool noLockedTiles = false, bool isBoardSetup = false)
    {
        int rand;

        if (noLockedTiles)
        {
            //TODO: temporary spawn hack to spawn only new normal tiles on the board.
            rand = Random.Range(0, 6);             //a normal tile
        }
        else
        {
            rand = Random.Range(0, 100);             // current chance for locked tile is 6/100 = 6%
            if (rand < 6)
            {
                rand += 6;                 //a locked tile
            }
            else
            {
                rand = Random.Range(0, 6);                 //a normal tile
            }
        }

        Match3Tile newTilePrefab = tilesPrefabs[rand].GetComponent <Match3Tile>();

        return(SpawnSpecificTileAt(rowIdx, columnIdx, newTilePrefab.GetType(), newTilePrefab.TileColor, offBoardTile, isBoardSetup));
    }
예제 #7
0
    public override void RaiseEventTileSwitchAnimBegan(Match3Tile neighborTile)
    {
        base.RaiseEventTileSwitchAnimBegan(neighborTile);

        if (neighborTile is BombTile)
        {
            BombTile neighborBomb = neighborTile as BombTile;
            // Mark this tile and it's neighbor as moving and without any gravity because there will be a custom animation on them
            // to try and keep things consistent.
            neighborBomb.DisableTileLogic();
            DisableTileLogic();

            // Prepare the bigger directional destroy effect on this directional tile.
            prefabTilesDestroyEffect = prefabBombCombineDestroyEffect;
        }

        if (neighborTile is DirectionalDestroyTile)
        {
            DirectionalDestroyTile directionalTile = neighborTile as DirectionalDestroyTile;
            directionalTile.SwitchBackOnMatchFail = false;
            SwitchBackOnMatchFail = false;

            CanBeMatched = false;
            (neighborTile as NormalTile).CanBeMatched = false;
        }
    }
예제 #8
0
 void OnTilesDestroyed(Match3Tile tile)
 {
     if (!updatingValues)
     {
         StartCoroutine(UpdateValues());
     }
 }
예제 #9
0
    public Match3Tile SpawnTileAt(Match3BoardPiece boardPiece, BoardCoord boardPos, GameObject tilePrefab)
    {
        // Destroy previous tile from board piece (if present).
        if (boardPiece.EditorTile != null)
        {
            // Remove the first spawn rule entry for this tile if it corresponds to its type.
            SetBoardPieceSpawnRuleForTile(boardPiece, boardPiece.EditorTile, true);
            GameObject.DestroyImmediate(boardPiece.EditorTile.gameObject);
        }

        GameObject newTileGO = PrefabUtility.InstantiatePrefab(tilePrefab) as GameObject;

        PrefabUtility.DisconnectPrefabInstance(newTileGO);

        Match3Tile newTile = newTileGO.GetComponent <Match3Tile>();

        newTile.name                    = string.Format("[{0},{1}] {2}", boardPos.row, boardPos.col, newTile.name);
        newTile.transform.parent        = boardRenderer.transform;
        newTile.transform.localPosition = boardPiece.transform.localPosition - boardRenderer.transform.forward * 2f;
        boardPiece.EditorTile           = newTile;

        // Add the first spawn rule entry for with this tile's type.
        SetBoardPieceSpawnRuleForTile(boardPiece, boardPiece.EditorTile);

        return(newTile);
    }
예제 #10
0
	protected override void TileDestroy(bool useEffect) 
	{	
		spawnResult = CheckForSpawnPatterns();
		
		cachedTransform.localPosition += Vector3.forward * -2f;

		if (spawnTimeBomb && !spawnResult) {
			spawnedTimeBomb = SpawnTimeBomb();
		}
		
		if (useDestroyEffect && useEffect) 
		{
			// Check if this bomb is a bomb resulted from a Bomb+Bomb combination
			if (prefabDestroyEffect == prefabDoubleDestroyEffect)
			{
				if (OnBombBombCombine != null) {
					OnBombBombCombine(this);
				}
			}
				
			TileBombDestroyEffect bombDestroyEffect = SpawnDestroyEffect(new Vector3(0f, 0f, -19f)).gameObject.GetComponent<TileBombDestroyEffect>();	
			bombDestroyEffect.explosionSpreadTime = animation.clip.length - bombDestroyEffect.delayAfterExplosionSpread;
			bombDestroyEffect.InitBombDestroyEffect(this, WorldPosition);
			bombDestroyEffect.triggerListener.OnTileEntered = OnTileEnteredDestroyTrigger;
			bombDestroyEffect.triggerListener.OnBoardPieceEntered = OnBoardPieceEnteredFreezeTrigger;
			bombDestroyEffect.OnEffectFinished = OnBombDestroyEffectFinished;
			
			//TODO:Remove redundant chunks of code if u will ever have the time / decency to do so
			//TODO: MIO: Revise this .. it was way too late when you wrote this.
			Transform effectInstance = (Instantiate(PrefabEffectBreakFragments) as GameObject).transform;
			effectInstance.position = WorldPosition;
			Destroy(effectInstance.gameObject, destroyEffect.lifeTime);
			effectBreakFragmentsInstance = effectInstance.GetComponent<TileDestroyEffect>();
			
			if (freezeEffect) {
				Destroy(freezeEffect);
				effectBreakFragmentsInstance.GetComponent<TileDestroyEffect>().UpdateMaterial(PrefabFreezeDestroyMaterialArray[(int)TileColor - 1]);
			}
			else {
				effectBreakFragmentsInstance.GetComponent<TileDestroyEffect>().UpdateMaterial(TileColor);
			}
			
			tileModelRenderer.enabled = false;
			//--------------------------------------------------------------------------------------
			
			animation.Play();
			
			if(tileModelAdditionalRenderer != null) {
				tileModelAdditionalRenderer.transform.parent.animation.Play("tile_iceberg_destroy");
			}
			
			if (OnTriggerBombTileFreeze != null) {
				OnTriggerBombTileFreeze(this);
			}
		}
		else {
			base.TileDestroy(false);
		}
	}
    public static void OnDrawGizmos(Match3Tile tile, GizmoType gizmoType)
    {
        if (!tile.canDrawGizmos || !tilesDebugDisplayOverride)
        {
            return;
        }

        string tileStates = "";

        if (tile.IsMoving)
        {
            tileStates = AppendState(tileStates, "M, ", maxStatesLength);
        }
        if (tile.IsDestroying)
        {
            tileStates = AppendState(tileStates, "D, ", maxStatesLength);
        }
        if (tile.debugPassiveGravity)
        {
            tileStates = AppendState(tileStates, "Pg, ", maxStatesLength);
        }
        if (tile.debugActiveGravity)
        {
            tileStates = AppendState(tileStates, "Ag, ", maxStatesLength);
        }
        if (tile.BoardPiece != null && !tile.HasReachedBoardPieceArea())
        {
            tileStates = AppendState(tileStates, "Bd, ", maxStatesLength);
        }

        tileStates = tileStates.Trim();

        if (labelStyle == null)
        {
            labelStyle = new GUIStyle();
            labelStyle.normal.textColor  = Color.yellow;
            labelStyle.fontSize          = 14;
            labelStyle.normal.background = MakeTex(2, 2, Color.black);
        }

        Handles.Label(tile.transform.position + new Vector3(-tile.collider.bounds.extents.x, tile.collider.bounds.extents.y, 0f),
                      tileStates, labelStyle);

        Matrix4x4 pushedMatrix = Gizmos.matrix;

        if (tile.transform.parent != null)
        {
            Gizmos.matrix = tile.transform.parent.localToWorldMatrix;
        }

        Gizmos.color = Color.green;
        Gizmos.DrawWireSphere(tile.fallDestination, 0.25f);

        if (tile.transform.parent != null)
        {
            Gizmos.matrix = pushedMatrix;
        }
    }
	public void InitBombDestroyEffect(Match3Tile owner, Vector3 destroyTriggerPos) {
		effectOwner = owner;
		
		// Setup destroy trigger
		destroyTrigger.position = destroyTriggerPos;
		triggerListener = destroyTrigger.gameObject.GetComponent<TilesTriggerListener>();
			
		StartCoroutine(StartTriggerScale(explosionSpreadTime));
	}
	protected void OnAnyTileDestroyedEvent(Match3Tile tile)
	{
		if(tile.GetType() == typeof(NormalTile))
		{
			tileColorCount[(int)tile.TileColor]--;
			tileTotalCount--;
			colorProbability[genericColorsIndexes[(int)tile.TileColor]] = 1f - (tileTotalCount == 0 ? 0f : tileColorCount[(int)tile.TileColor] / tileTotalCount);
		}
	}
예제 #14
0
 protected void OnAnyTileDestroyedEvent(Match3Tile tile)
 {
     if (tile.GetType() == typeof(NormalTile))
     {
         tileColorCount[(int)tile.TileColor]--;
         tileTotalCount--;
         colorProbability[genericColorsIndexes[(int)tile.TileColor]] = 1f - (tileTotalCount == 0 ? 0f : tileColorCount[(int)tile.TileColor] / tileTotalCount);
     }
 }
예제 #15
0
    public override void RaiseEventSwitchSuccess(Match3Tile neighborTile)
    {
        base.RaiseEventSwitchSuccess(neighborTile);

        //If this boardpiece is a dropperBehaviour
        if (BoardPiece.GetComponent <DropperBehaviour>() != null && !isDropping)
        {
            StartCoroutine(Drop());
        }
    }
    public void InitBombDestroyEffect(Match3Tile owner, Vector3 destroyTriggerPos)
    {
        effectOwner = owner;

        // Setup destroy trigger
        destroyTrigger.position = destroyTriggerPos;
        triggerListener         = destroyTrigger.gameObject.GetComponent <TilesTriggerListener>();

        StartCoroutine(StartTriggerScale(explosionSpreadTime));
    }
예제 #17
0
    protected void OnTileAttachedToBoardEvent(Match3Tile tile)
    {
//		Debug.LogError("[Spawner]++");
        if (tile.GetType() == typeof(NormalTile))
        {
            tileTotalCount++;
            tileColorCount[(int)tile.TileColor]++;
            colorProbability[genericColorsIndexes[(int)tile.TileColor]] = 1f - (tileTotalCount == 0 ? 0f : tileColorCount[(int)tile.TileColor] / tileTotalCount);
        }
    }
	protected void OnTileAttachedToBoardEvent(Match3Tile tile)
	{
//		Debug.LogError("[Spawner]++");
		if(tile.GetType() == typeof(NormalTile))
		{	
			tileTotalCount++;
			tileColorCount[(int)tile.TileColor]++;
			colorProbability[genericColorsIndexes[(int)tile.TileColor]] = 1f - (tileTotalCount == 0 ? 0f : tileColorCount[(int)tile.TileColor] / tileTotalCount);
		}
	}
//	public override void RaiseBoardFinishedSetupEvent ()
//	{
//		base.RaiseBoardFinishedSetupEvent();
//
//		BoardTilesInitializer initializer = new BoardTilesInitializer(Board);
//		initializer.Initialize();
//	}

    /// <summary>
    /// Setup the board tiles prefabs specified in the <see cref="tilesPrefabs"/> array,
    /// based on their type and color for quick access at run-time.
    /// </summary>
    public override void SetupBoardTiles()
    {
        tilesDictionary = new TilesDictionary();

        for (int i = 0; i < tilesPrefabs.Length; i++)
        {
            Match3Tile tile = tilesPrefabs[i].GetComponent <Match3Tile>();
            tilesDictionary[tile.GetType(), tile.TileColor] = tile;
        }
    }
예제 #20
0
	public override void RaiseEventSwitchSuccess (Match3Tile neighborTile)
	{
		base.RaiseEventSwitchSuccess (neighborTile);
		
		//If this boardpiece is a dropperBehaviour
		if (BoardPiece.GetComponent<DropperBehaviour>() != null && !isDropping)
		{
			StartCoroutine(Drop ());
		}
	}
예제 #21
0
	protected void OnTileDestroyed(Match3Tile tile)
	{
		foreach (DestroyTilesPair pair in destroyTiles) 
		{
			if (pair.type.GetType().IsInstanceOfType(tile) && tile.TileColor == pair.type.TileColor) {
				pair.current++;
			}
		}
		
		CheckWin();
	}
예제 #22
0
    protected void OnTileDestroyed(Match3Tile tile)
    {
        foreach (DestroyTilesPair pair in destroyTiles)
        {
            if (pair.type.GetType().IsInstanceOfType(tile) && tile.TileColor == pair.type.TileColor)
            {
                pair.current++;
            }
        }

        CheckWin();
    }
	public override void InitComponent () {
		base.InitComponent ();
		
		match3BoardRenderer = BoardRenderer as Match3BoardRenderer;
		numEffectsFinished = 0;
		winterchilOriginTile = this;
		
		tilesToDestroy.Clear();
		winterchillEffects.Clear();
		
	 	additionalChildAnimationComponent.Play(childIdleAnimationName);
	}
예제 #24
0
    public void OnTilesSwitchAnimFinished(AbstractBoardAnimations sender, AbstractTile srcTile, AbstractTile dstTile)
    {
//		Debug.Log("Switch anim finished!");
        // Update the board positions of the animated tiles (update the board logic after the animation finishes).
        boardData.SwitchTiles(srcTile, dstTile);

        Match3Tile srcMatch3Tile = srcTile as Match3Tile;
        Match3Tile dstMatch3Tile = dstTile as Match3Tile;

        bool foundMatches = matchesFinder.FindMatches();

        if ((!foundMatches || (!srcMatch3Tile.IsMatched && !dstMatch3Tile.IsMatched)) &&
            (srcMatch3Tile.SwitchBackOnMatchFail && dstMatch3Tile.SwitchBackOnMatchFail))
        {
            if (OnUserTilesSwitchBad != null)
            {
                OnUserTilesSwitchBad(srcMatch3Tile, dstMatch3Tile);
            }

            srcMatch3Tile.IsTileSwitching = true;
            dstMatch3Tile.IsTileSwitching = true;

            BoardAnimations.SwitchTilesAnim(false, srcMatch3Tile, dstMatch3Tile,
                                            (_sender, _srcTile, _dstTile) =>
            {
                boardData.SwitchTiles(_srcTile, _dstTile);
                _srcTile.IsTileSwitching = false;
                _dstTile.IsTileSwitching = false;
            }
                                            );

            srcMatch3Tile.RaiseEventSwitchBackOnFail(dstMatch3Tile);
            dstMatch3Tile.RaiseEventSwitchBackOnFail(srcMatch3Tile);
        }
        else if (srcMatch3Tile.IsMatched || dstMatch3Tile.IsMatched)
        {
            srcMatch3Tile.IsTileSwitching = false;
            dstMatch3Tile.IsTileSwitching = false;

            loseConditions.NewMove();

            srcMatch3Tile.RaiseEventSwitchSuccess(dstMatch3Tile);
            dstMatch3Tile.RaiseEventSwitchSuccess(srcMatch3Tile);
        }
        else if (!srcMatch3Tile.SwitchBackOnMatchFail || !dstMatch3Tile.SwitchBackOnMatchFail)
        {
            // Reset the "IsTileSwitching" property for tiles that don't switch back on match fail because they finished their switch animation.
            srcMatch3Tile.IsTileSwitching = false;
            dstMatch3Tile.IsTileSwitching = false;
        }

        DestroyLastFoundMatches();
    }
    /// <summary>
    /// Finds the first possible match. This is the main method from this class that needs to be called.
    /// </summary>
    /// <returns>
    /// The first possible match.
    /// </returns>
    public bool FindFirstPossibleMatch()
    {
        numFoundPossibleMatches = 0;
        lastFoundIsolatedTile   = null;

        foundPossibleMatch[0]   = foundPossibleMatch[1] = foundPossibleMatch[2] = null;
        foundPossibleMatchColor = TileColorType.None;

        ClearPartialMatchesBuffers();

        // Start searching for the first possible match
        Board.ApplyCancellableActionToAll(FindMatchingBoardPiecesAround);

        // Check if we previously found a possible match and store the result separatelly.
        if (foundPossibleMatchColor != TileColorType.None)
        {
            List <Match3Tile> foundPossibleMatchList = partialTileMatchesLists[(int)foundPossibleMatchColor];

//			if (debugEnabled) {
//				Debug.Log(Time.frameCount + " normal possible match found: ");
//			}

            for (int i = 0; i < 3; i++)
            {
                foundPossibleMatch[i] = foundPossibleMatchList[i];

//				if (debugEnabled) {
//					Debug.Log("Match tile: " + i + ": " + foundPossibleMatch[i]);
//				}
            }
            numFoundPossibleMatches = 3;

            return(true);
        }
        else if (triggerTileMatchFound.Count >= 2)
        {
//			if (debugEnabled) {
//				Debug.Log(Time.frameCount + " trigger tiles possible match found: ");
//			}
            for (int i = 0; i < triggerTileMatchFound.Count; i++)
            {
                foundPossibleMatch[i] = triggerTileMatchFound[i];
//				if (debugEnabled) {
//					Debug.Log("Match tile: " + i + ": " + foundPossibleMatch[i]);
//				}
            }
            numFoundPossibleMatches = triggerTileMatchFound.Count;

            return(true);
        }

        return(false);
    }
예제 #26
0
    public override void InitComponent()
    {
        base.InitComponent();

        match3BoardRenderer  = BoardRenderer as Match3BoardRenderer;
        numEffectsFinished   = 0;
        winterchilOriginTile = this;

        tilesToDestroy.Clear();
        winterchillEffects.Clear();

        additionalChildAnimationComponent.Play(childIdleAnimationName);
    }
	/// <summary>
	/// Finds the first possible match. This is the main method from this class that needs to be called.
	/// </summary>
	/// <returns>
	/// The first possible match.
	/// </returns>
	public bool FindFirstPossibleMatch() 
	{
		numFoundPossibleMatches = 0;
		lastFoundIsolatedTile = null;

		foundPossibleMatch[0] = foundPossibleMatch[1] = foundPossibleMatch[2] = null;
		foundPossibleMatchColor = TileColorType.None;
				
		ClearPartialMatchesBuffers();
		
		// Start searching for the first possible match
		Board.ApplyCancellableActionToAll(FindMatchingBoardPiecesAround);
		
		// Check if we previously found a possible match and store the result separatelly.
		if (foundPossibleMatchColor != TileColorType.None)
		{
			List<Match3Tile> foundPossibleMatchList = partialTileMatchesLists[(int)foundPossibleMatchColor];
			
//			if (debugEnabled) {
//				Debug.Log(Time.frameCount + " normal possible match found: ");
//			}
			
			for(int i = 0; i < 3; i++) {
				foundPossibleMatch[i] = foundPossibleMatchList[i];
				
//				if (debugEnabled) {
//					Debug.Log("Match tile: " + i + ": " + foundPossibleMatch[i]);
//				}
			}
			numFoundPossibleMatches = 3;
			
			return true;
		}
		else if (triggerTileMatchFound.Count >= 2)
		{
//			if (debugEnabled) {
//				Debug.Log(Time.frameCount + " trigger tiles possible match found: ");
//			}
			for(int i = 0; i < triggerTileMatchFound.Count; i++) {
				foundPossibleMatch[i] = triggerTileMatchFound[i];
//				if (debugEnabled) {
//					Debug.Log("Match tile: " + i + ": " + foundPossibleMatch[i]);
//				}
			}
			numFoundPossibleMatches = triggerTileMatchFound.Count;
			
			return true;
		}
		
		return false;
	}
    public Match3Tile SpawnSpecificTile(System.Type tileType, TileColorType prefabDefaultColor, bool isBoardSetup = false)
    {
        Match3Tile newTile = (Instantiate(tilesDictionary[tileType, prefabDefaultColor].gameObject) as GameObject).GetComponent <Match3Tile>();

        newTile.cachedTransform.parent = cachedTransform;
        newTile.BoardRenderer          = this;

        if (!isBoardSetup)
        {
            newTile.InitComponent();
        }

        return(newTile);
    }
    public Match3BoardPiece AttachTileToBoardAt(int rowIdx, int columnIdx, Match3Tile tile, bool offBoardTile, bool isBoardSetup = false, bool resetTilePosition = true)
    {
        // Assign the tile to the specified BoardPiece.
        Match3BoardPiece targetBoardPiece = Board[rowIdx, columnIdx] as Match3BoardPiece;

        if (isBoardSetup)
        {
            targetBoardPiece.TileRef = tile;
        }
        else
        {
            targetBoardPiece.Tile = tile;

//			if (targetBoardPiece.BottomLink != null && targetBoardPiece.BottomLink.Tile != null && targetBoardPiece.BottomLink.Tile.IsMoving) {
//				Match3Tile nextTile = targetBoardPiece.BottomLink.Tile as Match3Tile;
//				newTile.moveVel = Mathf.Clamp(nextTile.moveVel - newTile.initialVel, -newTile.initialVel, newTile.maxVel);
//			}
        }

        if (resetTilePosition)
        {
            targetBoardPiece.ResetTilePosition();
        }

//		if (offBoardTile)
//		{
//			Match3BoardPiece bottomLinkPiece = targetBoardPiece.BottomLink;
//			Vector3 tileLocalPos = newTile.LocalPosition;
//
//			if (bottomLinkPiece != null && bottomLinkPiece.Tile != null && bottomLinkPiece.LocalPosition.y < bottomLinkPiece.Tile.LocalPosition.y)
//			{
//				tileLocalPos.y = bottomLinkPiece.Tile.LocalPosition.y + verticalTileDistance + verticalTileOffset;
//			}
//			else {
//				tileLocalPos.y = targetBoardPiece.LocalPosition.y + verticalTileDistance + verticalTileOffset;
//			}
//
//			newTile.LocalPosition = tileLocalPos;
//
////			Debug.LogWarning("Spawning offboard tile at : " + tileLocalPos);
//			//Debug.Break();
//		}

        if (!isBoardSetup && !offBoardTile)
        {
            tile.InitAfterAttachedToBoard();
        }

        return(targetBoardPiece);
    }
    public Match3Tile SpawnSpecificTileAt(int rowIdx, int columnIdx, System.Type tileType, TileColorType prefabDefaultColor, bool offBoardTile = false, bool isBoardSetup = false)
    {
//		Debug.LogWarning("[SpawnSpecificTileAt] " + tileType.ToString() + " " + prefabDefaultColor);

        // Spawn the specified tile
        Match3Tile newTile = SpawnSpecificTile(tileType, prefabDefaultColor, isBoardSetup);

        newTile.name = string.Format("[{0},{1}] {2}", rowIdx, columnIdx, newTile.name);

        // Assign the tile to the specified BoardPiece.
        AttachTileToBoardAt(rowIdx, columnIdx, newTile, offBoardTile, isBoardSetup);

        return(newTile);
    }
    public override void OnInspectorGUI()
    {
        Match3Tile e = (Match3Tile)target;

        serializedObject.Update();
        DrawSpritePreview(normalSprite, tile.normalSprite);
        DrawSpritePreview(hoverSprite, tile.hoverSprite);
        e.traits = (TraitsOfTile)EditorGUILayout.EnumFlagsField(e.traits);

        EditorGUILayout.PropertyField(color);
        // EditorGUILayout.PropertyField(flags);
        EditorGUILayout.PropertyField(colliderType);

        serializedObject.ApplyModifiedProperties();
    }
예제 #32
0
	public Match3Tile this[System.Type tileType, TileColorType tileColor] {
		get {
			return tilesDictionary[tileType][(int)tileColor];
		}
		
		set {
			Match3Tile[] tiles;
			if (tilesDictionary.TryGetValue(tileType, out tiles) == false) {
				tiles = new Match3Tile[(int)TileColorType.Count];
			}
			
			tiles[(int)tileColor] = value;
			tilesDictionary[tileType] = tiles;
		}
	}
예제 #33
0
 public void GetPositionsOfRocks(MapDimentions mapDimentions, Tilemap tilemap)
 {
     for (int i = 0; i < mapDimentions.width; i++)
     {
         for (int j = 0; j < mapDimentions.height; j++)
         {
             Vector3Int pos = new Vector3Int(i, j, 0);
             Match3Tile m3  = tilemap.GetTile <Match3Tile>(pos);
             if (m3 && m3.traits.IsRock())
             {
                 this.SetPositionOfRock(pos);
             }
         }
     }
 }
예제 #34
0
    public override void RaiseEventTileSwitchAnimEnded(AbstractTile neighborTile)
    {
        // Check if this directional tile was combined with a BombTile.

        // isCombineWithBombEffect flag check was added to remove some unwanted behaviors where (2x bomb/directional effects would spawn)
        // TODO: Investigate further into why this is happening.

        if (neighborTile is BombTile && !isCombineWithBombEffect)
        {
            Match3BoardGameLogic.Instance.loseConditions.NewMove();

            StartCoroutine(StartCombineWithBombEffect(neighborTile as BombTile));
        }

        // Setup directional with directional tile combine effect.
        if (neighborTile is DirectionalDestroyTile && TappedFirst)
        {
            Match3BoardGameLogic.Instance.loseConditions.NewMove();

            IsDestroying = true;
            neighborTile.IsDestroying = true;

            Match3Tile crossTile = match3BoardRenderer.SpawnSpecificTileAt(BoardPiece.BoardPosition.row,
                                                                           BoardPiece.BoardPosition.col,
                                                                           typeof(CrossDestroyTile),
                                                                           TileColorType.None
                                                                           );
            crossTile.TileColor = TileColor;
            crossTile.DisableTileLogic();
            (crossTile as DirectionalDestroyTile).UpdateMaterial();

            if (neighborTile.BoardPiece.Tile == neighborTile)
            {
                neighborTile.BoardPiece.Tile = null;
            }

            Destroy(neighborTile.gameObject);
            Destroy(gameObject);
        }

        if (neighborTile is ColorBombTile && TappedFirst)
        {
            Match3BoardGameLogic.Instance.loseConditions.NewMove();
        }

        // In the base classes "movedByInput" and "tappedFirst" flags are reset so we call the base at the end of the overriden code.
        base.RaiseEventTileSwitchAnimEnded(neighborTile);
    }
예제 #35
0
    protected void SpawnNewTileInQueue(TileSpawnRule spawnRule)
    {
        Match3Tile newTile = spawnRule.SpawnNewTile();

        newTile.LocalPosition = spawnPoint;

        // Deactivate and hide the tile until the spawn queue is processed.
        newTile.gameObject.SetActive(false);

        spawnQueue.Enqueue(newTile);

        if (!isSpawnQueueUpdating)
        {
            StartCoroutine(ProcessSpawnQueue());
        }
    }
예제 #36
0
    public Match3Tile this[System.Type tileType, TileColorType tileColor] {
        get {
            return(tilesDictionary[tileType][(int)tileColor]);
        }

        set {
            Match3Tile[] tiles;
            if (tilesDictionary.TryGetValue(tileType, out tiles) == false)
            {
                tiles = new Match3Tile[(int)TileColorType.Count];
            }

            tiles[(int)tileColor]     = value;
            tilesDictionary[tileType] = tiles;
        }
    }
예제 #37
0
	public static void OnDrawGizmos(Match3Tile tile, GizmoType gizmoType) {
		if ( !tile.canDrawGizmos || !tilesDebugDisplayOverride) {
			return;
		}
		
		string tileStates = "";
		
		if (tile.IsMoving) {
			tileStates = AppendState(tileStates, "M, ", maxStatesLength);
		}
		if (tile.IsDestroying) {
			tileStates = AppendState(tileStates, "D, ", maxStatesLength);
		}
		if (tile.debugPassiveGravity) {
			tileStates = AppendState(tileStates, "Pg, ", maxStatesLength);
		}
		if (tile.debugActiveGravity) {
			tileStates = AppendState(tileStates, "Ag, ", maxStatesLength);
		}
		if (tile.BoardPiece != null && !tile.HasReachedBoardPieceArea()) {
			tileStates = AppendState(tileStates, "Bd, ", maxStatesLength);
		}
		
		tileStates = tileStates.Trim();
		
		if (labelStyle == null) {
			labelStyle = new GUIStyle();
			labelStyle.normal.textColor = Color.yellow;
			labelStyle.fontSize = 14;
			labelStyle.normal.background = MakeTex(2, 2, Color.black);
		}
		
		Handles.Label(tile.transform.position +  new Vector3(-tile.collider.bounds.extents.x, tile.collider.bounds.extents.y, 0f), 
					  tileStates, labelStyle);
		
		Matrix4x4 pushedMatrix = Gizmos.matrix;
		if (tile.transform.parent != null) {
			Gizmos.matrix = tile.transform.parent.localToWorldMatrix;
		}
		
		Gizmos.color = Color.green;
		Gizmos.DrawWireSphere(tile.fallDestination, 0.25f);
		
		if (tile.transform.parent != null) {
			Gizmos.matrix = pushedMatrix;
		}
	}	
	void OnTileDestroyed(Match3Tile tile) 
	{
		timeNextLook = Random.Range(timeBetweenPowerLooks.x, timeBetweenPowerLooks.y);
		timeNextWave = Random.Range(timeBetweenWaves.x, timeBetweenWaves.y);
		
		if ((tile is ColorBombTile) && timeNextHappyBig <= 0) {
			if (NewSystem) {
				HappyFaceBig();
			}
			else {
				HappyFace();
			}
		}
		else if (((tile is BombTile) || (tile is DirectionalDestroyTile)) && timeNextHappy <= 0f) {
			HappyFace();
		}
	}
예제 #39
0
    protected void SelectAndDestroyTiles()
    {
        ActuallyUsingItem();

        List <Match3BoardPiece>  allBoardPiecesWithTiles = new List <Match3BoardPiece>();
        List <LayeredBoardPiece> frostedBoardPieces      = new List <LayeredBoardPiece>();

        boardLogic.boardData.ApplyActionToAll((boardPiece) => {
            Match3Tile tile = boardPiece.Tile as Match3Tile;
            if (tile != null && !tile.IsMoving && tile.IsDestructible && !tile.IsDestroying && !(tile as NormalTile).IsFrozen())
            {
                allBoardPiecesWithTiles.Add(boardPiece as Match3BoardPiece);
            }

            LayeredBoardPiece frostPiece = (boardPiece as LayeredBoardPiece);
            if (frostPiece != null && frostPiece.NumLayers > 0)
            {
                frostedBoardPieces.Add(frostPiece);
            }
        });

        while (targetBoardPieces.Count < destroyTiles)
        {
            int index;
            if (frostedBoardPieces.Count > 0)
            {
                index = Random.Range(0, frostedBoardPieces.Count);
                targetBoardPieces.Add(frostedBoardPieces[index]);
                frostedBoardPieces.RemoveAt(index);
            }
            else if (allBoardPiecesWithTiles.Count > 0)
            {
                index = Random.Range(0, allBoardPiecesWithTiles.Count);
                targetBoardPieces.Add(allBoardPiecesWithTiles[index]);
                allBoardPiecesWithTiles.RemoveAt(index);
            }
            else
            {
                break;                 // REALLY? THERE AREN'T 3 TILES ON THE BOARD? WHAT HAS THE WORLD COME TO?!?! CURSE YOU CANDY CRUSH SAGA!!!
            }
        }

        StartCoroutine(DestroyStuff());
    }
예제 #40
0
    public override void RaiseEventTileSwitchAnimBegan(Match3Tile _neighborTile)
    {
        base.RaiseEventTileSwitchAnimBegan(_neighborTile);

        //One of the few cases were the color bomb swipe is invalid and a switchback is required
        if (!lastNeighborTile.IsDestructible)
        {
            SwitchBackOnMatchFail = true;
            return;
        }

        destroyColor = lastNeighborTile.TileColor;

        // Disable colliders for this tile and it's neighbor tile if the neighbor is a ColorBomb tile.
        // Because these will do a combine effect and they shouldn't be picked up by other destroy sensors in the meantime.
        if (lastNeighborTile is ColorBombTile)
        {
            DisableTileLogic();
            lastNeighborTile.DisableTileLogic();
        }

        // Cached the "TappedFirst" property here for this tile because it will be reset in "RaiseEventTileSwitchAnimEnded" event.
        wasFirstTapped = TappedFirst;

        if (lastNeighborTile is DirectionalDestroyTile)
        {
            lastNeighborTile.CanBeMatched = false;
        }

        if (lastNeighborTile is BombTile)
        {
            lastNeighborTile.CanBeMatched = false;
        }

        if (_neighborTile.GetType() == typeof(NormalTile) /* && wasFirstTapped*/)
        {
            (_neighborTile as NormalTile).CanBeMatched = false;
            if (!wasFirstTapped)
            {
                Match3BoardGameLogic.Instance.loseConditions.NewMove();
            }
        }
    }
예제 #41
0
    protected void CheckMatch(Match3Tile currentTile, ref Match3Tile targetTile, bool isVerticalPass)
    {
//		Debug.Log("Current tile: " + currentTile + "\n" + "targetTile: " + targetTile);
        if (targetTile == null || !targetTile.CanBeMatched)
        {
            // If there is no target tile to check matches with yet, try to set the currentTile as the targetTile and
            // get back to the loop so we can move to the next tile to compare it with the new targetTile.
            if (currentTile != null && currentTile.CanBeMatched)
            {
                targetTile = currentTile;
                if (matchesBatch.Count > 0)
                {
                    matchesBatch.Clear();
                }
                matchesBatch.Add(targetTile);
            }
        }
        else if (currentTile != null && currentTile.IsMatchWith(targetTile))
        {
            // If we found a matching tile with the targetTile add it to our temporary matches buffer.
            matchesBatch.Add(currentTile);
        }
        else
        {
            // If we found a tile different from the targetTile then we finished collecting tiles for the current batch and
            // we must check if we found at least 3 to add to our final "lastFoundMatches" result.
            // We also make the current tile the new targetTile because it belongs in a different batch of matches.
            targetTile = currentTile;
            if (matchesBatch.Count >= 3)
            {
                CollectNewFoundMatches(matchesBatch, isVerticalPass);
            }
            // Clear the current temporary matches buffer.
            matchesBatch.Clear();

            // We check here if the new target tile can be matched then we already add it to the new batch of matches.
            if (targetTile != null && targetTile.CanBeMatched)
            {
                matchesBatch.Add(currentTile);
            }
        }
    }
	public void SwitchTilesAnim(bool canRaiseGlobalSwitchEvent, Match3Tile src, Match3Tile dst, System.Action<Match3BoardAnimations, Match3Tile, Match3Tile> onAnimFinished = null) {
//		Debug.Log("[" + this.GetType().Name + "] SwitchTilesAnim " + src.name + " -> " + dst.name);
		src.IsMoving = true;
		dst.IsMoving = true;
		
		src.GravityEnabled = false;
		dst.GravityEnabled = false;
		
		//TODO: use a Tweener object pool and a TweenParams object pool for performance reasons
		Tweener srcToDstAnim = HOTween.To(src.cachedTransform, tileSwitchAnimDelay, 
											new TweenParms().Prop("localPosition", dst.BoardPiece.LocalPosition)
											.Ease(EaseType.EaseInSine)
										 );
		Tweener dstToSrcAnim = HOTween.To(dst.cachedTransform, tileSwitchAnimDelay, 
											new TweenParms().Prop("localPosition", src.BoardPiece.LocalPosition)
											.Ease(EaseType.EaseInSine)
										 );

		dstToSrcAnim.ApplyCallback(CallbackType.OnComplete, () => 
		{
			// Call a single registered custom method when the tile switch animation finishes. (without registering it for future callbacks)
			if (onAnimFinished != null) {
				onAnimFinished(this, src, dst);
			} 
				
			// Notify any registered methods of this event.
			RaiseEventTilesSwitchAnimFinished(canRaiseGlobalSwitchEvent, this, src, dst);
			
			src.RaiseEventTileSwitchAnimEnded(dst);
			dst.RaiseEventTileSwitchAnimEnded(src);
		});
		
		src.RaiseEventTileSwitchAnimBegan(dst);
		dst.RaiseEventTileSwitchAnimBegan(src);
		
//		srcToDstAnim.Play();
//		dstToSrcAnim.Play();
	}
예제 #43
0
	public void OnNewBoardPieceSelected(AbstractBoardPiece boardPiece, CustomInput.TouchInfo touchInfo)
	{
		if(BoardShuffleController.Instance.IsBoardReshuffling)
		{
			return;
		}
		
		bool selectionSucces = false;
		
		selectedBoardPiece = boardPiece;
		tileToDestroy = boardPiece.Tile as Match3Tile;
		effectPosition = boardPiece.cachedTransform;

		//Decide wether this selection is icepick worthy or not
		if(boardPiece.Tile == null)
		{
			if(boardPiece is LayeredBoardPiece && (boardPiece as LayeredBoardPiece).NumLayers > 0 )
			{
				selectionSucces = true;
			}
		}
		else if (!tileToDestroy.IsMoving && tileToDestroy.IsDestructible && !tileToDestroy.IsDestroying && !(tileToDestroy as NormalTile).IsFrozen()) 
		{
			selectionSucces = true;
		}
		
		if(selectionSucces)
		{
			SoundManager.Instance.PlayOneShot("icepick_sfx");
			
			touchController.StopInputController();
			touchController.OnNewBoardPieceSelected -= OnNewBoardPieceSelected;
			
			StartItemEffects();
		}
	}
예제 #44
0
	protected void CheckMatch(Match3Tile currentTile, ref Match3Tile targetTile, bool isVerticalPass) 
	{
//		Debug.Log("Current tile: " + currentTile + "\n" + "targetTile: " + targetTile);
		if ( targetTile == null || !targetTile.CanBeMatched ) 
		{
			// If there is no target tile to check matches with yet, try to set the currentTile as the targetTile and 
			// get back to the loop so we can move to the next tile to compare it with the new targetTile.
			if (currentTile != null && currentTile.CanBeMatched) 
			{
				targetTile = currentTile;
				if (matchesBatch.Count > 0) {
					matchesBatch.Clear();
				}
				matchesBatch.Add(targetTile);
			}
		} else if (currentTile != null && currentTile.IsMatchWith(targetTile)) {
			// If we found a matching tile with the targetTile add it to our temporary matches buffer.
			matchesBatch.Add(currentTile);
		} else {
			// If we found a tile different from the targetTile then we finished collecting tiles for the current batch and
			// we must check if we found at least 3 to add to our final "lastFoundMatches" result.
			// We also make the current tile the new targetTile because it belongs in a different batch of matches.
			targetTile = currentTile;
			if (matchesBatch.Count >= 3) {
				CollectNewFoundMatches(matchesBatch, isVerticalPass);
			}
			// Clear the current temporary matches buffer.
			matchesBatch.Clear();
			
			// We check here if the new target tile can be matched then we already add it to the new batch of matches.
			if (targetTile != null && targetTile.CanBeMatched) {
				matchesBatch.Add(currentTile);
			}
		}		
	}
	public Match3BoardPiece AttachTileToBoardAt(int rowIdx, int columnIdx, Match3Tile tile, bool offBoardTile, bool isBoardSetup = false, bool resetTilePosition = true) 
	{
		// Assign the tile to the specified BoardPiece.
		Match3BoardPiece targetBoardPiece = Board[rowIdx, columnIdx] as Match3BoardPiece;
		
		if (isBoardSetup) {
			targetBoardPiece.TileRef = tile;
		}
		else 
		{
			targetBoardPiece.Tile = tile;
			
//			if (targetBoardPiece.BottomLink != null && targetBoardPiece.BottomLink.Tile != null && targetBoardPiece.BottomLink.Tile.IsMoving) {
//				Match3Tile nextTile = targetBoardPiece.BottomLink.Tile as Match3Tile;
//				newTile.moveVel = Mathf.Clamp(nextTile.moveVel - newTile.initialVel, -newTile.initialVel, newTile.maxVel);
//			}
		}
		
		if (resetTilePosition) {
			targetBoardPiece.ResetTilePosition();
		}
		
//		if (offBoardTile) 
//		{
//			Match3BoardPiece bottomLinkPiece = targetBoardPiece.BottomLink;
//			Vector3 tileLocalPos = newTile.LocalPosition;
//			
//			if (bottomLinkPiece != null && bottomLinkPiece.Tile != null && bottomLinkPiece.LocalPosition.y < bottomLinkPiece.Tile.LocalPosition.y) 
//			{
//				tileLocalPos.y = bottomLinkPiece.Tile.LocalPosition.y + verticalTileDistance + verticalTileOffset;
//			}
//			else {
//				tileLocalPos.y = targetBoardPiece.LocalPosition.y + verticalTileDistance + verticalTileOffset;
//			}
//			
//			newTile.LocalPosition = tileLocalPos;
//
////			Debug.LogWarning("Spawning offboard tile at : " + tileLocalPos);
//			//Debug.Break();
//		}
		
		if ( !isBoardSetup && !offBoardTile ) {
			tile.InitAfterAttachedToBoard();
		}
		
		return targetBoardPiece;
	}
	public override void RaiseEventTileSwitchAnimBegan (Match3Tile neighborTile) {
		base.RaiseEventTileSwitchAnimBegan(neighborTile);
		
		if (neighborTile is BombTile) 
		{
			BombTile neighborBomb = neighborTile as BombTile;
			// Mark this tile and it's neighbor as moving and without any gravity because there will be a custom animation on them 
			// to try and keep things consistent.
			neighborBomb.DisableTileLogic();
			DisableTileLogic();

			// Prepare the bigger directional destroy effect on this directional tile.
			prefabTilesDestroyEffect = prefabBombCombineDestroyEffect;
		}
		
		if (neighborTile is DirectionalDestroyTile) 
		{
			DirectionalDestroyTile directionalTile = neighborTile as DirectionalDestroyTile;
			directionalTile.SwitchBackOnMatchFail = false;
			SwitchBackOnMatchFail = false;

			CanBeMatched = false;
			(neighborTile as NormalTile).CanBeMatched = false;
		}
	}
예제 #47
0
	/// <summary>
	/// Raises the tile switch animation begin event when this tile starts the switch animation with another neighbour tile.
	/// This event should be raised by the <see cref="Match3BoardGameLogic"/>.
	/// </summary>
	/// <param name='neighborTile'>
	/// Neighbour tile with which this tile does the switch.
	/// </param>
	public virtual void RaiseEventTileSwitchAnimBegan(Match3Tile neighborTile) {
		
	}
	protected IEnumerator ProcessSpawnQueue() 
	{
		Match3Tile nextTile = null;
		Vector3 tileLocalPos = Vector3.zero;
		
		isSpawnQueueUpdating = true;
		
		while(spawnQueue.Count > 0)
		{			
			nextTile = spawnQueue.Peek();
										
			if (boardPiece.Tile == null)
			{				
				if (lastSpawnedTile == null || lastSpawnedTile.LocalPosition.y <= boardPiece.LocalPosition.y)
				{
					if (lastSpawnedTile != null && lastSpawnedTile.LocalPosition.y >= (boardPiece.LocalPosition.y - Match3BoardRenderer.halfVertTileDistance))
					{
						nextTile.gameObject.SetActive(true);

						nextTile.moveVel = Mathf.Clamp(lastSpawnedTile.moveVel - nextTile.initialVel, 0f, nextTile.maxVel);

						tileLocalPos = nextTile.LocalPosition;
						tileLocalPos.y = lastSpawnedTile.LocalPosition.y + Match3BoardRenderer.vertTileDistance;

						nextTile.LocalPosition = tileLocalPos;
					}
					else
					{
						nextTile.gameObject.SetActive(true);
						nextTile.LocalPosition = spawnPoint;
					}
					
					Match3BoardRenderer.Instance.AttachTileToBoardAt(boardPiece, nextTile, false, false, false);
					lastSpawnedTile = spawnQueue.Dequeue();
				}

			}
			
			yield return null;
		}
		
		isSpawnQueueUpdating = false;
	}
예제 #49
0
	public virtual void RaiseEventSwitchBackOnFail(Match3Tile neighborTile) {
		
	}
	protected IEnumerator StartCombineWithBombEffect(BombTile neighborBombTile) {
		
		Match3Tile nextToEffectOriginTile;
//		TileColorType movedTileColor;
		
		IsDestroying = true;
		neighborBombTile.IsDestroying = true;
		
		if (OnDirectionalBombCombine != null) {
			OnDirectionalBombCombine(this);
		}
		
		isCombineWithBombEffect = true;
		
		if ( !TappedFirst ) {
			// Do the combo destroy effect from the other tiles world position because that one was moved by input.
			winterchilOriginTile = neighborBombTile;
			nextToEffectOriginTile = this;

		} else {
			nextToEffectOriginTile = neighborBombTile;
		}

		// Spawn the combined tile effect (an enlarging cross directional tile that builds up and the destroys itself)
		CrossBombCombineVisualEffect combinedTileEffect = (Instantiate(prefabBombCombinedTileEffect) as GameObject).GetComponent<CrossBombCombineVisualEffect>();
		combinedTileEffect.InitComponent();
		
		// Bring this giant tile in the front
		combinedTileEffect.cachedTransform.position = winterchilOriginTile.WorldPosition - Vector3.forward * 0.5f;
		// Set the delay between the horizontal and vertical direction destroy effect.
		delayBetweenCrossDirections = combinedTileEffect.horizontalAnimTime;
		
		HOTween.To(nextToEffectOriginTile.cachedTransform, 0.2f, new TweenParms()
											  							  .Prop("localPosition", winterchilOriginTile.LocalPosition)
																		  .Prop("localScale", Vector3.zero));
		
		bombCombineEffectColumn = winterchilOriginTile.BoardPiece.BoardPosition.col;
		
		yield return new WaitForSeconds(0.2f);
		
		neighborBombTile.gameObject.SetActive(false);
		
		// Disable the default visual effect for this directional tile because we're doing a special combine effect.
		useDestroyEffect = false;
		
		StartCoroutine(DelayedTileRelease(0.1f));
		
		// Destroy the cross tile effect after a delay.
		GameObject.Destroy(combinedTileEffect.gameObject, combinedTileEffect.totalAnimTime);		

		SetVerticalColumnsLock(bombCombineEffectColumn, true);
		
		canDestroyBaseTileAfterWinterchill = false;
		
		direction = Direction.Horizontal;
		StartDirectionalDestroy(() => 
		{
			canDestroyBaseTileAfterWinterchill = true;
			direction = Direction.Vertical;
			StartDirectionalDestroy();
					
			if(neighborBombTile.BoardPiece)
			{
				neighborBombTile.BoardPiece.Tile = null;
			}
			
			GameObject.Destroy(neighborBombTile.gameObject, 0.2f);
		});
	}
예제 #51
0
	public virtual void RaiseEventSwitchSuccess(Match3Tile neighborTile) {  }
예제 #52
0
	public bool TryPossibleMatchMove() 
	{
		// Knowing the isolated tile, determine the target coord where the isolated tile needs to be moved to make the match.
		Match3Tile[] lastFoundMatch = possibleMatchFinder.foundPossibleMatch;
		Match3Tile[] otherMatchTiles = new Match3Tile[2];
		int j = 0;
		
		// Determine the other 2 tiles (non-isolated) in the "otherMatchTile" array.
		for(int i = 0; i < possibleMatchFinder.numFoundPossibleMatches; i++) 
		{
			if (lastFoundMatch[i] != possibleMatchFinder.lastFoundIsolatedTile)
			{
				//TODO: for some reason an instance becomes null here, but in the same frame inside the possible matches finder it's not null.
				//That's why i've put this safety check here.
				if (lastFoundMatch[i] == null) {
					return false;
				}
				otherMatchTiles[j++] = lastFoundMatch[i];
			}
		}
		
		// Determine the board coord where the isolated tile must move to match.
		BoardCoord isolatedTargetPos = possibleMatchFinder.lastFoundIsolatedTile.BoardPiece.BoardPosition;
//		Debug.Log(Time.frameCount + " otherMatchTiles[0] = " + otherMatchTiles[0]);
//		Debug.Log(Time.frameCount + " otherMatchTiles[1] = " + otherMatchTiles[1]);
//		Debug.Log(Time.frameCount + " lastFoundIsolatedTile = " + possibleMatchFinder.lastFoundIsolatedTile);
		
		BoardCoord otherTilesOffset;
		if (j == 1) {
			// When 2 special trigger tiles are found as a possible match, there is only 1 other tile besides the "isolated" tile in that match.
			otherTilesOffset = isolatedTargetPos - otherMatchTiles[0].BoardPiece.BoardPosition;
		} else {
			otherTilesOffset = otherMatchTiles[0].BoardPiece.BoardPosition - otherMatchTiles[1].BoardPiece.BoardPosition;
		}
		
		if (otherTilesOffset.row == 0) {
			// Check if the isolated tile is already on the same row, then we have to target the col. by recalculating the offset between the columns.
			if (possibleMatchFinder.lastFoundIsolatedTile.BoardPiece.BoardPosition.row == otherMatchTiles[0].BoardPiece.BoardPosition.row) 
			{
				int colOffset = otherMatchTiles[0].BoardPiece.BoardPosition.col - possibleMatchFinder.lastFoundIsolatedTile.BoardPiece.BoardPosition.col;
				colOffset = Mathf.Clamp(colOffset, -1, 1);
				isolatedTargetPos.col += colOffset;
			}
			else {				
				isolatedTargetPos.row = otherMatchTiles[0].BoardPiece.BoardPosition.row;
			}
		}
		else 
		{
			// Check if the isolated tile is already on the same column, then we have to target the row by recalculating the offset between the rows.
			if (possibleMatchFinder.lastFoundIsolatedTile.BoardPiece.BoardPosition.col == otherMatchTiles[0].BoardPiece.BoardPosition.col) 
			{
				int rowOffset = otherMatchTiles[0].BoardPiece.BoardPosition.row - possibleMatchFinder.lastFoundIsolatedTile.BoardPiece.BoardPosition.row;
				rowOffset = Mathf.Clamp(rowOffset, -1, 1);
				isolatedTargetPos.row += rowOffset;
			}
			else {
				isolatedTargetPos.col = otherMatchTiles[0].BoardPiece.BoardPosition.col;
			}
		}
		
		Match3BoardPiece targetPiece = gameLogic.boardData[isolatedTargetPos] as Match3BoardPiece;
		if (TileSwitchInput.Instance.IsEnabled && targetPiece != null && targetPiece.Tile != null && targetPiece.Tile.IsUserMoveable) 
		{
			// Try to move the isolated tile to make the match.
			if ( !gameLogic.TryToMoveTile(possibleMatchFinder.lastFoundIsolatedTile, targetPiece.Tile) ) 
			{
				// If for some reason we failed the above move, try a random move.
				if ( !useOnlyPossibleMoves ) 
				{
					if ( TryRandomMoveAround(possibleMatchFinder.lastFoundIsolatedTile.BoardPiece as Match3BoardPiece) ) {
						return true;
					}
				}
				else {
					return false;
				}
			}
			else {
				// Possible match successed
				return true;
			}
		}
		
		return false;
	}
	protected bool HasFoundPossibleMatchForColor(TileColorType tileColor)
	{
		int lastTriggerTileIdx = triggerTileMatchFound.Count - 1;
		
		// Check first if we found at least 2 trigger tiles that can be combined.
		// If thereis a ColorBomb in this list then it can be combined with any user moveable tile(ex:NormalTile) or any other trigger tile.
		if (triggerTileMatchFound.Count >= 2)
		{
			lastFoundIsolatedTile = triggerTileMatchFound[lastTriggerTileIdx];
//			Debug.LogWarning("[PossibleMatchesFinder] lastFoundIsolatedTile = " + lastFoundIsolatedTile);

			return true;
		}	
		
		// Check if we found a possible match.
		if (partialTileMatchesLists[(int)tileColor].Count == 3) 
		{
			List<Match3Tile> isolatedTiles = isolatedTilesLists[(int)tileColor];
			lastFoundIsolatedTile = null;
			
			// Usually in the isolated tiles list for a certain tile color, only one tile is left because the other 2 are adjacent.
			// In case there are more than 1 tiles left (usually all 3 are left) is because it means that none of them is adjacent to the other
			// and we have to see which 2 tiles are collinear (are on the same line horizontal/vertical) so we know that the 3rd tile is isolated.
			if (isolatedTiles.Count > 1) 
			{
				// Search the 2 tiles that are collinear and mark them null so the list is left only with the isolated tile.
				for(int i = 0; i < isolatedTiles.Count - 1; i++) 
				{
					Match3Tile tile = isolatedTiles[i];
					for(int j = i + 1; j < isolatedTiles.Count; j++)
					{
						Match3Tile other = isolatedTiles[j];
						if ( tile.BoardPiece.IsCollinearWith(other.BoardPiece) )  {
							// We found the 2 (and only possible) collinear tiles.
							// Mark them as null so we are left only with the isolated tile. Don't remove them because it's slower in this case.
							isolatedTiles[i] = null;
							isolatedTiles[j] = null;
							goto FinishedSearch;
						}
					}
				}
				
			FinishedSearch:
				// Find the remaining isolated tile
				for(int i = 0; i < isolatedTiles.Count; i++) 
				{
					if (isolatedTiles[i] != null) {
						lastFoundIsolatedTile = isolatedTiles[i];
						break;
					}
				}
			} 
			else {
				lastFoundIsolatedTile = isolatedTiles[0];
			}
			
			// Validate the isolated tile for this possible match group.
			if (lastFoundIsolatedTile == null) 
			{
//				Debug.LogWarning("[PossibleMatchesFinder] For some reason the isolated tile wasn't found for a possible match! This shouldn't happen!");
//				for(int i = 0; i < partialTileMatchesLists[(int)tileColor].Count; i++) 
//				{
//					Debug.LogWarning(partialTileMatchesLists[(int)tileColor][i].name + ", ");
//				}
			} 
			else if ( !lastFoundIsolatedTile.IsUserMoveable )
			{
				// This tile is not user moveable. This possible match group is not valid.
				ClearPartialMatchesBuffers();
				
				return false;
			}
			
//			isolatedTile.cachedTransform.localScale *= 1.25f;
//			Debug.Log("[PossibleMatchesFinder] The valid isolated tile is: " + lastFoundIsolatedTile.name);
			
			// Store the color type of the possible match. Stop the search here.
			foundPossibleMatchColor = tileColor;
//			Debug.LogWarning("We found a possible match: " +  foundPossibleMatchColor);

			return true;
		}
		
		return false;
	}
	/// <summary>
	/// Adds a new tile to the possible matches list corresponding to this new tile's color and determine if 
	/// this tile is a possible isolated tile in a list of possible matches.
	/// An isolated tile in a possible match is the tile that can be moved to complete the match (this tile must be user moveable and matchable).
	/// </summary>
	/// <param name='newTile'>
	/// The new found tile.
	/// </param>
	protected void AddNewPossibleMatchTile(Match3Tile newTile)
	{
		int lastTriggerTileIdx = triggerTileMatchFound.Count - 1;
		
		// If the last trigger tile added was a ColorBomb the it can match with this new tile also even if it's a normal tile.
		// If this is a special (trigger) tile, add to the trigger tiles possible match list
		if (lastTriggerTileIdx >= 0 && triggerTileMatchFound[lastTriggerTileIdx] is ColorBombTile && 
			triggerTileMatchFound[lastTriggerTileIdx].BoardPiece.IsAdjacentTo(newTile.BoardPiece) ||
			newTile is TriggerTile && (triggerTileMatchFound.Count == 0 || triggerTileMatchFound[lastTriggerTileIdx].BoardPiece.IsAdjacentTo(newTile.BoardPiece)))
		{
//			if (lastTriggerTileIdx >= 0 && triggerTileMatchFound[lastTriggerTileIdx] is ColorBombTile) {
//				Debug.LogWarning("[PossibleMatchesFinder] newTile = " + newTile);
//			}
			triggerTileMatchFound.Add(newTile);
		}
			
		partialTileMatchesLists[(int)newTile.TileColor].Add(newTile);
		
		List<Match3Tile> isolatedTiles = isolatedTilesLists[(int)newTile.TileColor];

		// Find the first adjacent isolated tile from the list corresponding to this tile's color. 
		bool foundIsolatedAdjacentTile = false;
		for(int i = 0; i < isolatedTiles.Count; i++) 
		{
			// Remove one of the other isolated tiles in the list because we found that the new tile is adjacent to it.
			if (isolatedTiles[i].BoardPiece.IsAdjacentTo(newTile.BoardPiece))
			{
				isolatedTiles.RemoveAt(i);
				foundIsolatedAdjacentTile = true;
				break;
			}
		}

		// If we didn't find any isolated tile adjacent to this new one, add it to the possibly isolated tiles list corresponding
		// to this tile's color.
		if ( !foundIsolatedAdjacentTile ) {
			isolatedTiles.Add(newTile);
		}
	}
예제 #55
0
	public bool IsMatchWith(Match3Tile otherTile) {
		return otherTile != null && otherTile.CanBeMatched && CanBeMatched && TileColor == otherTile.TileColor;
	}
	void OnTilesDestroyed(Match3Tile tile)
	{
		if (!updatingValues) {
			StartCoroutine(UpdateValues());
		}
	}
예제 #57
0
	public override void RaiseEventTileSwitchAnimBegan (Match3Tile neighborTile) {
		base.RaiseEventTileSwitchAnimBegan (neighborTile);
		
		if ((neighborTile is BombTile || neighborTile is ColorBombTile) && TappedFirst)
		{
			Match3BoardGameLogic.Instance.loseConditions.NewMove();
		}
		
		if (neighborTile is BombTile)
		{
			// Don't allow this tile and it's neighbour with who it was switched to switch back on match fail. 
			BombTile neighborBomb = neighborTile as BombTile;
			neighborBomb.SwitchBackOnMatchFail = false;
			neighborBomb.DisableTileLogic();
			// Replace the default destroy effect with a bigger destroy effect
			neighborBomb.prefabDestroyEffect = neighborBomb.prefabDoubleDestroyEffect;
			neighborBomb.useBigTimeBomb = true;
		}
	}
예제 #58
0
	public bool HasTileInArea(Match3Tile otherTile)
	{
		return (otherTile.LocalPosition - LocalPosition).sqrMagnitude <= Match3BoardRenderer.sqrVertTileDistance;
	}	
	public void OnTilesSwitchBadSndEvent(Match3Tile tileA, Match3Tile tileB)
	{
		SoundManager.Instance.PlayOneShot(sndTileSwapBad);
	}
예제 #60
0
	void OnAnyTileDestroyed (Match3Tile tile)
	{
		timeToWait = multiplierWait;
	}