Open Ended Lab
On
2048 GAME
using C++ Programming Language
Course No: CSE 2100
Course Name: Object Oriented Programming Laboratory
Submitted By-
Fariha Tahsin
Roll: 2209016
10th February 2025
Department of Electronics and Communication Engineering
Khulna University of Engineering & Technology
Khulna-9203, Bangladesh.
Introduction
Project Overview
This project aims to develop a console-based implementation of the 2048 game using C++
and object-oriented programming (OOP) principles.
Game Description
2048 is a sliding tile puzzle game that challenges players to combine numbered tiles into larger
values. The objective is to create the 2048 tile by merging tiles of the same value. Each move
shifts tiles in one direction (Up, Down, Left, or Right), merging adjacent tiles of the same value
and adding a new tile to the grid.
Key gameplay mechanics:
1. Sliding tiles in one of four directions (Up, Down, Left, Right).
2. Merging tiles with the same value during a slide.
3. Randomly adding new tiles (2, 4, 8, 16 or 32) to the grid after each move.
4. Ending the game when no valid moves remain or when the player achieves the 2048
tile.
Objectives
1. To implement the basic mechanics of 2048, including tile sliding, merging, and grid
updates.
2. To provide clear feedback for win or game-over states.
3. To use OOP principles (class, object, encapsulation, inheritance, abstraction and
polymorphism) to ensure a modular and reusable codebase.
4. To display the grid in a visually appealing format and provide intuitive controls (W,
A, S, D for movement, Q to quit).
Features
1. Dynamic Grid Updates:
o A 4x4 grid updates in real-time after each move.
o New tiles (2, 4, 8, 16 or 32) are generated dynamically based on gameplay
progression. For example: First there will be 2 and 4 tile. After five moves,
2, 4 and 8 will be generated. Then after ten moves, 2, 4, 8 and 16 will be
generated randomly.
2. Win and Game-Over Conditions:
o Players win upon creating the 2048 tile.
o The game ends if no valid moves are available.
2
3. Tile Sliding and Merging:
o Will be implemented as modular strategies for each direction (Move_Up,
Move_Down, Move_Left, Move_Right).
4. Interactive Console Interface:
o A clean and intuitive console interface will display the grid, with clear
prompts for user input.
Here’s a simple chart that represents the flow of the 2048 game implementation.
3
Proposed Class Structure
1. Grid Class:
o Managing the grid state (a 2D array).
o Initializing the grid.
o Tile Generation: Randomly adding a new tile (2, 4, 8, 16 or 32) to an empty
position after each move.
o Win/ Loss Detection: Detecting when the 2048 tile is created or when no
valid moves are available.
o Grid Display: Formatting and display the grid for a clear user interface.
2. Move Classes (Move_Up, Move_Down, Move_Left, Move_Right):
o Implementing the specific behaviors for moving and merging tiles in each
direction.
3. Game_2048 Class:
o Managing the game loop and interactions with the Grid object.
o Accepting user input (W (up), A (left), S (down), D (right), Q(quit)).
o Managing the game state and triggering win/loss conditions.
Inheritance used in this project
1. Single Inheritance: Base_Move only inherits from one parent class
(Move_Strategy), this is single inheritance.
2. Hierarchical Inheritance: Move_Up, Move_Down, Move_Left, Move_Right all
inherit from Base_Move. Since multiple classes inherit from the same base class,
this is hierarchical inheritance.
4
5
Conclusion
This project is a practical implementation of the popular 2048 game using C++ and object-
oriented programming (OOP) principles. The game demonstrates the successful use of key
OOP concepts such as encapsulation, inheritance, polymorphism, and abstraction to create a
clean, modular, and scalable codebase. The console-based design ensures that players enjoy an
interactive and engaging experience, while the modular architecture allows for easy future
enhancements like scoring, undo functionality, or even a graphical interface. This project
highlights how OOP can be effectively used to build robust and maintainable software
solutions.
