• CPT Project Ideation

CPT Project Ideation

Project: Facial Recognition software login system paired with a verion of Monopoly

Part 1: Functioning of the Facial Recognition login system

  • The facial login system aims to recogize the facial pattern on an induvidual registered into the system, and allow them acces into their unique login
  • The login system won’t require any passwords but rather would store the details of one’s face into the backend system.
  • This backend server with the registered user would thereby recognize the person’s face and allow acces into their unique login.

Working of a facial recognization software

A facial recognization software has 4 major steps for allowed access for the user.

  1. Face detection: The software first located the face with the frame of the camera or video frame
  2. Feature Extraction: It analyzes facial feautures like the eyes, nose and mouth and converts into into data
  3. Database comparison: The extracted data is then compared to a database of know and registered facial data
  4. Mathcing algorithm: An algorithm searches across the database for a correct match
  5. Results: The user is allowed or denied acces depeding on the algorithm search and their login page is displayed accrodingly from the data that is fetched.

Login Screen Processing

  • We plan to have accurate and measurable safety features for the login screen
  • With Valid CSRF Token Process, SQL Injection Prevention, Password Complexity Checker etc

Part 2: Monopoly based board game

The second part of this project details what is to be give after the person logs into the page. We plan to create a monopoly based board game. This game unlike monopoly which have simple card and motor functions. In this Monopoly variation, players roll dice to move, gaining or losing money at each step. A computer opponent also moves randomly. Steal Money cards add strategy, offering chances to gain or lose cash. Random Event cards introduce choices like moving forward or backward. The goal is to reach $1000 first. The backend system manages user data and a leaderboard, tracking progress and showcasing financial success.

Part 2A: Desigining the game

  1. The board: The design of the board is said to be done is code with each box defined for its color of for its property.
  2. The cards: The cards are a part of the board sqaures and are part of the user’s ability of move throught the spaces. The cards are dynamic but one played, an if - then senario is meant to be used to continue the game.
  3. The players: The players in the this game are the user themself and a robot opponent. The opponent is mostly likely a programmable software which plays agains the user for better engagment.
  4. Winning or Loosing: The sole purpose of the game is for either end of play to reach $1000 first.
  5. Role of User: The user only need to click a rool the dice button which enact gameplay on its own. We wish to minimize as much user interference as possible sticking to only rolling the dice which is said to be random as well.
  6. Keeping tally of score: Each game will be recorded with win or loss statistics along with the time taken to reach said conlcusion as well.
  7. Login Page: The login page is designed to not only have the monopoly based game but also statistics of the user’s past game play. We plan to use a backend database such as SQLITE to store the data from precious gameplays and also manage to link it to the facial recognition software so that the correct statisitics are matched with the correct user.
  8. Random Events: If the first part of this code works we plan to also include random events that either encourage gameplay or disupt it entirely.

Part 2B: Unique Cards

  • Move space card: This card moves the user the set number of spaces either forward or backward
  • Money card: This card allows the user to either gain or loose money
  • Steal money card: This allows the user to “steal” money from the opponent
  • Teleportation card: Allows the user to teleport to a unique place on the board
  • Double income card: Double the user’s total momney at the mooment
  • Double jeprody: Takes off double of what the user has pushing them into a negetive zone
  • 0 card: Resets the user’s total moneyback to 0
  • 1000 card: instant win for the user
  • Kill Zone: Alows for the user to “kill” the opponent or take away all their money

More ideas for card will be added as the gameplay progresses

Part 2C: Code ideas for the gameplay

1. Board Layout

class MonopolyBoard:
    def __init__(self):
        self.spaces = [
            {"type": "start", "name": "Start"},
            {"type": "property", "name": "Property 1", "cost": 100, "rent": 20},
            {"type": "move", "name": "Move Space", "steps": 2},
            {"type": "money", "name": "Money Card", "amount": 50},
            # Add more spaces as needed
        ]

    def get_space_info(self, position):
        return self.spaces[position]

# Example usage:
monopoly_board = MonopolyBoard()

# Accessing space information at position 2
space_info = monopoly_board.get_space_info(2)
print(space_info)

2. Dice gameplay

import random

def roll_dice():
    input("Press Enter to roll the dice...")
    result = random.randint(1, 6)
    print(f"You rolled a {result}")
    return result

# Example usage:
user_roll = roll_dice()

3. Card Gameplay

Given the senario that the player gains $50 after the gameplay

class Player:
    def __init__(self, name):
        self.name = name
        self.money = 0

# Card gameplay
def play_money_card(player):
    card_value = 50
    player.money += card_value
    print(f"{player.name} gained ${card_value}. Total money: ${player.money}")

# Example usage:
player1 = Player("Player1")
play_money_card(player1)

4. Robot Opponent

class Player:
    def __init__(self, name):
        self.name = name
        self.money = 0

def roll_dice():
    return random.randint(1, 6)

def play_turn(player):
    steps = roll_dice()
    player.money += steps * 10  # Simulating earning money based on dice roll
    print(f"{player.name} rolled a {steps} and earned ${steps * 10}. Total money: ${player.money}")

def robot_opponent_turn():
    steps = roll_dice()
    robot_money = steps * 10  # Simulating robot earning money based on dice roll
    print(f"Robot opponent rolled a {steps} and earned ${robot_money}.")

# Example usage:
player1 = Player("Player1")

# Player's turn
play_turn(player1)

# Robot opponent's turn
robot_opponent_turn()

Part 3: Group Assignments

Group Assignments divided amongst the people

Name Project Work
Austin Monopoly board and gameplay designed and coded
Eric Facial Recognition and backend storage
Saaras Facial Recognition and backend storage
Cayden Monopoly board and gameplay designed and coded
Sri Monopoly board and gameplay designed and coded