SMT GEETA D.

TATKARE POLYTECHNIC, GOVE – KOLAD

COMPUTER DEPARTMENT

A MICROPROJECT
Report on

Cricket Management System

Submitted in partial fulfillment by M.S.B.T.E. norms

For the academic year 2024-25

For award in Diploma in

Computer Engineering

SUBMITTED BY
Sr No. Name of Student Roll No

1 Arshad Kondkari 12

2 Sujaat Koor 13

3 Shubham Mhatre 16

Under The Guidance Of

Mrs. Anuja Syryavanshi

1
 PART A

Cricket Management System

1.0 Rationale

A Cricket Management System (CMS) is essential for streamlining and automating the
various processes involved in managing cricket teams, players, tournaments, and match
statistics. It provides a centralized platform to store and manage player profiles, track
performance metrics, and handle scheduling of matches and training sessions. The system
helps administrators, coaches, and team managers efficiently manage player data, ensuring
real-time access to crucial information for better decision-making. It also simplifies
tournament management by automating fixture scheduling, live score updates, and match
result tracking.

2.0 Literature Review

A literature review for the Cricket Management System (CMS) project involves examining
existing research, systems, and technologies that have been applied to the management of
cricket and similar sports. While cricket management has traditionally relied on manual
processes, recent advancements in technology have significantly transformed how cricket
organizations handle player data, scheduling, and performance tracking. Several studies
have explored the application of Information Technology (IT) in sports management,
emphasizing the role of software systems in streamlining administrative tasks and
enhancing decision-making.

3.0 Proposed Methodology

The proposed methodology for developing the Cricket Management System (CMS) will
follow a structured and iterative approach, combining aspects of Agile software
development and system design principles to ensure flexibility, user-centric design, and
robust functionality. The first phase of the project will involve **requirements gathering**
and **stakeholder analysis**, where input from key users—such as cricket administrators,
coaches, players, and fans—will be collected through surveys, interviews, and focus groups
to understand their specific needs and pain points.

2
 4.0 Action Plan

Sr. Planned Planned Name of Responsible

Details of activity
No. Start date Finish date Team Members

1 Topic assignment and approval of aim 02-09-24 06-09-24 All Members

2 Making of action plan and work on 09-09-24 14-09-24 Arshad

3 Searching of related information 17-09-24 21-09-24 Sujaat

4 Collection of related information 23-09-24 28-09-24 Arshad, Shubham

5 Arrange the information 30-09-24 05-10-24 Shubham

6 Work a report presentation 07-10-24 11-10-24 Sujaat, Shubham

7 Preparation of annexure II 14-10-24 19-10-24 Arshad

8 Approval of annexure II 21-10-24 26-10-24 Sujaat

5.0 Resources Required

Sr.
Name of Resource/Material Specifications Qty Remarks
No.

Processor(i3-i5),RAM-4GB and
1 Computer 1 Required
windows 11

2 jdk 1.8.0 1 Required

3 Internet connection 10mbps - Required

4 Word application Microsoft word 10 1 Required

3
 PART B

Cricket Management System

1.0 Rationale

A Cricket Management System (CMS) is essential for streamlining and automating the
various processes involved in managing cricket teams, players, tournaments, and match
statistics. It provides a centralized platform to store and manage player profiles, track
performance metrics, and handle scheduling of matches and training sessions. The system
helps administrators, coaches, and team managers efficiently manage player data, ensuring
real-time access to crucial information for better decision-making. It also simplifies
tournament management by automating fixture scheduling, live score updates, and match
result tracking. By offering performance analytics, the CMS enables coaches to evaluate
individual and team strengths, identify areas for improvement, and make data-driven
decisions for player selection and match strategies.

2.0 Course Outcome Integrated

a) Develop Program Using GUI Framework

b) Handle Event of AWT and Swing component
c) Develop Program to handle event in Java Program

3.0 Literature Review

A literature review for the Cricket Management System (CMS) project involves examining
existing research, systems, and technologies that have been applied to the management of
cricket and similar sports. While cricket management has traditionally relied on manual
processes, recent advancements in technology have significantly transformed how cricket
organizations handle player data, scheduling, and performance tracking. Several studies
have explored the application of Information Technology (IT) in sports management,
emphasizing the role of software systems in streamlining administrative tasks and
enhancing decision-making. For example, research on sports management systems has
shown that centralized databases improve data accuracy and accessibility, facilitating
better management of player statistics, match schedules, and performance metrics.

