Guess Who? 🤷‍♀️

Table of Contents 🕵️‍♂️

Project Overview 🥸
Installation and Setup 🏃🏼‍♀️
Figma Prototype 📷
Features 👨🏼‍💻
Structure and Key Components 🧠
Technical Architecture 🏠
Architecture Pattern 🏗️

Project Overview 🥸

"Guess Who?" is a mobile adaptation of the classic board game, developed using Android Studio and libGDX with Firebase Realtime database. The game supports both single-player and multiplayer modes, allowing players to guess their opponent's chosen character through a series of yes/no questions.

Installation and Setup 🏃🏼‍♀️

Prerequisites

Android device running Android 7.0 (Nougat) or later

Running the Game

To install the game on an Android device:

Clone or download the project from the GitHub repository. To do so, use the following command:
```
git clone git@git.ntnu.no:henriesn/TDT4240-02.git.
```
Open the project in Android Studio. To do this, navigate to File > Import, and then select the project.
Open Device Manager and click the plus sign to add a new device. This can be found in the sidebar or in the toolbar at the top Tools > Device Manager.
Launch the Medium Phone Android Virtual Device with API 35 running Android 15.0 “VanillaIceCream"
Build and run the project using Android Studio’s Run button, or go to Run > Run 'Android' in the toolbar.
If you experience any difficulties when trying to run the project, try cleaning and rebuilding it by going to Build > Clean Project, and then Build > Rebuild Project. After that, try running the project again.

Alternatively, you can run it natively on your Android device, either via USB or by generating an APK file, however we have not tested this configuration as we did not have an Android device available during development.

Figma Prototype 📷

For mobile 📱

Login view	Choose multiplayer or single player

Start a game	Create a game

Join a game	Choose a character

Multiplayer view - sending question	Multiplayer view - receiving question

Singleplayer view

Guess character	Leaderboard

Loosing view	Winning view

Structure and Key Components 🧠

🔹 `controller/`

Handles user input and state transitions.

buttonControllers/: Manages button-specific interactions.
state/: Contains the logic for different game states (e.g., GamePlayState, EndGameState, LoginState).

🔹 `model/`

Contains all data structures and business logic. Models represent the core of the game’s information — characters, users, questions, and gameplay data.

🔹 `view/`

Includes all visual components and UI elements. Views are responsible for rendering content and displaying feedback to the player. They are stateless and rely on models/controllers for updates.

🔹 `utils/`

A collection of helper classes, shared logic, and backend integrations. This folder supports reusable logic like Firebase callbacks, enums, and utility methods used across the app.

🔹 `FirebaseInterface.java`

Acts as the bridge between the app and the Firebase backend. Handles tasks like database read/write operations, and multiplayer syncing.

🔹 `GameStateManager.java`

The central controller that manages state transitions. It controls when the app moves from login to gameplay to leaderboard, etc.

🔹 `GuessWho.java`

The entry point of the application. This class initializes the game and sets up the starting state.

Architecture Pattern 🏗️

This project uses the Model-View-Controller (MVC) pattern to ensure a clean separation between data (Model), presentation (View), and logic (Controller). This structure improves maintainability, supports parallel development, and allows for easier testing and scaling.

Features 👨🏼‍💻

Main Functional Requirements

Log in: Log in with a new or existing username.
Character Board: A board displaying 16 characters.
Character Selection: Players choose a character that their opponent must guess.
Question System: Players send questions and receive yes/no responses
Cross Out Cards: Cross out the character cards based on questions.
Guess Character: Guess character and know if they won or lost.
Game mode: Player can choose between multiplayer and single player.
Multiplayer Mode: Two players can compete in real-time, and send custom questions. Player can either ‘join a game’ or ‘create a game’.
Single Player Mode: A player guesses a randomly assigned character with predefined questions.
Game Control: Quit options.
End Game Handling: Displays the correct character and declares the winner.
Leaderboard: Tracks the number of won games.

Quality Attributes

Primary Attribute:

Modifiability: Designed for ease of updating game rules, character rosters, and difficulty settings.

Secondary Attributes:

Usability: Intuitive UI with easily accessible help screens for first-time players.
Performance: Low latency in multiplayer interactions (<1sec leaderboard update time, <1sec game session setup).

Technical Architecture 🏠

Core Technologies & Frameworks

Android Studio: Development environment.
libGDX: Handles game logic, rendering, and input management.

Key Architectural Considerations

Screen-based game flow: LibGDX enforces a stack-based screen structure.
Game State Management: Firebase Realtime Database is used to store and synchronize player selections and game progress.

This project is developed a part of the TDT4240 course. Contributions and feedback are welcome!

henriesn/TDT4240-02

About

Resources

Stars

Watchers

Forks

Releases

Packages 0

Contributors 5

Languages

Packages