diff --git a/Games/Dsa_quiz_game/README.md b/Games/Dsa_quiz_game/README.md
new file mode 100644
index 0000000000..1fc0f26a1a
--- /dev/null
+++ b/Games/Dsa_quiz_game/README.md
@@ -0,0 +1,37 @@
+# **Dsa_quiz_game**
+
+---
+
+
+
+## **Description đ**
+
+-The DSA Quiz Game is for educational purposes and contains DSA problems.
+-It will help strengthen concepts.
+-Increase your self-confidence.
+-Easy to play.
+
+## **functionalities đŽ**
+
+-Contains 50+ DSA questions.
+-Randomly selects any 10 questions.
+-Shows results after the game.
+-Displays the correct answer if your answer is wrong.
+
+
+
+## **How to play? đšī¸**
+-Start by selecting any one option. The game will show you the correct answer if your answer is wrong.
+
+
+
+
+## **Screenshots đ¸**
+
+
+
+
+
+
+
+
diff --git a/Games/Dsa_quiz_game/index.html b/Games/Dsa_quiz_game/index.html
new file mode 100644
index 0000000000..2b9c36c0c3
--- /dev/null
+++ b/Games/Dsa_quiz_game/index.html
@@ -0,0 +1,26 @@
+
+
+
+
+
+
+ Quizz App
+
+
+
+
Simple Quiz
+
+
This is Question
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Games/Dsa_quiz_game/script.js b/Games/Dsa_quiz_game/script.js
new file mode 100644
index 0000000000..52981b7406
--- /dev/null
+++ b/Games/Dsa_quiz_game/script.js
@@ -0,0 +1,414 @@
+const questions = [
+ {
+ question: "What is the time complexity of accessing an element in an array by its index?",
+ answers: [
+ {text: "O(1)", correct: true},
+ {text: "O(n)", correct: false},
+ {text: "O(log n)", correct: false},
+ {text: "O(n^2)", correct: false},
+ ]
+ },
+ {
+ question: "What data structure is a Last-In-First-Out (LIFO) data structure?",
+ answers: [
+ {text: "Stack", correct: true},
+ {text: "Queue", correct: false},
+ {text: "Linked List", correct: false},
+ {text: "Tree", correct: false},
+ ]
+ },
+ {
+ question: "What is the time complexity of inserting an element at the end of an array?",
+ answers: [
+ {text: "O(1)", correct: false},
+ {text: "O(n)", correct: true},
+ {text: "O(log n)", correct: false},
+ {text: "O(n^2)", correct: false},
+ ]
+ },
+ {
+ question: "Which data structure uses First-In-First-Out (FIFO) ordering?",
+ answers: [
+ {text: "Queue", correct: true},
+ {text: "Stack", correct: false},
+ {text: "Linked List", correct: false},
+ {text: "Tree", correct: false},
+ ]
+ },
+ {
+ question: "What is the time complexity of inserting an element at the beginning of an array?",
+ answers: [
+ {text: "O(1)", correct: false},
+ {text: "O(n)", correct: true},
+ {text: "O(log n)", correct: false},
+ {text: "O(n^2)", correct: false},
+ ]
+ },
+ {
+ question: "Which data structure organizes elements in a hierarchical structure?",
+ answers: [
+ {text: "Tree", correct: true},
+ {text: "Stack", correct: false},
+ {text: "Queue", correct: false},
+ {text: "Linked List", correct: false},
+ ]
+ },
+ {
+ question: "What is the time complexity of searching for an element in a binary search tree?",
+ answers: [
+ {text: "O(1)", correct: false},
+ {text: "O(n)", correct: false},
+ {text: "O(log n)", correct: true},
+ {text: "O(n^2)", correct: false},
+ ]
+ },
+ {
+ question: "Which data structure allows elements to be accessed in a LIFO (Last-In-First-Out) manner?",
+ answers: [
+ {text: "Stack", correct: true},
+ {text: "Queue", correct: false},
+ {text: "Linked List", correct: false},
+ {text: "Tree", correct: false},
+ ]
+ },
+ {
+ question: "What is the time complexity of inserting an element in the middle of an array?",
+ answers: [
+ {text: "O(1)", correct: false},
+ {text: "O(n)", correct: true},
+ {text: "O(log n)", correct: false},
+ {text: "O(n^2)", correct: false},
+ ]
+ },
+ {
+ question: "Which data structure does not have a fixed size?",
+ answers: [
+ {text: "Linked List", correct: true},
+ {text: "Stack", correct: false},
+ {text: "Queue", correct: false},
+ {text: "Tree", correct: false},
+ ]
+ },
+ {
+ question: "What is the time complexity of inserting an element at the end of a linked list?",
+ answers: [
+ {text: "O(1)", correct: false},
+ {text: "O(n)", correct: true},
+ {text: "O(log n)", correct: false},
+ {text: "O(n^2)", correct: false},
+ ]
+ },
+ {
+ question: "Which data structure allows elements to be accessed in a FIFO (First-In-First-Out) manner?",
+ answers: [
+ {text: "Queue", correct: true},
+ {text: "Stack", correct: false},
+ {text: "Linked List", correct: false},
+ {text: "Tree", correct: false},
+ ]
+ },
+ {
+ question: "What is the time complexity of deleting an element at the beginning of a linked list?",
+ answers: [
+ {text: "O(1)", correct: true},
+ {text: "O(n)", correct: false},
+ {text: "O(log n)", correct: false},
+ {text: "O(n^2)", correct: false},
+ ]
+ },
+ {
+ question: "Which data structure represents a collection of elements, each identified by at least one array index or key?",
+ answers: [
+ {text: "Array", correct: true},
+ {text: "Linked List", correct: false},
+ {text: "Queue", correct: false},
+ {text: "Stack", correct: false},
+ ]
+ },
+ {
+ question: "What is the time complexity of finding an element in a hash table?",
+ answers: [
+ {text: "O(1)", correct: true},
+ {text: "O(log n)", correct: false},
+ {text: "O(n)", correct: false},
+ {text: "O(n^2)", correct: false},
+ ]
+ },
+ {
+ question: "Which data structure allows for constant time insertion and deletion of elements at both ends?",
+ answers: [
+ {text: "Deque", correct: true},
+ {text: "Linked List", correct: false},
+ {text: "Queue", correct: false},
+ {text: "Stack", correct: false},
+ ]
+ },
+ {
+ question: "What is the time complexity of finding an element in a sorted array using binary search?",
+ answers: [
+ {text: "O(1)", correct: false},
+ {text: "O(log n)", correct: true},
+ {text: "O(n)", correct: false},
+ {text: "O(n^2)", correct: false},
+ ]
+ },
+ {
+ question: "Which data structure follows the Last-In-First-Out (LIFO) principle?",
+ answers: [
+ {text: "Stack", correct: true},
+ {text: "Queue", correct: false},
+ {text: "Deque", correct: false},
+ {text: "Linked List", correct: false},
+ ]
+ },
+ {
+ question: "What is the time complexity of appending an element to the end of a dynamic array (with resizing)?",
+ answers: [
+ {text: "O(1)", correct: false},
+ {text: "O(log n)", correct: false},
+ {text: "O(n)", correct: false},
+ {text: "Amortized O(1)", correct: true},
+ ]
+ },
+ {
+ question: "Which data structure is based on the principle of First-In-First-Out (FIFO)?",
+ answers: [
+ {text: "Queue", correct: true},
+ {text: "Stack", correct: false},
+ {text: "Deque", correct: false},
+ {text: "Linked List", correct: false},
+ ]
+ },
+ {
+ question: "What is the time complexity of finding the minimum (or maximum) element in a min (or max) heap?",
+ answers: [
+ {text: "O(1)", correct: true},
+ {text: "O(log n)", correct: false},
+ {text: "O(n)", correct: false},
+ {text: "O(n^2)", correct: false},
+ ]
+ },
+ {
+ question: "Which data structure can be used to efficiently implement a priority queue?",
+ answers: [
+ {text: "Heap", correct: true},
+ {text: "Stack", correct: false},
+ {text: "Queue", correct: false},
+ {text: "Linked List", correct: false},
+ ]
+ },
+ {
+ question: "What is the time complexity of inserting an element at the beginning of a linked list?",
+ answers: [
+ {text: "O(1)", correct: true},
+ {text: "O(log n)", correct: false},
+ {text: "O(n)", correct: false},
+ {text: "O(n^2)", correct: false},
+ ]
+ },
+ {
+ question: "What is the purpose of a linked list?",
+ answers: [
+ {text: "To store data in a linear structure with a dynamic size", correct: true},
+ {text: "To sort data efficiently", correct: false},
+ {text: "To implement recursive algorithms", correct: false},
+ {text: "To perform mathematical operations", correct: false},
+ ]
+ },
+ {
+ question: "What is a stack?",
+ answers: [
+ {text: "A data structure that follows the Last-In-First-Out (LIFO) principle", correct: true},
+ {text: "A data structure that follows the First-In-First-Out (FIFO) principle", correct: false},
+ {text: "A data structure that organizes elements in a hierarchical structure", correct: false},
+ {text: "A data structure that allows elements to be accessed in any order", correct: false},
+ ]
+ },
+ {
+ question: "What is the purpose of a binary heap?",
+ answers: [
+ {text: "To implement priority queues efficiently", correct: true},
+ {text: "To sort data in ascending order", correct: false},
+ {text: "To perform recursive algorithms", correct: false},
+ {text: "To store key-value pairs for efficient retrieval", correct: false},
+ ]
+ },
+ {
+ question: "What is a binary tree?",
+ answers: [
+ {text: "A tree data structure in which each node has at most two children", correct: true},
+ {text: "A tree data structure in which each node has exactly two children", correct: false},
+ {text: "A tree data structure with more than two children per node", correct: false},
+ {text: "A tree data structure with no children", correct: false},
+ ]
+ },
+ {
+ question: "What is a binary search tree (BST)?",
+ answers: [
+ {text: "A binary tree in which the left subtree of a node contains only nodes with keys less than the node's key and the right subtree contains only nodes with keys greater than the node's key", correct: true},
+ {text: "A binary tree that is sorted in descending order", correct: false},
+ {text: "A binary tree that contains duplicate nodes", correct: false},
+ {text: "A binary tree in which every node has exactly two children", correct: false},
+ ]
+ },
+ {
+ question: "What is a balanced binary tree?",
+ answers: [
+ {text: "A binary tree in which the height of the left and right subtrees of any node differ by at most one", correct: true},
+ {text: "A binary tree that contains only nodes with even keys", correct: false},
+ {text: "A binary tree in which every node has exactly two children", correct: false},
+ {text: "A binary tree in which all leaf nodes are at the same level", correct: false},
+ ]
+ },
+ {
+ question: "What is a graph?",
+ answers: [
+ {text: "A data structure that consists of a set of nodes (vertices) and a set of edges that connect pairs of nodes", correct: true},
+ {text: "A data structure that represents hierarchical relationships between elements", correct: false},
+ {text: "A data structure used for storing key-value pairs", correct: false},
+ {text: "A data structure that allows for efficient search, insertion, and deletion operations", correct: false},
+ ]
+ },
+ {
+ question: "What is a directed graph?",
+ answers: [
+ {text: "A graph in which the edges have a direction, indicating a one-way connection between nodes", correct: true},
+ {text: "A graph in which all nodes are connected to each other", correct: false},
+ {text: "A graph in which the edges have weights assigned to them", correct: false},
+ {text: "A graph in which the edges do not have a direction, indicating a two-way connection between nodes", correct: false},
+ ]
+ },
+ {
+ question: "What is a weighted graph?",
+ answers: [
+ {text: "A graph in which each edge is assigned a numerical value, called a weight", correct: true},
+ {text: "A graph in which the nodes have different sizes", correct: false},
+ {text: "A graph in which the nodes have different colors", correct: false},
+ {text: "A graph in which each edge is assigned a direction", correct: false},
+ ]
+ },
+ {
+ question: "What is the adjacency matrix of a graph?",
+ answers: [
+ {text: "A two-dimensional array where the value at index [i][j] represents whether there is an edge from node i to node j", correct: true},
+ {text: "A tree data structure used for storing key-value pairs", correct: false},
+ {text: "A data structure that represents hierarchical relationships between elements", correct: false},
+ {text: "A data structure used for representing binary trees", correct: false},
+ ]
+ },
+ {
+ question: "What is the depth-first search (DFS) algorithm used for in graphs?",
+ answers: [
+ {text: "To explore as far as possible along each branch before backtracking", correct: true},
+ {text: "To find the shortest path between two nodes in a weighted graph", correct: false},
+ {text: "To find the minimum spanning tree of a graph", correct: false},
+ {text: "To find the topological ordering of a directed acyclic graph (DAG)", correct: false},
+ ]
+ },
+ {
+ question: "What is the breadth-first search (BFS) algorithm used for in graphs?",
+ answers: [
+ {text: "To explore all the neighbor nodes at the present depth before moving on to the nodes at the next depth level", correct: true},
+ {text: "To find the shortest path between two nodes in a weighted graph", correct: false},
+ {text: "To find the minimum spanning tree of a graph", correct: false},
+ {text: "To find the topological ordering of a directed acyclic graph (DAG)", correct: false},
+ ]
+ },
+ {
+ question: "What is a spanning tree of a graph?",
+ answers: [
+ {text: "A subgraph that is a tree and includes all the vertices of the original graph", correct: true},
+ {text: "A tree data structure used for storing key-value pairs", correct: false},
+ {text: "A data structure that represents hierarchical relationships between elements", correct: false},
+ {text: "A data structure used for representing binary trees", correct: false},
+ ]
+ }
+
+];
+const questionElement = document.getElementById('question');
+const answerButtons = document.getElementById('answer-btn');
+const nextButton = document.getElementById('next-btn');
+let currentquinx = 0;
+let score = 0;
+let shuffledQuestions = [];
+
+function startquiz() {
+ currentquinx = 0;
+ score = 0;
+ nextButton.innerHTML = "Next";
+ shuffledQuestions = questions.sort(() => Math.random() - 0.5).slice(0, 10); // Shuffle and select 10 questions
+ ShowQuestion();
+}
+
+function ShowQuestion() {
+ resetState();
+ let currentque = shuffledQuestions[currentquinx];
+ let questionNo = currentquinx + 1;
+ questionElement.innerHTML = questionNo + ". " + currentque.question;
+ currentque.answers.forEach(answer => {
+ const button = document.createElement('button');
+ button.innerHTML = answer.text;
+ button.classList.add("btn");
+ button.addEventListener('click', () => checkAnswer(answer.correct));
+ answerButtons.appendChild(button);
+ if(answer.correct) {
+ button.dataset.correct = answer.correct;
+ }
+ button.addEventListener("click", selectAnswer);
+
+ })
+}
+
+function resetState() {
+ nextButton.style.display = 'none';
+ while (answerButtons.firstChild) {
+ answerButtons.removeChild(answerButtons.firstChild);
+ }
+}
+
+function selectAnswer(e) {
+ const selectedBtn = e.target;
+ const isCorrect = selectedBtn.dataset.correct === "true";
+
+ if (isCorrect) {
+ selectedBtn.classList.add("correct");
+ score++;
+ } else {
+ selectedBtn.classList.add("incorrect");
+ }
+
+ Array.from(answerButtons.children).forEach(button => {
+ if (button.dataset.correct === "true") {
+ button.classList.add("correct");
+ }
+ button.disabled = true;
+ });
+
+ nextButton.style.display = "block";
+}
+
+function ShowScore() {
+ resetState();
+ questionElement.innerHTML = `You scored ${score} out of ${shuffledQuestions.length} !`;
+ nextButton.innerHTML = "Play Again";
+ nextButton.style.display = "block";
+}
+
+function handleNextButton() {
+ currentquinx++;
+ if(currentquinx < shuffledQuestions.length) {
+ ShowQuestion();
+ } else {
+ ShowScore();
+ }
+}
+
+nextButton.addEventListener("click", () => {
+ if(currentquinx < shuffledQuestions.length) {
+ handleNextButton();
+ } else {
+ startquiz();
+ }
+});
+
+startquiz();
diff --git a/Games/Dsa_quiz_game/style.css b/Games/Dsa_quiz_game/style.css
new file mode 100644
index 0000000000..3fd9887f5c
--- /dev/null
+++ b/Games/Dsa_quiz_game/style.css
@@ -0,0 +1,83 @@
+*
+{
+ margin: 0;
+ padding: 0;
+ font-family: 'Poppins',sans-serif;
+ box-sizing: border-box;
+}
+body
+{
+ background: #001e4d;
+
+}
+.app
+{
+ background: #fff;
+ width: 90%;
+ max-width: 600px;
+ margin: 100px auto 0;
+ border-radius: 10px;
+ padding: 30px;
+}
+.app h1
+{
+ font-weight: 25px;
+ color: #001e4d;
+ font-weight: 600px;
+ border-bottom: 1px solid #333;
+ padding-bottom: 30px;
+}
+.quiz
+{
+ padding: 20px 0;
+}
+.quiz h2
+{
+ font-size: 18px;
+ color: #001e4d;
+ font-weight: 600px;
+}
+.btn
+{
+ background: #fff;
+ color: #222;
+ font-weight: 500px;
+ width: 100%;
+ border: 1px solid #222;
+ padding: 10px;
+ margin: 10px 0;
+ text-align: left;
+ border-radius: 4px;
+ cursor: pointer;
+ transition:all 0.5s;
+}
+
+.btn:hover:not([disabled]) {
+ background: #222;
+ color: #fff;
+}
+
+.btn:disabled {
+ cursor: no-drop;
+}
+#next-btn
+{
+ background: #001e4d;
+ color: #fff;
+ font-weight: 500px;
+ width: 150px;
+ border:0;
+ padding: 10px;
+ margin: 20px auto 0;
+ border-radius: 4px;
+ cursor: pointer;
+ display: none;
+}
+.correct
+{
+ background: #9aeabc;
+}
+.incorrect
+{
+ background: #ff9393;
+}
\ No newline at end of file
diff --git a/Games/Gravity_Simulation_Game/README.md b/Games/Gravity_Simulation_Game/README.md
new file mode 100644
index 0000000000..a20659d485
--- /dev/null
+++ b/Games/Gravity_Simulation_Game/README.md
@@ -0,0 +1,15 @@
+# **Gravity_Simulation_Game**
+
+## **Description đ**
+Observe and Differentiate between the gravitational fields of Sun, Mercury, Venus, Earth, Moon, Mars, Jupiter, Saturn, Uranus, Neptune and Pluto.
+
+## **How to play? đšī¸**
+First the user needs to select a celestial body of our solar system among the given options. Then a simulation of various balls of various shapes and colors colliding with each other and jumping under the influence of gravity is shown, until all the balls come at rest at the floor.
+This way user can feel and enjoy the diverse gravitation of the planetary bodies our solar system.
+
+## **Screenshots đ¸**
+
+
+## **Working video đš**
+https://github.com/Sara1428/GameZone/assets/146193518/8bfecb13-40d2-4d5e-b7e4-e47325c60293
+
diff --git a/Games/Gravity_Simulation_Game/index.html b/Games/Gravity_Simulation_Game/index.html
new file mode 100644
index 0000000000..7e1b92f56f
--- /dev/null
+++ b/Games/Gravity_Simulation_Game/index.html
@@ -0,0 +1,32 @@
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Games/Physics_Quizz/script.js b/Games/Physics_Quizz/script.js
new file mode 100644
index 0000000000..7d93152600
--- /dev/null
+++ b/Games/Physics_Quizz/script.js
@@ -0,0 +1,186 @@
+const quizQuestions = [
+ {
+ question: "A substance which takes the shape of its container and has a definite volume is a ",
+ options: ["solid", "liquid", "gas", "crystal"],
+ correctAnswer: "liquid"
+ },
+ {
+ question: "What happens to a gas when the temperature decreases ",
+ options: ["It expands", "It rises.", "It condenses", "It becomes less dense."],
+ correctAnswer: "It condenses"
+ },
+ {
+ question: "Any material that does not allow heat to pass through it easily is called ",
+ options: ["conductor", "expand", "contract", "insulator"],
+ correctAnswer: "insulator"
+ },
+ {
+ question: "A material through which heat and electricity flow easily is called ",
+ options: ["Resistancer", "conductor", "Short circuit", "insulator"],
+ correctAnswer: "conductor"
+ },
+ {
+ question: "If you were on the Moon, there would be a change in your ",
+ options: ["weight and mass", "weight", "mass", "voulme"],
+ correctAnswer: "weight"
+ },
+ {
+ question: "The process by which a liquid changes to a gas is called ",
+ options: ["evaporation", "condensation", "precipitation", "transpiration"],
+ correctAnswer: "evaporation"
+ },
+ {
+ question: "The ability to do work is called ",
+ options: ["rest", "force", "motion", "energy"],
+ correctAnswer: "energy"
+ },
+ {
+ question: "A force that occurs when an object rubs against another object ",
+ options: ["friction", "conduction", "thermometer", "radiation"],
+ correctAnswer: "friction"
+ },
+ {
+ question: "Something that makes an object start moving, stop moving, speed up, or slow down is a ",
+ options: ["position", "force", "effort", "load"],
+ correctAnswer: "force"
+ },
+ {
+ question: "The buildup of electric charges in one place is called ",
+ options: ["Static electricity", "Electric charge", "Electric field", "Electric circuit"],
+ correctAnswer: "Static electricity"
+ },
+ {
+ question: "The force that attracts a body toward the center of Earth, or toward any other physical body having mass.",
+ options: ["planet", "weightless", "gravity", "orbit"],
+ correctAnswer: "gravity"
+ },
+ {
+ question: "The atoms in which state shake, but don't move freely?",
+ options: ["liquid", "solid", "gas", "mixture"],
+ correctAnswer: "solid"
+ },
+ {
+ question: "An example of a gas is ",
+ options: ["chocolate syrup", "a rock", " a pencil", "helium"],
+ correctAnswer: "helium"
+ },
+ {
+ question: "The temperature at which a gas becomes a liquid is called the ",
+ options: ["freezing point", "condensation point", "boiling point", "sublimation"],
+ correctAnswer: "boiling point"
+ },
+ {
+ question: "Water freezes at what temperature?",
+ options: ["212 degrees F", "32 degrees C", "32 degrees F", "212 degrees C"],
+ correctAnswer: "32 degrees F"
+ }
+];
+
+// Variables to track quiz state
+let currentQuestionIndex = 0;
+let score = 0;
+let timeLeft = 60;
+let timerInterval;
+
+// Function to start the quiz
+function startQuiz() {
+ document.getElementById("start-button").style.display = "none";
+ displayQuestion();
+ startTimer();
+}
+
+// Function to display a question and its options
+function displayQuestion() {
+ const currentQuestion = quizQuestions[currentQuestionIndex];
+ const questionText = document.getElementById("question-text");
+ const answerButtons = document.getElementById("answer-buttons");
+
+ // Clear previous question and answer options
+ questionText.innerHTML = "";
+ answerButtons.innerHTML = "";
+
+ // Display the current question
+ questionText.innerHTML = currentQuestion.question;
+
+ // Create answer buttons for each option
+ currentQuestion.options.forEach(option => {
+ const button = document.createElement("button");
+ button.innerText = option;
+ button.classList.add("answer-button");
+ answerButtons.appendChild(button);
+
+ // Add click event listener to check the answer
+ button.addEventListener("click", function () {
+ checkAnswer(option, button);
+ });
+ });
+}
+
+// Function to check the selected answer
+function checkAnswer(selectedOption, button) {
+ const currentQuestion = quizQuestions[currentQuestionIndex];
+ const answerButtons = document.getElementById("answer-buttons");
+
+ // Check if the selected answer is correct
+ if (selectedOption === currentQuestion.correctAnswer) {
+ score++;
+ button.style.backgroundColor = "darkgreen";
+ } else {
+ // Indicate the selected answer is wrong
+ button.style.backgroundColor = "red";
+
+ // Display the correct answer if the selected answer is incorrect
+ const correctAnswerElement = document.createElement("div");
+ correctAnswerElement.classList.add("correct-answer");
+ correctAnswerElement.innerText = `Correct Answer: ${currentQuestion.correctAnswer}`;
+ answerButtons.appendChild(correctAnswerElement);
+ }
+
+ // Move to the next question or end the quiz after a short delay
+ setTimeout(() => {
+ currentQuestionIndex++;
+ if (currentQuestionIndex < quizQuestions.length) {
+ displayQuestion();
+ } else {
+ endQuiz();
+ }
+ }, 1000);
+}
+
+// Function to start the timer
+function startTimer() {
+ // Update the timer text immediately
+ document.getElementById("timer").textContent = timeLeft;
+
+ timerInterval = setInterval(function () {
+ timeLeft--;
+
+ // Update the timer text
+ document.getElementById("timer").textContent = timeLeft;
+
+ // End the quiz if time runs out
+ if (timeLeft <= 0) {
+ endQuiz();
+ }
+ }, 1000);
+}
+
+// Function to end the quiz
+function endQuiz() {
+ // Stop the timer
+ clearInterval(timerInterval);
+
+ // Calculate the score percentage
+ const scorePercentage = (score / quizQuestions.length) * 100;
+
+ // Display the final score
+ const questionContainer = document.getElementById("question-container");
+ questionContainer.innerHTML = `
+
Quiz Completed!
+
Your Score: ${score} out of ${quizQuestions.length}
+
Score Percentage: ${scorePercentage}%
+ `;
+}
+
+
+document.getElementById("start-button").addEventListener("click", startQuiz);
diff --git a/Games/Physics_Quizz/style.css b/Games/Physics_Quizz/style.css
new file mode 100644
index 0000000000..bbec90d511
--- /dev/null
+++ b/Games/Physics_Quizz/style.css
@@ -0,0 +1,75 @@
+body {
+ background-color: #f2f2f2;
+ font-family: Arial, sans-serif;
+ display: flex;
+ justify-content: center;
+ align-items: center;
+ height: 100vh;
+ background-image: url('./background-image/backgroundimage.jpeg');
+ background-size: cover;
+
+}
+
+.quiz-container {
+ max-width: 500px;
+ background-color: #5c50dd;
+ border-radius: 10px;
+ padding: 20px;
+ animation: fadeIn 1s ease-in-out;
+ box-shadow: 0 4px 6px rgba(25, 89, 172, 0.1);
+ transition: box-shadow 0.3s ease-in-out;
+}
+
+h1 {
+ text-align: center;
+
+}
+
+#question-container {
+ margin-bottom: 20px;
+}
+
+#question-text {
+ font-size: 18px;
+ margin-bottom: 10px;
+}
+
+#answer-buttons {
+ display: grid;
+ grid-template-columns: repeat(2, 1fr);
+ grid-gap: 10px;
+}
+
+button {
+ height: 40px;
+ font-size: 16px;
+ background-color: #dfdedf;
+ border: none;
+ border-radius: 5px;
+ cursor: pointer;
+}
+
+button:hover {
+ background-color: #26c488;
+}
+
+#controls-container {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ font-weight: "bold";
+}
+
+#timer-container {
+ display: flex;
+ align-items: center;
+}
+
+#timer-text {
+ font-size: 14px;
+}
+
+#timer {
+ font-weight: bold;
+ margin-left: 5px;
+}
\ No newline at end of file
diff --git a/Games/Taash Game/README.md b/Games/Taash Game/README.md
new file mode 100644
index 0000000000..747d250379
--- /dev/null
+++ b/Games/Taash Game/README.md
@@ -0,0 +1,12 @@
+# Taash Game
+The player has to get a hand with a value as close to 21 as possible without going over.
+A hand that goes over 21 is a bust.
+The players in a Taash Game plays against the dealer. Each player has to beat the dealer's hand in order to win.
+
+In Taash Game, the suits have no meaning.
+1. Number cards have a value equal to their number.
+2. All the picture cards (Jacks, Queens, and Kings) are worth 10.
+3. Aces are worth 1.
+4. The table keeps a record of total wins,loses and draws
+5. Click on "Restart" Button to start a new game
+6. Click on "Deal" Button to clear the field
diff --git a/Games/Taash Game/images/10.png b/Games/Taash Game/images/10.png
new file mode 100644
index 0000000000..01be5daa37
Binary files /dev/null and b/Games/Taash Game/images/10.png differ
diff --git a/Games/Taash Game/images/2.png b/Games/Taash Game/images/2.png
new file mode 100644
index 0000000000..2f1d24063f
Binary files /dev/null and b/Games/Taash Game/images/2.png differ
diff --git a/Games/Taash Game/images/3.png b/Games/Taash Game/images/3.png
new file mode 100644
index 0000000000..7c804ae15b
Binary files /dev/null and b/Games/Taash Game/images/3.png differ
diff --git a/Games/Taash Game/images/4.png b/Games/Taash Game/images/4.png
new file mode 100644
index 0000000000..ea50674261
Binary files /dev/null and b/Games/Taash Game/images/4.png differ
diff --git a/Games/Taash Game/images/5.png b/Games/Taash Game/images/5.png
new file mode 100644
index 0000000000..f456f1e71d
Binary files /dev/null and b/Games/Taash Game/images/5.png differ
diff --git a/Games/Taash Game/images/6.png b/Games/Taash Game/images/6.png
new file mode 100644
index 0000000000..46b86bcc59
Binary files /dev/null and b/Games/Taash Game/images/6.png differ
diff --git a/Games/Taash Game/images/7.png b/Games/Taash Game/images/7.png
new file mode 100644
index 0000000000..1a21883717
Binary files /dev/null and b/Games/Taash Game/images/7.png differ
diff --git a/Games/Taash Game/images/8.png b/Games/Taash Game/images/8.png
new file mode 100644
index 0000000000..277705b131
Binary files /dev/null and b/Games/Taash Game/images/8.png differ
diff --git a/Games/Taash Game/images/9.png b/Games/Taash Game/images/9.png
new file mode 100644
index 0000000000..b3fdc074b0
Binary files /dev/null and b/Games/Taash Game/images/9.png differ
diff --git a/Games/Taash Game/images/A.png b/Games/Taash Game/images/A.png
new file mode 100644
index 0000000000..bb25fee819
Binary files /dev/null and b/Games/Taash Game/images/A.png differ
diff --git a/Games/Taash Game/images/J.png b/Games/Taash Game/images/J.png
new file mode 100644
index 0000000000..7960a94e7a
Binary files /dev/null and b/Games/Taash Game/images/J.png differ
diff --git a/Games/Taash Game/images/K.png b/Games/Taash Game/images/K.png
new file mode 100644
index 0000000000..c9d1c990ea
Binary files /dev/null and b/Games/Taash Game/images/K.png differ
diff --git a/Games/Taash Game/images/Q.png b/Games/Taash Game/images/Q.png
new file mode 100644
index 0000000000..6499247e29
Binary files /dev/null and b/Games/Taash Game/images/Q.png differ
diff --git a/Games/Taash Game/index.html b/Games/Taash Game/index.html
new file mode 100644
index 0000000000..2d05937546
--- /dev/null
+++ b/Games/Taash Game/index.html
@@ -0,0 +1,62 @@
+
+
+
+
+ Taash Game
+
+
+
+
+
+