4
4.0 Actual Procedure Followed

1) Discuss with Respective Subject Teacher About our Topic.

2) Select One Topic for Micro Project.
3) Confirm the Topic and Tell Topic Name and Group Name to Respective Subject Teacher.
4) Distribute Micro project Work to All Group Members.
5) Develop a c program for moving train
6) Get Help of Google to Search Information.
7) Refer books Related to Respective Subject.
8) Fill all Information in the Report.
9) Send Report to Respective Subject teacher To Check Report Is Correct or Not.
10) Print the Report and Submit It.
11) Program: -
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

class Player {
private String name;
private String role;
private int runs;
private int wickets;

public Player(String name, String role, int runs, int wickets) {

this.name = name;
this.role = role;
this.runs = runs;
this.wickets = wickets;
}

public String getName() {

return name;
}

public void addRuns(int runsScored) {

this.runs += runsScored;
}

5
 public void addWickets(int wicketsTaken) {
this.wickets += wicketsTaken;
}

@Override
public String toString() {
return String.format("Name: %s, Role: %s, Runs: %d, Wickets: %d", name, role, runs,
wickets);
}
}

class Team {
private String name;
private List<Player> players;

public Team(String name) {

this.name = name;
this.players = new ArrayList<>();
}

public String getName() {

return name;
}

public List<Player> getPlayers() {

return players;
}

public void addPlayer(Player player) {

players.add(player);
}

public boolean removePlayer(String playerName) {

Iterator<Player> iterator = players.iterator();
while (iterator.hasNext()) {
Player player = iterator.next();
if (player.getName().equalsIgnoreCase(playerName)) {
iterator.remove();
return true;

6
 }
}
return false;
}

public void displayTeamInfo(TextArea displayArea) {

displayArea.append("\nTeam: " + name);
for (Player player : players) {
displayArea.append("\n" + player.toString());
}
}
}

public class CricketManagementSystemAWT1 extends Frame {

private List<Team> teams;
private TextArea displayArea;
private TextField teamNameField, playerNameField, playerRoleField, runsField,
wicketsField;

public CricketManagementSystemAWT1() {
teams = new ArrayList<>();

// Create and set up the main window (Frame)

setTitle("Cricket Management System");
setLayout(new BorderLayout());
setSize(600, 600);

// Create the display area (TextArea)

displayArea = new TextArea(15, 50);
displayArea.setEditable(false);
displayArea.setBackground(Color.LIGHT_GRAY);
displayArea.setFont(new Font("Courier", Font.PLAIN, 12));
add(displayArea, BorderLayout.CENTER);

// Create the Panel for input fields and buttons

Panel inputPanel = new Panel();
inputPanel.setLayout(new GridBagLayout()); // Changed to GridBagLayout for
better control
GridBagConstraints gbc = new GridBagConstraints();
gbc.insets = new Insets(5, 5, 5, 5); // Added padding between components

7
gbc.gridx = 0;
gbc.gridy = 0;
inputPanel.add(new Label("Team Name:"), gbc);

teamNameField = new TextField(30);

gbc.gridx = 1;
inputPanel.add(teamNameField, gbc);

gbc.gridx = 0;
gbc.gridy = 1;
inputPanel.add(new Label("Player Name:"), gbc);

playerNameField = new TextField(30);

gbc.gridx = 1;
inputPanel.add(playerNameField, gbc);

gbc.gridx = 0;
gbc.gridy = 2;
inputPanel.add(new Label("Player Role:"), gbc);

playerRoleField = new TextField(30);

gbc.gridx = 1;
inputPanel.add(playerRoleField, gbc);

gbc.gridx = 0;
gbc.gridy = 3;
inputPanel.add(new Label("Runs:"), gbc);

runsField = new TextField(10);

gbc.gridx = 1;
inputPanel.add(runsField, gbc);

gbc.gridx = 0;
gbc.gridy = 4;
inputPanel.add(new Label("Wickets:"), gbc);

wicketsField = new TextField(10);

gbc.gridx = 1;
inputPanel.add(wicketsField, gbc);

8
// Buttons for actions
Panel buttonPanel = new Panel();
buttonPanel.setLayout(new GridLayout(1, 6, 10, 10)); // Horizontal grid for buttons
Button addTeamButton = new Button("Add Team");
Button addPlayerButton = new Button("Add Player");
Button removePlayerButton = new Button("Remove Player");
Button updateRunsButton = new Button("Update Runs");
Button updateWicketsButton = new Button("Update Wickets");
Button displayTeamsButton = new Button("Display Teams");

buttonPanel.add(addTeamButton);
buttonPanel.add(addPlayerButton);
buttonPanel.add(removePlayerButton);
buttonPanel.add(updateRunsButton);
buttonPanel.add(updateWicketsButton);
buttonPanel.add(displayTeamsButton);

// Add the input panel to the frame's BorderLayout.NORTH

add(inputPanel, BorderLayout.NORTH);
add(buttonPanel, BorderLayout.SOUTH);

// Event Listeners for Buttons

addTeamButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String teamName = teamNameField.getText();
Team team = new Team(teamName);
teams.add(team);
displayArea.append("\nTeam '" + teamName + "' added successfully!");
clearInputFields();
}
});

addPlayerButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String teamName = teamNameField.getText();
String playerName = playerNameField.getText();
String playerRole = playerRoleField.getText();
int runs = Integer.parseInt(runsField.getText());
int wickets = Integer.parseInt(wicketsField.getText());

9
 Player player = new Player(playerName, playerRole, runs, wickets);
boolean added = false;
for (Team team : teams) {
if (team.getName().equalsIgnoreCase(teamName)) {
team.addPlayer(player);
added = true;
break;
}
}

if (added) {
displayArea.append("\nPlayer '" + playerName + "' added to team '" +
teamName + "'");
} else {
displayArea.append("\nTeam '" + teamName + "' not found!");
}
clearInputFields();
}
});

removePlayerButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String teamName = teamNameField.getText();
String playerName = playerNameField.getText();
boolean removed = false;
for (Team team : teams) {
if (team.getName().equalsIgnoreCase(teamName)) {
removed = team.removePlayer(playerName);
break;
}
}
if (removed) {
displayArea.append("\nPlayer '" + playerName + "' removed from team '" +
teamName + "'");
} else {
displayArea.append("\nPlayer '" + playerName + "' not found in team '" +
teamName + "'");
}
clearInputFields();
}

10
 });

updateRunsButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String teamName = teamNameField.getText();
String playerName = playerNameField.getText();
int runsScored = Integer.parseInt(runsField.getText());
boolean updated = false;
for (Team team : teams) {
if (team.getName().equalsIgnoreCase(teamName)) {
for (Player player : team.getPlayers()) {
if (player.getName().equalsIgnoreCase(playerName)) {
player.addRuns(runsScored);
updated = true;
break;
}
}
break;
}
}
if (updated) {
displayArea.append("\n" + runsScored + " runs added to " + playerName);
} else {
displayArea.append("\nPlayer '" + playerName + "' not found in team '" +
teamName + "'");
}
}
});

updateWicketsButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String teamName = teamNameField.getText();
String playerName = playerNameField.getText();
int wicketsTaken = Integer.parseInt(wicketsField.getText());
boolean updated = false;
for (Team team : teams) {
if (team.getName().equalsIgnoreCase(teamName)) {
for (Player player : team.getPlayers()) {
if (player.getName().equalsIgnoreCase(playerName)) {
player.addWickets(wicketsTaken);

11
 updated = true;
break;
}
}
break;
}
}
if (updated) {
displayArea.append("\n" + wicketsTaken + " wickets added to " +
playerName);
} else {
displayArea.append("\nPlayer '" + playerName + "' not found in team '" +
teamName + "'");
}
}
});

displayTeamsButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
displayArea.setText(""); // Clear the display area
for (Team team : teams) {
team.displayTeamInfo(displayArea);
}
}
});

// Window Closing Listener

addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent we) {
System.exit(0);
}
});

// Set the visibility of the window

setVisible(true);
}

private void clearInputFields() {

teamNameField.setText("");
playerNameField.setText("");

12
 playerRoleField.setText("");
runsField.setText("");
wicketsField.setText("");
}

public static void main(String[] args) {

new CricketManagementSystemAWT1();
}
}

5.0 Actual Resources Used

Sr. Name of
Specifications Qty Remarks
No. Resource/Material

Processor(i3-i5),RAM-4GB and
1 Computer 1 Available
windows 11

2 jdk 1.8.0 1 Available

3 Internet connection 10mbps - Available

4 Word application Microsoft word 10 1 Available

13
6.0 Outputs of the Micro-Project

14
15
16
17
18
19
 7.0 Skill Developed / learning out of this Micro-Project.

1) Team work produces the energy in the work

2) Leadership communication between all the group members
3) Increases our confidence level
4) Team presentation skill is improved
5) Know about word file and uses of MS OFFICE

