Quenched AR Project Overview

• Quenched AR is an avant-garde match-3 game that seamlessly integrates augmented reality (AR) technology, offering a groundbreaking gaming experience. Players engage in matching various drink types to advance through levels and achieve high scores, interacting with game elements in a virtual space as if they were in the physical world, elevating the traditional match-3 gameplay to new heights.

Role: Lead Unity Developer

• Game Development & AR Integration
  • Spearheaded the development of Quenched AR, a pioneering match-3 game leveraging augmented reality to immerse players in a dynamic gaming environment.
  • Engineered the core game mechanics, including the match-3 algorithm, ensuring a smooth and intuitive gameplay experience.
  • Integrated AR technology, enabling the seamless blending of virtual objects with the real world, enhancing player interaction and engagement.
• Power-Ups & Visual Effects (VFX)
  • Designed and implemented a variety of power-ups, each with unique abilities to enhance gameplay dynamics and provide strategic depth.
  • Created captivating visual effects that respond to player actions, contributing to the game's immersive experience and aesthetic appeal.
• XR Environment Adaptation
  • Adapted game functionalities for extended reality (XR) environments, ensuring compatibility and optimized performance across various AR devices.
• Team Leadership & Mentorship
  • Provided mentorship and guidance to a team of 2D/3D artists inexperienced in XR development.
• Cross-Platform Optimization
  • Ensured optimal game performance on multiple platforms, addressing the unique challenges of AR and XR compatibility.
  • Implemented efficient code practices and optimized assets for smooth operation across a wide range of devices.
• Project Impact
  • Quenched AR has set a new standard for AR gaming, blending engaging match-3 mechanics with cutting-edge augmented reality technology.

Diving Deep into Game Development Mechanics

Creating the Board

1. Created a grid system adaptable to various AR environments using Unity tools, dynamically resizing based on the player's device and real-world space.

2.  // Pseudo Code for Creating the Board
               function createBoard(width, height) {
                   let board = new Array(height);
                   for (let i = 0; i < height; i++) {
                       board[i] = new Array(width);
                   }
                   return board;
               }

   ‍

Randomizing the Board

1. Developed an algorithm for randomizing the board to generate unique game setups with weighted randomness for balanced challenge and playability.

2.  // Pseudo Code for Randomizing the Board
           function randomizeBoard(board) {
               for each tile in board
                   tile.type = getRandomDrinkType()
           }

   ‍

Preventing Repeating Tiles

1. Implemented an algorithm to prevent three identical drinks from aligning horizontally or vertically at the start, increasing strategic complexity.

2. // Pseudo Code for Preventing Repeating Tiles
           function checkAndPreventRepeats(board) {
               for each tile in board
                   while hasRepeatingNeighbours(tile)
                       tile.type = getRandomDrinkType()
           }

   ‍

Swapping Tiles

1. Integrated gesture recognition for swapping drinks, translating physical movements into in-game actions for a tactile, immersive experience.

2. // Pseudo Code for Swapping Tiles
           function swapTiles(tile1, tile2) {
               temporary = tile1.type
               tile1.type = tile2.type
               tile2.type = temporary
           }

   ‍

Finding Adjacent Tiles

1. Developed an algorithm to identify adjacent drinks and potential chain reactions, encouraging strategic gameplay.

2.  // Pseudo Code for Finding Adjacent Tiles
           function findAdjacentTiles(tile) {
               // Return list of adjacent tiles
           }

   ‍

Shifting and Refilling Tiles

1. Engineered an efficient algorithm to dynamically shift and refill tiles after matches, maintaining fast gameplay pace.

Combos

1. Crafted a combo system using recursive algorithms, rewarding players for chain reactions with increasing bonuses to encourage creative play.

 //  Pseudo Code for Calculating Combos
    function calculateCombos(board) {
        // Initialize a list to keep track of tiles that are part of combos
        var comboTiles = []
    
        // Iterate over each tile in the board
        for each tile in board {
            if (isPartOfCombo(tile)) {
                // If the tile is part of a combo, add it to the list
                comboTiles.add(tile)
            }
        }
    
        // For each tile that is part of a combo
        for each tile in comboTiles {
            // Remove the tile from the board
            removeTile(tile)
    
            // Increment the player's score based on the combo length
            updateScore(comboTiles.length)
        }
    
        // Check if there are empty spaces in the board after removing tiles
        if (boardHasEmptySpaces()) {
            // Shift tiles to fill the empty spaces
            shiftAndRefillTiles(board)
        }
    
        // Recursively check for new combos after the board has been updated
        if (newCombosFormed()) {
            calculateCombos(board)
        }
    }
    
    // Helper function to determine if a tile is part of a combo
    function isPartOfCombo(tile) {
        // Logic to check adjacent tiles for matching types
        // Return true if tile is part of a horizontal or vertical match of 3 or more
    }
    
    // Helper function to remove a tile from the board
    function removeTile(tile) {
        // Logic to remove the specified tile from the board
    }
    
    // Helper function to update the player's score
    function updateScore(comboLength) {
        // Logic to update the player's score based on the length of the combo
    }
    
    // Helper function to check if the board has empty spaces
    function boardHasEmptySpaces() {
        // Logic to check for empty spaces on the board
        // Return true if there are empty spaces
    }
    
    // Helper function to shift tiles and refill the board
    function shiftAndRefillTiles(board) {
        // Logic for shifting tiles down to fill empty spaces
        // Logic for refilling the board with new tiles
    }
    
    // Helper function to check for new combos after updating the board
    function newCombosFormed() {
        // Logic to check if new combos are formed after shifting and refilling tiles
        // Return true if new combos are formed
    }