MEMORY GAME
A Java implementation of the Memory game involves representing
cards with images, managing game state (revealed/hidden,
matched), and handling player interaction. The goal is to find all
matching pairs of cards by flipping two cards at a time.
Key Components:
1. Card Representation:
A Card class can represent a card with an image (or number/letter)
and a boolean flag indicating if it’s revealed.
2. Game State:
The game state is tracked using data structures like lists or arrays
to store cards and their current state (revealed/hidden, matched).
3. Player Interaction:
Handling player clicks/input to flip cards and check for matches.
Timers can be used to hide cards after a certain time if they don’t
match.
4. Logic:
The game logic includes checking for matching pairs, updating the
game state, and determining the game’s end condition (all pairs
matched).
Example Code Snippet (Simplified Card Class).
import javax.imageio.ImageIO;
import javax.imageio.stream.ImageInputStream;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import java.util.stream.Collectors;
import javax.swing.Timer;
class Game {
public static class Controller {
final JFrame window;
Model model;
View view;
// Constructor
public Controller(Model model) {
this.window = new JFrame("Memory"); // Create the window
this.window.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); //
Close the window when the user clicks on the close button
this.window.setResizable(false); // Disable the resizing of the window
this.reset(model); // Reset the game
}
// Reset the game
public void reset(Model model) {
this.model = model;
this.view = new View(model);
this.window.setVisible(false);
this.window.setContentPane(view);
this.window.pack();
this.window.setLocationRelativeTo(null);
for (JButton button : this.model.getButtons()) {
button.addActionListener(new ButtonActionListener(this));
Utilities.timer(200, (ignored) -> this.window.setVisible(true)); // Show
the window after 200ms
public JFrame getWindow() {
return this.window;
public Model getModel() {
return this.model;
public View getView() {
return this.view;
public static class Model {
// Constants for the game
static final String[] AVAILABLE_IMAGES = new String[]{"0.png", "1.png",
"2.png", "3.png", "4.png", "5.png", "6.png", "7.png", "8.png"};
static final Integer MAX_REGISTERED_SCORES = 10;
final ArrayList<Float> scores;
final ArrayList<JButton> buttons;
final int columns; // Number of columns
int tries; // Number of tries left
boolean gameStarted; // Is the game started
public Model(int columns) {
this.columns = columns; // Number of columns
this.buttons = new ArrayList<>(); // List of buttons in the game
this.scores = new ArrayList<>(); // List of scores in the game
this.tries = 10; // Number of tries initially
this.gameStarted = false; // Game is not started initially
int numberOfImage = columns * columns; // Number of images
Vector<Integer> v = new Vector<>(); // Vector to store the images
for (int i = 0; i < numberOfImage - numberOfImage % 2; i++) { //
Add the images twice
v.add(i % (numberOfImage / 2));
if (numberOfImage % 2 != 0) v.add(AVAILABLE_IMAGES.length - 1); //
Add the last image if the number of images is odd
// Add the images as a button to the game
for (int i = 0; i < numberOfImage; i++) {
int rand = (int) (Math.random() * v.size()); // Randomly select an
image
String reference = AVAILABLE_IMAGES[v.elementAt(rand)]; // Get
the image
this.buttons.add(new MemoryButton(reference)); // Add the image
as a button
v.removeElementAt(rand); // Remove the image from the vector
public int getColumns() {
return columns;
public ArrayList<JButton> getButtons() {
return buttons;
// Get the number of tries left
public int getTries() {
return tries;
// Decrement the tries count by calling this method
public void decrementTries() {
this.tries--;
// return if the game has started
public boolean isGameStarted() {
return this.gameStarted;
// start the game
public void startGame() {
this.gameStarted = true;
}
}
// class to handle the UI of the game
public static class View extends JPanel {
final JLabel tries;
public View(Model model) {
this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
this.tries = new JLabel("", SwingConstants.CENTER);
this.tries.setFont(new Font("MV Boli", Font.BOLD, 30));
this.tries.setForeground(Color.WHITE);
JPanel imagePanel = new JPanel();
int columns = model.getColumns();
imagePanel.setLayout(new GridLayout(columns, columns));
for (JButton button : model.getButtons()) {
imagePanel.add(button);
this.setTries(model.getTries());
JPanel triesPanel = new JPanel();
triesPanel.add(this.tries);
triesPanel.setAlignmentX(CENTER_ALIGNMENT);
triesPanel.setBackground(new Color(0X8946A6));
this.add(triesPanel);
this.add(imagePanel);
public void setTries(int triesLeft) {
this.tries.setText("Tries left : " + triesLeft);
}
}
// class to handle the button clicks
public static class ReferencedIcon extends ImageIcon {
final String reference;
public ReferencedIcon(Image image, String reference) {
super(image);
this.reference = reference;
public String getReference() {
return reference;
// class to handle the button on the images
public static class MemoryButton extends JButton {
static final String IMAGE_PATH = "";
static final Image NO_IMAGE = Utilities.loadImage("no_image.png");
public MemoryButton(String reference) {
Image image = Utilities.loadImage(IMAGE_PATH + reference);
Dimension dimension = new Dimension(120, 120);
this.setPreferredSize(dimension);
this.setIcon(new ImageIcon(NO_IMAGE));
this.setDisabledIcon(new ReferencedIcon(image, reference));
public static class Dialogs {
public static void showLoseDialog(JFrame window) {
UIManager.put("OptionPane.background", new Color(0XEA99D5));
UIManager.put("Panel.background", new Color(0XEA99D5));
JOptionPane.showMessageDialog(window, "You lost, try again !", "You
lost !", JOptionPane.INFORMATION_MESSAGE);
public static void showWinDialog(JFrame window, Model model) {
String message = String.format("Congrats you won!!");
UIManager.put("OptionPane.background", new Color(0XEA99D5));
UIManager.put("Panel.background", new Color(0XEA99D5));
JOptionPane.showMessageDialog(window.getContentPane(),
message, "", JOptionPane.INFORMATION_MESSAGE);
// class to handle the button clicks
public static class ButtonActionListener implements ActionListener {
final Controller controller;
final Model model;
final View view;
final JFrame window;
static int disabledButtonCount = 0;
static JButton lastDisabledButton = null;
static final Image TRAP_IMAGE = Utilities.loadImage("no_image.png");
final ReferencedIcon trap;
public ButtonActionListener(Controller controller) {
this.controller = controller;
this.model = controller.getModel();
this.view = controller.getView();
this.window = controller.getWindow();
this.trap = new ReferencedIcon(TRAP_IMAGE, "no_image.png");
// Method to handle the button clicks and check if two images are same
@Override
public void actionPerformed(ActionEvent e) {
JButton button = (JButton) e.getSource();
button.setEnabled(false);
ReferencedIcon thisIcon = (ReferencedIcon) button.getDisabledIcon();
disabledButtonCount++;
if (!model.isGameStarted()) { // If the game has not started
model.startGame(); // Start the game
if (disabledButtonCount == 2) { // If two buttons are disabled
ReferencedIcon thatIcon = (ReferencedIcon)
lastDisabledButton.getDisabledIcon();
boolean isPair =
thisIcon.getReference().equals(thatIcon.getReference()); // Check if the two
images are the same
if (!isPair) { // If the two images are not the same
model.decrementTries(); // Decrement the number of tries
view.setTries(model.getTries()); // Update the number of tries
JButton lastButton = lastDisabledButton; // Store the last button
Utilities.timer(500, ((ignored) -> { // Wait 500ms before re-
enabling the buttons
button.setEnabled(true); // Re-enable the button
lastButton.setEnabled(true); // Re-enable the last button
}));
}
disabledButtonCount = 0; // Reset the counter
ArrayList<JButton> enabledButtons = (ArrayList<JButton>)
model.getButtons().stream().filter(Component::isEnabled).collect(Collectors.t
oList());
if (enabledButtons.size() == 0) { // If all the buttons are disabled
controller.reset(new Model(controller.getModel().getColumns())); //
Reset the game
Dialogs.showWinDialog(window, model); // Show the win dialog
lastDisabledButton = button; // Store the last button
if (model.getTries() == 0) { // If the number of tries is 0
controller.reset(new Model(controller.getModel().getColumns())); //
Reset the game
Dialogs.showLoseDialog(window); // Show the lose dialog
Utilities.timer(1000, (ignored) -> model.getButtons().forEach(btn -
> btn.setEnabled(false))); // Wait 1s before disabling all the buttons
public static class Utilities {
static final ClassLoader cl = Utilities.class.getClassLoader();
// Method to create a timer
public static void timer(int delay, ActionListener listener) {
Timer t = new Timer(delay, listener);
t.setRepeats(false);
t.start();
}
// Method to load an image
public static Image loadImage(String s) {
Image image = null;
try {
InputStream resourceStream = cl.getResourceAsStream(s);
if (resourceStream != null) {
ImageInputStream imageStream =
ImageIO.createImageInputStream(resourceStream);
image = ImageIO.read(imageStream);
} catch (IOException e) {
e.printStackTrace();
return image;
// Main class to run the game
class Main {
static final int DEFAULT_SIZE = 4;
public static void main(String[] args) {
Locale.setDefault(Locale.ENGLISH);
SwingUtilities.invokeLater(() -> new Game.Controller(new
Game.Model(DEFAULT_SIZE)));
}
OUTPUT:-