8.0 Application Of this Micro-Project

1. Team and Player Management
2. Tournament and Match Management
3. Performance Analytics and Data-Driven Insights
4. Fan Engagement and Real-Time Updates
5. Resource and Financial Management
6. Scouting and Development for Youth Academies
7. Compliance and Health Monitoring
8. Administrative Efficiency
9. Event Planning and Promotion

9.0 Area of Future Improvement

1. Integration of Advanced Analytics and AI

• Machine Learning for Performance Prediction: Future iterations of the CMS

could integrate machine learning algorithms to predict player performance based
on historical data, match conditions, and other factors such as weather, pitch type,
or opposition strength.
• Player Injury Prediction and Prevention: By using AI and data analytics, the
system could predict injury risks based on players' physical condition, workload,
and injury history.
• Advanced Match Analytics: Incorporating more advanced statistical models, such
as predictive modeling or computer vision-based analysis of match footage, could
offer deeper insights into player and team performance

2. Augmented Reality (AR) and Virtual Reality (VR) Integration

• Player Training and Simulation: Integrating AR or VR technology into the CMS

could provide immersive training experiences for players. For example, VR

20
 simulations of match scenarios could help players practice decision-making in
high-pressure situations or improve their reaction times.
• Fan Engagement: AR could also enhance fan experience by offering virtual tours
of stadiums, interactive replays, or even immersive experiences such as virtual seat
selection or "as-if-you-were-there" experiences during live matches.

3. Real-Time Data Integration and IoT

• Wearable Devices for Player Monitoring: Integration with wearable technology,

such as fitness trackers or smartwatches, could provide real-time data on player
health, heart rate, hydration levels, and physical exertion during training or
matches.
• Internet of Things (IoT) for Equipment Tracking: IoT-enabled cricket gear,
such as smart bats, balls, or pads, could provide valuable performance data (e.g.,
bat swing speed, ball speed, impact force) that could be integrated into the CMS to
provide a more comprehensive view of player performance.

4. Fan-Centric Features and Interactive Platforms

• Personalized Fan Experience: Future CMS versions could offer more

personalized experiences for fans. By analyzing fan behavior and preferences (e.g.,
favorite players, teams, or match types).
• Gamification and Fantasy Leagues: The CMS could incorporate gamification
elements, allowing fans to participate in fantasy leagues, predict match outcomes,
or engage in real-time challenges during matches..
• Social Media Integration: Greater integration with social media platforms could
allow fans to share match moments, player achievements, or live scores directly
from the CMS.

5. Cloud Scalability and Mobile App Enhancements

• Cloud-Native Architecture: To accommodate the growing volume of data

generated from various matches, tournaments, and player activities, the CMS could
transition to a more robust, cloud-native infrastructure.
• Offline Capabilities: Enhancing the mobile app with offline functionality would
allow users (such as coaches or match organizers in remote areas) to access certain
features and input data without an active internet connection, syncing when the
connection is restored.

21
6. Blockchain for Data Security and Transparency

• Contract Management and Payments: Blockchain could be used to securely store

player contracts, payment records, and sponsorship agreements. The transparency
and immutability of blockchain would ensure that all transactions are verified and
recorded, reducing the risk of fraud or disputes.
• Ticketing and Anti-Counterfeit Measures: Blockchain-based ticketing systems
could be integrated into the CMS to ensure ticket authenticity, preventing fraud and
scalping. Fans could also be rewarded with digital tokens that could be redeemed
for exclusive content or merchandise.

7. Enhanced Communication Tools

• Chatbots for Communication: AI-powered chatbots could be integrated into the

CMS to provide instant support for fans, players, or administrators, answering
common queries related to match schedules, player stats, ticketing, and more.
• Real-Time Collaboration Features: For team management, introducing real-time
collaboration tools (e.g., shared calendars, task management, and instant
messaging) could improve coordination between coaches, staff, and players.

8. Expanded Global Reach and Multilingual Support

• International Expansion: To support cricket’s global growth, the CMS could be

expanded to support multiple languages and regional-specific features.
• Localized Content: Depending on the region, CMS could provide localized
content such as player profiles, tournament schedules, and fan interactions, helping
to improve engagement and accessibility for users worldwide.

9. Sustainability and Environmental Tracking

• Eco-Friendly Practices: In line with increasing awareness of environmental

sustainability, the CMS could help cricket teams and organizations monitor and
reduce their environmental impact.

22