Upload 29 files

# Maze Data Structure in Java

This is a Java project that visualizes maze-solving algorithms using basic data structures like stacks, queues, and graphs.

## Features

- Visual simulation of maze traversal
- Demonstrates core data structures and recursion
- Useful for educational purposes

## How to Run

1. Clone or download the repository.
2. Compile the Java files:
javac MazeSolver.java
java MazeSolver
3. Alternatively, run the provided .jar file if available.

## License

This project is licensed under the MIT License.

mazeDataStructure/mazeDeneme/.gitignore

@@ -0,0 +1,29 @@
+### IntelliJ IDEA ###
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

mazeDataStructure/mazeDeneme/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

mazeDataStructure/mazeDeneme/.idea/.name

@@ -0,0 +1 @@
+DataStructuresProject

mazeDataStructure/mazeDeneme/.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_24" default="true" project-jdk-name="openjdk-24" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

mazeDataStructure/mazeDeneme/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/mazeDeneme.iml" filepath="$PROJECT_DIR$/mazeDeneme.iml" />
+    </modules>
+  </component>
+</project>

mazeDataStructure/mazeDeneme/.idea/workspace.xml

@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="b5072dfa-d52e-49ae-8fc0-689c044ffaa8" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="FileTemplateManagerImpl">
+    <option name="RECENT_TEMPLATES">
+      <list>
+        <option value="Class" />
+      </list>
+    </option>
+  </component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 8
+}</component>
+  <component name="ProjectId" id="2wApFYymmxPaPZVZ6JOtcKgORsc" />
+  <component name="ProjectViewState">
+    <option name="foldersAlwaysOnTop" value="false" />
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+    <option name="sortKey" value="BY_TIME_DESCENDING" />
+  </component>
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;Application.InputScreen.executor&quot;: &quot;Run&quot;,
+    &quot;Application.Main.executor&quot;: &quot;Run&quot;,
+    &quot;Application.Maze.executor&quot;: &quot;Run&quot;,
+    &quot;Application.MazeGame.executor&quot;: &quot;Run&quot;,
+    &quot;Application.MazeGenerator.executor&quot;: &quot;Run&quot;,
+    &quot;Application.MazeSwing.executor&quot;: &quot;Run&quot;,
+    &quot;JavaClassFindUsagesOptions.isSearchForTextOccurrences&quot;: &quot;false&quot;,
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;kotlin-language-version-configured&quot;: &quot;true&quot;,
+    &quot;last_opened_file_path&quot;: &quot;C:/Users/anilu/Documents/denizProje&quot;,
+    &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
+    &quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
+    &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
+    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
+    &quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
+    &quot;onboarding.tips.debug.path&quot;: &quot;C:/Users/anilu/IdeaProjects/mazeDeneme/src/Main.java&quot;,
+    &quot;project.structure.last.edited&quot;: &quot;Project&quot;,
+    &quot;project.structure.proportion&quot;: &quot;0.0&quot;,
+    &quot;project.structure.side.proportion&quot;: &quot;0.0&quot;,
+    &quot;settings.editor.selected.configurable&quot;: &quot;preferences.lookFeel&quot;,
+    &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
+  }
+}</component>
+  <component name="SharedIndexes">
+    <attachedChunks>
+      <set>
+        <option value="bundled-jdk-9823dce3aa75-a94e463ab2e7-intellij.indexing.shared.core-IU-243.26053.27" />
+        <option value="bundled-js-predefined-d6986cc7102b-1632447f56bf-JavaScript-IU-243.26053.27" />
+      </set>
+    </attachedChunks>
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="b5072dfa-d52e-49ae-8fc0-689c044ffaa8" name="Changes" comment="" />
+      <created>1745494132492</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1745494132492</updated>
+      <workItem from="1745494133731" duration="749000" />
+      <workItem from="1745494899626" duration="3300000" />
+      <workItem from="1745573609389" duration="4342000" />
+      <workItem from="1745582449579" duration="1716000" />
+      <workItem from="1745684545735" duration="10368000" />
+      <workItem from="1745831618109" duration="12238000" />
+      <workItem from="1745873259840" duration="1359000" />
+      <workItem from="1745932611845" duration="12000" />
+      <workItem from="1745933062425" duration="33307000" />
+      <workItem from="1746098087868" duration="251000" />
+      <workItem from="1746104724431" duration="3438000" />
+      <workItem from="1746108904522" duration="7272000" />
+      <workItem from="1746182825310" duration="6584000" />
+      <workItem from="1746195297418" duration="1770000" />
+      <workItem from="1746204440746" duration="2850000" />
+      <workItem from="1746208079372" duration="5143000" />
+      <workItem from="1746267018747" duration="1521000" />
+      <workItem from="1746284021289" duration="10472000" />
+      <workItem from="1746299074166" duration="318000" />
+      <workItem from="1746362154867" duration="1013000" />
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+</project>

mazeDataStructure/mazeDeneme/game_log.txt

@@ -0,0 +1,400 @@
+=== OYUN BİTTİ ===
+Kazanan Ajan: Mavi Agent (ID: 1)
+Toplam Raunt Sayısı: 106
+
+Mavi Agent (ID: 1)
+- Adım Sayısı: 54
+- Tuzak Sayısı: 1
+- Power-Up Kullanımı: 4
+- Hareketler: (0, 0)(0, 1)(0, 2)(0, 3)(0, 4)(1, 4)(1, 5)(1, 6)(1, 7)(2, 7)(2, 8)(1, 8)(0, 8)(0, 7)(0, 8)(0, 9)(1, 9)(1, 10)(1, 9)(1, 10)(2, 10)(2, 9)(2, 8)(1, 8)(0, 8)(0, 9)(1, 9)(1, 10)(2, 10)(2, 9)(3, 9)(3, 8)(4, 8)(5, 8)(5, 9)(5, 10)(4, 10)(4, 11)(4, 12)(4, 13)(4, 14)(5, 14)(5, 13)(5, 12)(6, 12)(7, 12)(7, 11)(6, 11)(6, 10)(6, 8)(7, 8)(7, 7)
+--------------------------
+Turuncu Agent (ID: 2)
+- Adım Sayısı: 53
+- Tuzak Sayısı: 2
+- Power-Up Kullanımı: 7
+- Hareketler: (14, 14)(14, 13)(13, 12)(13, 13)(13, 14)(12, 14)(11, 14)(10, 14)(10, 13)(10, 12)(11, 12)(11, 11)(10, 11)(9, 11)(9, 10)(9, 9)(9, 8)(9, 7)(9, 6)(9, 7)(9, 6)(10, 6)(11, 6)(11, 7)(10, 7)(10, 8)(11, 8)(12, 8)(13, 8)(13, 7)(12, 7)(12, 6)(13, 6)(13, 5)(13, 6)(13, 5)(14, 5)(14, 4)(14, 3)(14, 2)(14, 1)(14, 0)(14, 1)(14, 2)(14, 1)(14, 0)(13, 0)(13, 1)(13, 2)(13, 3)(13, 4)
+--------------------------
+=== OYUN BİTTİ ===
+Kazanan Ajan: Turuncu Agent (ID: 2)
+Toplam Raunt Sayısı: 47
+
+Turuncu Agent (ID: 2)
+- Adım Sayısı: 24
+- Tuzak Sayısı: 0
+- Power-Up Kullanımı: 0
+- Hareketler: (9, 9)(8, 9)(8, 8)(9, 8)(9, 7)(8, 7)(7, 7)(7, 8)(7, 9)(6, 9)(5, 9)(4, 9)(3, 9)(2, 9)(1, 9)(0, 9)(0, 8)(1, 8)(2, 8)(2, 7)(2, 6)(3, 6)(4, 6)(4, 5)(5, 5)
+--------------------------
+Mavi Agent (ID: 1)
+- Adım Sayısı: 24
+- Tuzak Sayısı: 0
+- Power-Up Kullanımı: 0
+- Hareketler: (0, 0)(1, 0)(2, 0)(2, 1)(2, 2)(3, 2)(3, 1)(4, 1)(5, 1)(6, 1)(6, 2)(5, 2)(4, 2)(4, 3)(4, 4)(5, 4)(6, 4)(6, 3)(7, 3)(7, 2)(7, 1)(8, 1)(8, 0)(9, 0)(9, 1)
+--------------------------
+=== OYUN BİTTİ ===
+Kazanan Ajan: Turuncu Agent (ID: 2)
+Toplam Raunt Sayısı: 15
+
+Turuncu Agent (ID: 2)
+- Adım Sayısı: 8
+- Tuzak Sayısı: 0
+- Power-Up Kullanımı: 1
+- Hareketler: (9, 9)(8, 9)(7, 9)(6, 9)(5, 9)(5, 8)(5, 7)(5, 6)(5, 5)
+--------------------------
+Mavi Agent (ID: 1)
+- Adım Sayısı: 8
+- Tuzak Sayısı: 0
+- Power-Up Kullanımı: 0
+- Hareketler: (0, 0)(0, 1)(1, 1)(1, 2)(0, 2)(0, 3)(1, 3)(2, 3)(2, 4)
+--------------------------
+=== OYUN BİTTİ ===
+Kazanan Ajan: Turuncu Agent (ID: 2)
+Toplam Raunt Sayısı: 23
+
+Turuncu Agent (ID: 2)
+- Adım Sayısı: 12
+- Tuzak Sayısı: 0
+- Power-Up Kullanımı: 0
+- Hareketler: (9, 9)(8, 9)(7, 9)(7, 8)(6, 8)(5, 8)(5, 7)(6, 7)(7, 7)(7, 6)(6, 6)(5, 6)(5, 5)
+--------------------------
+Mavi Agent (ID: 1)
+- Adım Sayısı: 12
+- Tuzak Sayısı: 1
+- Power-Up Kullanımı: 0
+- Hareketler: (0, 0)(0, 1)(1, 1)(1, 0)(2, 0)(2, 1)(3, 1)(3, 0)(4, 0)(4, 2)
+--------------------------
+=== OYUN BİTTİ ===
+Kazanan Ajan: Turuncu Agent (ID: 2)
+Toplam Raunt Sayısı: 85
+
+Turuncu Agent (ID: 2)
+- Adım Sayısı: 43
+- Tuzak Sayısı: 4
+- Power-Up Kullanımı: 1
+- Hareketler: (14, 9)(14, 8)(14, 6)(14, 5)(14, 4)(14, 3)(13, 3)(13, 2)(14, 2)(14, 1)(14, 0)(12, 0)(12, 1)(12, 3)(12, 4)(13, 4)(13, 5)(13, 6)(13, 7)(13, 8)(12, 8)(11, 8)(11, 9)(10, 9)(10, 8)(10, 7)(11, 6)(10, 6)(9, 6)(8, 6)(7, 6)(7, 5)
+--------------------------
+Mavi Agent (ID: 1)
+- Adım Sayısı: 43
+- Tuzak Sayısı: 4
+- Power-Up Kullanımı: 0
+- Hareketler: (0, 0)(0, 1)(1, 1)(1, 2)(1, 3)(2, 3)(2, 4)(2, 5)(3, 5)(3, 4)(3, 3)(3, 2)(2, 1)(3, 0)(3, 1)(4, 1)(4, 2)(5, 2)(5, 3)(5, 4)(6, 4)(6, 3)(7, 2)(8, 2)(8, 1)(8, 0)(9, 0)(9, 1)(10, 1)(10, 0)(11, 0)(11, 1)(11, 2)(10, 2)(10, 3)
+--------------------------
+=== OYUN BİTTİ ===
+Kazanan Ajan: Turuncu Agent (ID: 2)
+Toplam Raunt Sayısı: 15
+
+Turuncu Agent (ID: 2)
+- Adım Sayısı: 8
+- Tuzak Sayısı: 0
+- Power-Up Kullanımı: 0
+- Hareketler: (9, 9)(8, 9)(7, 9)(7, 8)(6, 8)(6, 7)(6, 6)(5, 6)(5, 5)
+--------------------------
+Mavi Agent (ID: 1)
+- Adım Sayısı: 8
+- Tuzak Sayısı: 0
+- Power-Up Kullanımı: 0
+- Hareketler: (0, 0)(1, 0)(1, 1)(1, 2)(0, 2)(0, 3)(0, 4)(0, 5)(0, 6)
+--------------------------
+=== OYUN BİTTİ ===
+Kazanan Ajan: Turuncu Agent (ID: 2)
+Toplam Raunt Sayısı: 59
+
+Turuncu Agent (ID: 2)
+- Adım Sayısı: 30
+- Tuzak Sayısı: 3
+- Power-Up Kullanımı: 3
+- Hareketler: (9, 9)(8, 9)(7, 9)(6, 9)(6, 8)(6, 7)(6, 6)(7, 6)(7, 6)(7, 7)(7, 6)(7, 7)(8, 7)(9, 7)(9, 6)(9, 5)(9, 4)(7, 4)(6, 3)(5, 3)(5, 4)(5, 5)
+--------------------------
+Mavi Agent (ID: 1)
+- Adım Sayısı: 30
+- Tuzak Sayısı: 0
+- Power-Up Kullanımı: 0
+- Hareketler: (0, 0)(0, 1)(0, 2)(0, 3)(0, 4)(1, 4)(1, 3)(1, 2)(2, 2)(2, 3)(3, 3)(4, 3)(4, 4)(3, 4)(2, 4)(2, 5)(1, 5)(1, 6)(0, 6)(0, 7)(0, 8)(1, 8)(1, 9)(2, 9)(3, 9)(3, 8)(4, 8)(4, 9)(5, 9)(5, 8)(5, 7)
+--------------------------
+=== Game Over ===
+Winner Agent: Blue Agent (ID: 1)
+Number of rount played: 22
+
+Blue Agent (ID: 1)
+- Step number: 12
+- Trap number: 0
+- Power-Up usage: 0
+- Moves: (0, 0)(1, 0)(2, 0)(3, 0)(3, 1)(3, 2)(4, 2)(4, 3)(5, 3)(5, 4)(4, 4)(4, 5)(5, 5)
+--------------------------
+Orange Agent (ID: 2)
+- Step number: 11
+- Trap number: 1
+- Power-Up usage: 0
+- Moves: (9, 9)(9, 8)(8, 8)(7, 8)(6, 8)(6, 7)(8, 7)(9, 7)(9, 6)
+--------------------------
+=== Game Over ===
+Winner Agent: Orange Agent (ID: 2)
+Number of rount played: 59
+
+Orange Agent (ID: 2)
+- Step number: 30
+- Trap number: 1
+- Power-Up usage: 0
+- Moves: (9, 9)(9, 8)(9, 7)(9, 6)(9, 5)(9, 4)(9, 3)(9, 2)(8, 2)(8, 1)(9, 1)(9, 0)(8, 0)(6, 0)(6, 1)(7, 1)(7, 2)(7, 3)(7, 4)(8, 4)(8, 5)(7, 5)(6, 5)(6, 4)(5, 4)(4, 4)(4, 5)(5, 5)
+--------------------------
+Blue Agent (ID: 1)
+- Step number: 30
+- Trap number: 1
+- Power-Up usage: 1
+- Moves: (0, 0)(1, 1)(0, 1)(0, 2)(0, 3)(0, 4)(0, 5)(0, 6)(1, 6)(1, 5)(1, 4)(1, 3)(1, 2)(2, 2)(2, 1)(3, 1)(4, 1)(5, 1)(5, 2)(4, 2)(4, 3)(3, 3)(3, 4)(3, 5)(2, 5)(2, 6)(2, 7)(2, 8)
+--------------------------
+=== Game Over ===
+Winner Agent: Orange Agent (ID: 2)
+Number of rount played: 31
+
+Orange Agent (ID: 2)
+- Step number: 16
+- Trap number: 0
+- Power-Up usage: 0
+- Moves: (9, 9)(8, 9)(7, 9)(7, 8)(8, 8)(8, 7)(8, 6)(8, 5)(9, 5)(9, 4)(8, 4)(7, 4)(7, 5)(6, 5)(6, 4)(5, 4)(5, 5)
+--------------------------
+Blue Agent (ID: 1)
+- Step number: 16
+- Trap number: 1
+- Power-Up usage: 0
+- Moves: (0, 0)(1, 0)(1, 1)(0, 1)(0, 2)(0, 3)(1, 3)(2, 3)(2, 2)(2, 1)(3, 1)(3, 0)(4, 0)(4, 1)
+--------------------------
+=== Game Over ===
+Winner Agent: Blue Agent (ID: 1)
+Number of rount played: 22
+
+Blue Agent (ID: 1)
+- Step number: 12
+- Trap number: 1
+- Power-Up usage: 0
+- Moves: (0, 0)(1, 0)(2, 0)(2, 1)(1, 1)(1, 2)(1, 3)(2, 3)(3, 3)(3, 4)(4, 4)(5, 4)(5, 5)
+--------------------------
+Orange Agent (ID: 2)
+- Step number: 11
+- Trap number: 0
+- Power-Up usage: 0
+- Moves: (9, 9)(9, 8)(8, 8)(7, 8)(6, 8)(6, 9)(5, 9)(5, 8)(5, 7)(6, 7)(7, 7)(7, 6)
+--------------------------
+=== Game Over ===
+Winner Agent: Orange Agent (ID: 2)
+Number of rount played: 27
+
+Orange Agent (ID: 2)
+- Step number: 14
+- Trap number: 0
+- Power-Up usage: 0
+- Moves: null(9, 9)(9, 8)(9, 7)(9, 6)(8, 6)(8, 7)(7, 7)(7, 6)(7, 5)(8, 5)(8, 4)(7, 4)(6, 4)(6, 5)
+--------------------------
+Blue Agent (ID: 1)
+- Step number: 14
+- Trap number: 0
+- Power-Up usage: 1
+- Moves: null(0, 0)(1, 0)(2, 0)(3, 0)(3, 1)(4, 1)(5, 1)(5, 2)(5, 3)(5, 4)(4, 4)(3, 4)(3, 5)(3, 6)
+--------------------------
+=== Game Over ===
+Winner Agent: Orange Agent (ID: 2)
+Number of rount played: 23
+
+Orange Agent (ID: 2)
+- Step number: 12
+- Trap number: 0
+- Power-Up usage: 0
+- Moves: null(9, 9)(8, 9)(8, 8)(8, 7)(9, 7)(9, 6)(8, 6)(7, 6)(7, 5)(6, 5)(6, 6)(5, 6)
+--------------------------
+Blue Agent (ID: 1)
+- Step number: 12
+- Trap number: 0
+- Power-Up usage: 0
+- Moves: null(0, 0)(0, 1)(0, 2)(0, 3)(1, 3)(1, 4)(1, 5)(0, 5)(0, 6)(0, 7)(0, 8)(1, 8)
+--------------------------
+=== Game Over ===
+Winner Agent: Blue Agent (ID: 1)
+Number of rount played: 66
+
+Blue Agent (ID: 1)
+- Step number: 34
+- Trap number: 2
+- Power-Up usage: 1
+- Moves: null(0, 0)(0, 1)(1, 1)(1, 2)(2, 2)(2, 3)(1, 3)(1, 4)(0, 4)(0, 5)(1, 5)(2, 5)(2, 6)(1, 6)(0, 6)(0, 7)(0, 8)(0, 9)(1, 9)(2, 9)(2, 8)(2, 7)(3, 7)(4, 7)(4, 6)(5, 6)(6, 6)(6, 5)
+--------------------------
+Orange Agent (ID: 2)
+- Step number: 33
+- Trap number: 1
+- Power-Up usage: 2
+- Moves: null(9, 9)(8, 9)(8, 8)(9, 8)(9, 7)(9, 6)(9, 5)(9, 4)(8, 4)(8, 5)(8, 6)(7, 6)(7, 5)(7, 4)(7, 3)(8, 3)(9, 3)(9, 2)(9, 3)(9, 2)(9, 1)(8, 1)(8, 2)(8, 3)(9, 3)(9, 2)(9, 1)(8, 1)(8, 0)(7, 0)
+--------------------------
+=== Game Over ===
+Winner Agent: Blue Agent (ID: 1)
+Number of rount played: 70
+
+Blue Agent (ID: 1)
+- Step number: 36
+- Trap number: 2
+- Power-Up usage: 0
+- Moves: null(0, 0)(1, 0)(2, 0)(3, 0)(4, 0)(5, 0)(5, 1)(6, 1)(6, 2)(5, 2)(5, 3)(6, 3)(7, 3)(8, 3)(8, 4)(9, 4)(9, 5)(9, 6)(9, 7)(8, 7)(7, 7)(7, 6)(8, 6)(8, 5)(7, 5)(7, 4)(6, 4)(6, 5)(6, 6)(5, 6)
+--------------------------
+Orange Agent (ID: 2)
+- Step number: 35
+- Trap number: 1
+- Power-Up usage: 2
+- Moves: null(9, 9)(8, 9)(8, 8)(7, 8)(6, 8)(6, 7)(5, 7)(5, 8)(5, 9)(4, 9)(3, 9)(2, 9)(1, 9)(0, 9)(0, 8)(1, 8)(1, 7)(0, 7)(0, 6)(1, 6)(2, 6)(2, 7)(3, 7)(4, 7)(4, 6)(3, 6)(3, 5)(2, 5)(3, 5)(2, 5)(1, 5)(2, 5)
+--------------------------
+=== Game Over ===
+Winner Agent: Orange Agent (ID: 2)
+Number of rount played: 39
+
+Orange Agent (ID: 2)
+- Step number: 20
+- Trap number: 0
+- Power-Up usage: 4
+- Moves: null(9, 9)(9, 8)(9, 7)(9, 6)(9, 5)(9, 4)(8, 4)(8, 5)(7, 5)(6, 5)(6, 4)(7, 4)(7, 3)(7, 2)(7, 3)(7, 2)(6, 2)(6, 3)(5, 3)(5, 4)
+--------------------------
+Blue Agent (ID: 1)
+- Step number: 20
+- Trap number: 1
+- Power-Up usage: 0
+- Moves: null(0, 0)(1, 0)(2, 0)(2, 1)(2, 2)(1, 2)(0, 2)(0, 3)(1, 3)(1, 4)(0, 4)(0, 5)(1, 5)(2, 5)(2, 6)(1, 6)(0, 6)
+--------------------------
+=== Game Over ===
+Winner Agent: Orange Agent (ID: 2)
+Number of rount played: 25
+
+Orange Agent (ID: 2)
+- Step number: 13
+- Trap number: 1
+- Power-Up usage: 0
+- Moves: null(9, 9)(9, 8)(9, 7)(8, 7)(8, 6)(8, 5)(7, 5)(7, 4)(6, 4)(5, 4)
+--------------------------
+Blue Agent (ID: 1)
+- Step number: 13
+- Trap number: 0
+- Power-Up usage: 0
+- Moves: null(0, 0)(1, 0)(1, 1)(1, 2)(1, 3)(0, 3)(0, 4)(0, 5)(0, 6)(1, 6)(2, 6)(2, 5)(1, 5)
+--------------------------
+=== Game Over ===
+Winner Agent: Orange Agent (ID: 2)
+Number of rount played: 19
+
+Orange Agent (ID: 2)
+- Step number: 10
+- Trap number: 0
+- Power-Up usage: 0
+- Moves: null(9, 9)(8, 9)(8, 8)(7, 8)(7, 7)(6, 7)(6, 6)(7, 6)(7, 5)(6, 5)
+--------------------------
+Blue Agent (ID: 1)
+- Step number: 10
+- Trap number: 0
+- Power-Up usage: 0
+- Moves: null(0, 0)(1, 0)(2, 0)(2, 1)(1, 1)(1, 2)(0, 2)(0, 3)(0, 4)(1, 4)
+--------------------------
+=== Game Over ===
+Winner Agent: Orange Agent (ID: 2)
+Number of rount played: 63
+
+Orange Agent (ID: 2)
+- Step number: 32
+- Trap number: 1
+- Power-Up usage: 1
+- Moves: (9, 9)(9, 8)(8, 8)(7, 8)(7, 7)(7, 6)(8, 6)(8, 7)(9, 7)(9, 6)(9, 5)(8, 5)(7, 5)(7, 4)(6, 4)(6, 3)(7, 3)(7, 2)(9, 2)(9, 1)(8, 1)(7, 1)(7, 0)(6, 0)(6, 1)(6, 2)(5, 2)(5, 3)(5, 4)(5, 5)
+--------------------------
+Blue Agent (ID: 1)
+- Step number: 32
+- Trap number: 1
+- Power-Up usage: 2
+- Moves: (0, 0)(0, 1)(0, 2)(0, 3)(0, 4)(0, 5)(0, 6)(0, 7)(0, 8)(0, 9)(1, 9)(2, 9)(3, 9)(3, 7)(4, 7)(5, 7)(5, 8)(6, 8)(6, 9)(7, 9)(8, 9)(9, 9)(9, 8)(9, 7)(9, 6)(9, 5)(8, 5)(8, 4)(8, 3)(9, 3)
+--------------------------
+=== Game Over ===
+Winner Agent: Orange Agent (ID: 2)
+Number of rount played: 7
+
+Orange Agent (ID: 2)
+- Step number: 4
+- Trap number: 0
+- Power-Up usage: 0
+- Moves: (4, 4)(4, 3)(4, 2)(3, 2)(2, 2)
+--------------------------
+Blue Agent (ID: 1)
+- Step number: 4
+- Trap number: 0
+- Power-Up usage: 0
+- Moves: (0, 0)(1, 0)(2, 0)(3, 0)(3, 1)
+--------------------------
+=== Game Over ===
+Winner Agent: Orange Agent (ID: 2)
+Number of rount played: 27
+
+Orange Agent (ID: 2)
+- Step number: 14
+- Trap number: 1
+- Power-Up usage: 0
+- Moves: (9, 9)(9, 8)(8, 8)(8, 7)(9, 7)(9, 5)(8, 5)(7, 5)(7, 6)(6, 6)(5, 6)(5, 5)
+--------------------------
+Blue Agent (ID: 1)
+- Step number: 14
+- Trap number: 0
+- Power-Up usage: 1
+- Moves: (0, 0)(1, 0)(2, 0)(3, 0)(4, 0)(4, 1)(5, 1)(6, 1)(6, 0)(7, 0)(8, 0)(9, 0)(9, 1)(9, 2)(9, 3)
+--------------------------
+=== Game Over ===
+Winner Agent: Blue Agent (ID: 1)
+Number of rount played: 42
+
+Blue Agent (ID: 1)
+- Step number: 22
+- Trap number: 2
+- Power-Up usage: 1
+- Moves: (0, 0)(1, 0)(1, 1)(0, 1)(0, 2)(1, 3)(2, 3)(2, 2)(3, 2)(4, 3)(5, 3)(6, 3)(6, 4)(7, 4)(7, 5)(6, 5)(5, 5)
+--------------------------
+Orange Agent (ID: 2)
+- Step number: 21
+- Trap number: 1
+- Power-Up usage: 0
+- Moves: (9, 9)(8, 9)(7, 9)(6, 9)(5, 9)(4, 9)(3, 9)(2, 9)(0, 9)(0, 8)(1, 8)(2, 8)(2, 7)(3, 7)(3, 8)(4, 8)(4, 7)(4, 6)(4, 5)
+--------------------------
+=== Game Over ===
+Winner Agent: Orange Agent (ID: 2)
+Number of rount played: 27
+
+Orange Agent (ID: 2)
+- Step number: 14
+- Trap number: 0
+- Power-Up usage: 4
+- Moves: (9, 9)(8, 9)(7, 9)(7, 8)(8, 8)(9, 8)(9, 7)(9, 6)(9, 5)(8, 5)(7, 5)(6, 5)(7, 5)(6, 5)(5, 5)
+--------------------------
+Blue Agent (ID: 1)
+- Step number: 14
+- Trap number: 1
+- Power-Up usage: 0
+- Moves: (0, 0)(0, 1)(0, 2)(0, 3)(1, 3)(2, 3)(3, 3)(3, 2)(5, 2)(6, 2)(7, 2)(7, 1)
+--------------------------
+=== Game Over ===
+Winner Agent: Orange Agent (ID: 2)
+Number of rount played: 23
+
+Orange Agent (ID: 2)
+- Step number: 12
+- Trap number: 0
+- Power-Up usage: 0
+- Moves: (9, 9)(8, 9)(8, 8)(9, 8)(9, 7)(8, 7)(8, 6)(8, 5)(7, 5)(7, 6)(6, 6)(6, 5)(5, 5)
+--------------------------
+Blue Agent (ID: 1)
+- Step number: 12
+- Trap number: 0
+- Power-Up usage: 3
+- Moves: (0, 0)(1, 0)(2, 0)(3, 0)(3, 1)(4, 1)(4, 0)(5, 0)(6, 0)(6, 1)(6, 2)(6, 3)(6, 4)
+--------------------------
+=== Game Over ===
+Winner Agent: Orange Agent (ID: 2)
+Number of rount played: 215
+
+Orange Agent (ID: 2)
+- Step number: 108
+- Trap number: 7
+- Power-Up usage: 4
+- Moves: (19, 19)(19, 18)(18, 18)(17, 19)(16, 19)(16, 18)(16, 17)(15, 17)(15, 16)(16, 16)(17, 16)(17, 15)(17, 14)(16, 14)(16, 13)(17, 13)(17, 12)(14, 12)(14, 13)(15, 14)(14, 14)(13, 14)(13, 13)(13, 12)(12, 12)(12, 11)(12, 10)(12, 9)(13, 9)(13, 8)(14, 8)(14, 7)(14, 6)(15, 6)(15, 5)(16, 5)(17, 6)(17, 7)(18, 7)(18, 8)(18, 9)(19, 9)(19, 8)(19, 7)(19, 6)(19, 7)(19, 6)(18, 6)(18, 5)(18, 6)(18, 5)(19, 5)(19, 4)(19, 3)(19, 2)(19, 1)(18, 0)(17, 0)(16, 0)(16, 1)(17, 1)(18, 1)(18, 2)(18, 3)(18, 4)(17, 4)(16, 4)(15, 4)(14, 4)(14, 3)(13, 3)(13, 4)(12, 4)(11, 4)(11, 5)(10, 6)(9, 6)(9, 5)(8, 5)(8, 6)(8, 7)(9, 7)(9, 8)(10, 8)(11, 8)(11, 9)(11, 10)(10, 10)
+--------------------------
+Blue Agent (ID: 1)
+- Step number: 108
+- Trap number: 3
+- Power-Up usage: 6
+- Moves: (0, 0)(1, 0)(1, 1)(2, 1)(3, 1)(4, 1)(5, 1)(5, 0)(6, 0)(7, 0)(8, 0)(9, 0)(10, 0)(10, 1)(9, 1)(8, 1)(8, 2)(7, 2)(6, 2)(6, 3)(5, 3)(5, 2)(4, 2)(4, 3)(3, 3)(3, 2)(2, 2)(1, 2)(2, 2)(1, 2)(0, 2)(1, 2)(0, 2)(1, 2)(0, 2)(0, 3)(1, 3)(1, 4)(2, 4)(2, 5)(3, 5)(3, 6)(2, 6)(3, 6)(2, 6)(2, 7)(1, 7)(1, 8)(2, 8)(2, 9)(3, 9)(4, 9)(5, 9)(5, 8)(5, 7)(6, 7)(6, 6)(5, 6)(5, 5)(5, 4)(6, 4)(7, 4)(8, 4)(8, 3)(9, 3)(10, 3)(11, 3)(11, 2)(12, 2)(13, 2)(14, 2)(15, 2)(15, 1)(14, 1)(14, 0)(16, 0)(16, 1)(17, 1)(18, 1)(18, 2)(18, 3)(18, 4)(17, 4)(16, 4)(15, 4)(14, 4)(14, 3)(13, 3)(13, 4)(12, 4)(11, 4)(11, 5)(10, 5)(10, 6)(9, 6)(9, 5)(8, 5)(8, 6)(8, 7)(9, 7)(10, 8)(11, 8)(11, 9)
+--------------------------

mazeDataStructure/mazeDeneme/mazeDeneme.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

mazeDataStructure/mazeDeneme/src/Agent.java

@@ -0,0 +1,233 @@
+import java.awt.Color;
+import java.util.Random;
+
+public class Agent {
+    private int x, y;
+    private final int id;
+    private final MazeManager maze;
+    private final Color color;
+    private final String name;
+
+    private boolean phaseWallUsed = false;
+    private boolean passedWall = false;
+    private final Stack<String> moveHistory;
+    private final Random random = new Random();
+    private boolean gotPowerUp = false;
+
+    private int powerUpUses = 0;
+    private int stepCount = 0;
+    private int trapHits = 0;
+
+
+    public Agent(int startX, int startY, MazeManager maze, Color color, String name, int id) {
+        this.id=id;
+        this.x = startX;
+        this.y = startY;
+        this.maze = maze;
+        this.color = color;
+
+        this.name = name;
+        this.moveHistory = new Stack<>(maze.getCols() * maze.getRows());
+        moveHistory.push("(" + x + ", " + y + ")");
+    }
+
+    public int getId()
+    {
+        return id;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public Color getColor() {
+        return color;
+    }
+
+    public int getTrapHits() {
+        return trapHits;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Stack<String> getMoveHistory() {
+        return moveHistory;
+    }
+
+    public boolean passedWallThisTurn() {
+        return passedWall;
+    }
+
+    public void setPassedWall(boolean value) {
+        this.passedWall = value;
+    }
+
+    public int getStepCount() {
+        return stepCount;
+    }
+
+
+    public int getPowerUpUses() {
+        return powerUpUses;
+    }
+
+    public void moveTowardsGoal() {
+        boolean canPhaseWall = false;
+
+        if (gotPowerUp && !phaseWallUsed) {
+            if (random.nextInt(100) < 20) {
+                canPhaseWall = true;
+                passedWall = true;
+                powerUpUses++;
+            }
+        } else {
+            passedWall = false;
+        }
+
+        Node[] openSet = new Node[maze.getCols() * maze.getRows()];
+        boolean[][] closedSet = new boolean[maze.getCols()][maze.getRows()];
+        int openSetSize = 0;
+
+        int goalX = maze.getCols() / 2;
+        int goalY = maze.getRows() / 2;
+
+        Node start = new Node(x, y, null, 0, heuristic(x, y, goalX, goalY));
+        openSet[openSetSize++] = start;
+        Node goalNode = null;
+
+        while (openSetSize > 0) {
+            int bestIndex = 0;
+            for (int i = 1; i < openSetSize; i++) {
+                if (openSet[i].f < openSet[bestIndex].f) bestIndex = i;
+            }
+            Node current = openSet[bestIndex];
+            openSet[bestIndex] = openSet[--openSetSize];
+
+            if (current.x == goalX && current.y == goalY) {
+                goalNode = current;
+                break;
+            }
+
+            closedSet[current.x][current.y] = true;
+
+            for (int dir = 0; dir < 4; dir++) {
+                int nx = current.x;
+                int ny = current.y;
+                switch (dir) {
+                    case 0:
+                        ny--;
+                        break;
+                    case 1:
+                        nx++;
+                        break;
+                    case 2:
+                        ny++;
+                        break;
+                    case 3:
+                        nx--;
+                        break;
+                }
+                if (!maze.isInMaze(nx, ny)) {
+                    continue;
+                }
+                boolean isWall = maze.hasWall(current.x, current.y, dir);
+                if (isWall && !canPhaseWall) {
+                    continue;
+                }
+                if (closedSet[nx][ny]) {
+                    continue;
+                }
+
+                boolean alreadyInOpenSet = false;
+                for (int i = 0; i < openSetSize; i++) {
+                    if (openSet[i].x == nx && openSet[i].y == ny) {
+                        alreadyInOpenSet = true;
+                        break;
+                    }
+                }
+
+                if (!alreadyInOpenSet) {
+                    openSet[openSetSize++] = new Node(nx, ny, current,
+                            current.g + 1, heuristic(nx, ny, goalX, goalY));
+                }
+            }
+        }
+
+        if (goalNode != null && goalNode.parent != null) {
+            Node moveTo = goalNode;
+            while (moveTo.parent.parent != null) {
+                moveTo = moveTo.parent;
+            }
+
+            int oldX = x;
+            int oldY = y;
+
+            if (maze.hasWall(x, y, directionTo(moveTo.x, moveTo.y)) && canPhaseWall) {
+                phaseWallUsed = true;
+            }
+
+            this.x = moveTo.x;
+            this.y = moveTo.y;
+
+            if (x != oldX || y != oldY) {
+                moveHistory.push("(" + x + ", " + y + ")");
+                stepCount++;
+            }
+
+            MazeTile tile = maze.getTile(x, y);
+            if (tile.getEntity() == MazeTile.EntityType.TRAP && tile.isTrapActive()) {
+                tile.deactivateTrap();
+                trapHits++;
+                stepBackTwice();
+            }
+            if (tile.getEntity() == MazeTile.EntityType.POWER_UP && tile.isPowerUpActive()) {
+                tile.deactivatePowerUp();
+                gotPowerUp = true;
+                phaseWallUsed = false;
+            }
+        }
+    }
+
+    private int directionTo(int toX, int toY) {
+        if (toX == x + 1) return 1;
+        if (toX == x - 1) return 3;
+        if (toY == y + 1) return 2;
+        if (toY == y - 1) return 0;
+        return -1;
+    }
+
+    private void stepBackTwice() {
+        if (moveHistory.getSize() < 3) return;
+        moveHistory.pop();
+        moveHistory.pop();
+        String coord = (String) moveHistory.pop();
+        String[] parts = coord.replace("(", "").replace(")", "").split(", ");
+        this.x = Integer.parseInt(parts[0]);
+        this.y = Integer.parseInt(parts[1]);
+    }
+
+    private int heuristic(int x1, int y1, int x2, int y2) {
+        return Math.abs(x1 - x2) + Math.abs(y1 - y2);
+    }
+
+    private static class Node {
+        int x, y;
+        Node parent;
+        int g;
+        int f;
+
+        public Node(int x, int y, Node parent, int g, int h) {
+            this.x = x;
+            this.y = y;
+            this.parent = parent;
+            this.g = g;
+            this.f = g + h;
+        }
+    }
+}

mazeDataStructure/mazeDeneme/src/CircularLinkedList.java

@@ -0,0 +1,65 @@
+public class CircularLinkedList<T> {
+    private Node<T> head;
+    private int size = 0;
+
+    public void add(T data) {
+        Node<T> newNode = new Node<>(data);
+        if (head == null) {
+            head = newNode;
+            head.next = head;
+            head.prev = head;
+        } else {
+            Node<T> last = head.prev;
+
+            last.next = newNode;
+            newNode.prev = last;
+
+            newNode.next = head;
+            head.prev = newNode;
+        }
+        size++;
+    }
+
+    public void rotateOneStep(int steps) {
+        if (head == null || steps <= 0)
+        {
+            return;
+        }
+        for (int i = 0; i < steps; i++) {
+            head = head.prev;
+        }
+    }
+
+
+    public T get(int index) {
+        if (index < 0 || index >= size);
+        Node<T> current = head;
+        for (int i = 0; i < index; i++) {
+            current = current.next;
+        }
+        return current.data;
+    }
+
+    public void toArray(T[] array) {
+        if (array.length < size) ;
+        Node<T> curr = head;
+        for (int i = 0; i < size; i++) {
+            array[i] = curr.data;
+            curr = curr.next;
+        }
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public static class Node<T> {
+        T data;
+        Node<T> next;
+        Node<T> prev; // ← burası eklendi
+
+        public Node(T data) {
+            this.data = data;
+        }
+    }
+}

mazeDataStructure/mazeDeneme/src/InputScreen.java

@@ -0,0 +1,70 @@
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class InputScreen extends JFrame {
+    private JTextField colsField, rowsField, trapChanceField, powerUpChanceField;
+    private JButton playButton;
+
+    public InputScreen() {
+        setTitle("Maze settings");
+        setSize(300, 250);
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        setLocationRelativeTo(null);
+        setLayout(new GridLayout(5, 2, 5, 5));
+
+        add(new JLabel("Col number:"));
+        colsField = new JTextField("10");
+        add(colsField);
+
+        add(new JLabel("Row number:"));
+        rowsField = new JTextField("10");
+        add(rowsField);
+
+        add(new JLabel("Trap Probality (%):"));
+        trapChanceField = new JTextField("5");
+        add(trapChanceField);
+
+        add(new JLabel("PowerUp Probality (%):"));
+        powerUpChanceField = new JTextField("3");
+        add(powerUpChanceField);
+
+        playButton = new JButton("Play");
+        add(new JLabel()); // boşluk için
+        add(playButton);
+
+        playButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                startGame();
+            }
+        });
+
+        setVisible(true);
+    }
+
+    private void startGame() {
+        try {
+            int cols = Integer.parseInt(colsField.getText());
+            int rows = Integer.parseInt(rowsField.getText());
+            int trapChance = Integer.parseInt(trapChanceField.getText());
+            int powerUpChance = Integer.parseInt(powerUpChanceField.getText());
+
+            JFrame frame = new JFrame("Maze Game");
+            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+            frame.getContentPane().add(new MazeManager(cols, rows, trapChance, powerUpChance));
+            frame.pack();
+            frame.setLocationRelativeTo(null);
+            frame.setVisible(true);
+
+            this.dispose(); // input ekranını kapat
+        } catch (NumberFormatException ex) {
+            JOptionPane.showMessageDialog(this, "enter valid number.", "error", JOptionPane.ERROR_MESSAGE);
+        }
+    }
+
+    public static void main(String[] args) {
+        new InputScreen();
+    }
+}

mazeDataStructure/mazeDeneme/src/Main.java

@@ -0,0 +1,7 @@
+public class Main {
+    public static void main(String[] args) {
+
+        new InputScreen();
+
+    }
+}

mazeDataStructure/mazeDeneme/src/MazeManager.java

@@ -0,0 +1,392 @@
+import java.awt.*;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.*;
+import javax.swing.*;
+import javax.swing.Timer;
+
+public class MazeManager extends JPanel {
+
+
+    //Agens and queue
+    private Queue<Agent> agentQueue;
+    private Agent agent1;
+    private Agent agent2;
+
+
+    //variables
+    private final int cols, rows;
+    private final int cellSize = 20;
+    private final MazeTile[][] tiles;
+    private final boolean[][][] walls;
+    private final Random random = new Random();
+    private final int trapChance;
+    private final int powerUpChance;
+
+
+    //Game Mechanic
+    private boolean gameOver = false;
+    private int currRount = 0;
+    private Timer timer;
+
+    public MazeManager(int cols, int rows, int trapChance, int powerUpChance) {
+
+        //Create ways in maze
+        this.cols = cols;
+        this.rows = rows;
+        this.trapChance = trapChance;
+        this.powerUpChance = powerUpChance;
+        this.tiles = new MazeTile[cols][rows];
+        this.walls = new boolean[cols][rows][4];
+
+        for (int x = 0; x < cols; x++) {
+            for (int y = 0; y < rows; y++) {
+                tiles[x][y] = new MazeTile();
+                for (int d = 0; d < 4; d++) walls[x][y][d] = true;
+            }
+        }
+
+        boolean[][] visited = new boolean[cols][rows];
+        generateMaze(0, 0, visited);
+        placeEntities();
+        setPreferredSize(new Dimension(cols * cellSize, rows * cellSize));
+
+
+        agentQueue = new Queue(10);
+        agent1 = new Agent(0, 0, this, Color.BLUE, "Blue Agent",1);
+        agent2 = new Agent(cols - 1, rows - 1, this, Color.ORANGE, "Orange Agent",2);
+
+        agentQueue.enqueue(agent1);
+        agentQueue.enqueue(agent2);
+
+        timer = new Timer(300, e -> {
+            if (gameOver || agentQueue.isEmpty()) return;
+
+            if (currRount > 0 && currRount % 5 == 0) rotateCorridor();
+            repaint();
+
+            Agent currentAgent = agentQueue.dequeue();
+            currentAgent.moveTowardsGoal();
+
+            if (tiles[currentAgent.getX()][currentAgent.getY()].getEntity() == MazeTile.EntityType.GOAL) {
+                gameOver = true;
+                timer.stop();
+
+                Agent loser = currentAgent == agent1 ? agent2 : agent1;
+                GameLog(currentAgent, loser);
+
+                JOptionPane.showMessageDialog(this,
+                        finalReport(agent1, agent2, currentAgent),
+                        "Game over!",
+                        JOptionPane.INFORMATION_MESSAGE);
+                return;
+            }
+
+            agentQueue.enqueue(currentAgent);
+            currRount++;
+
+        });
+        timer.start();
+    }
+
+
+    private void generateMaze(int x, int y, boolean[][] visited) {
+        visited[x][y] = true;
+        Integer[] dirs = {0, 1, 2, 3};
+        Collections.shuffle(Arrays.asList(dirs));
+
+        for (int dir : dirs) {
+            int nx = x, ny = y;
+            switch (dir) {
+                case 0:
+                    ny--;
+                    break;
+                case 1:
+                    nx++;
+                    break;
+                case 2:
+                    ny++;
+                    break;
+                case 3:
+                    nx--;
+                    break;
+            }
+
+
+        if (isInMaze(nx, ny) && !visited[nx][ny]) {
+                removeWall(x, y, dir);
+                generateMaze(nx, ny, visited);
+            }
+        }
+    }
+
+    public boolean hasWall(int x, int y, int dir) {
+        return walls[x][y][dir];
+    }
+
+    public void removeWall(int x, int y, int dir) {
+        walls[x][y][dir] = false;
+        int nx = x, ny = y;
+        int opp = (dir + 2) % 4;
+        switch (dir) {
+            case 0:
+                ny--;
+                break;
+            case 1:
+                nx++;
+                break;
+            case 2:
+                ny++;
+                break;
+            case 3:
+                nx--;
+                break;
+        }
+        if (isInMaze(nx, ny)) walls[nx][ny][opp] = false;
+    }
+
+
+    //-WİP-
+    private void placeEntities() {
+        int goalX = cols / 2;
+        int goalY = rows / 2;
+        tiles[goalX][goalY].setEntity(MazeTile.EntityType.GOAL);
+
+        int total = cols * rows;
+        int trapCount = total * trapChance / 100;
+        int powerCount = total * powerUpChance / 100;
+
+        for (int i = 0; i < trapCount; i++) {
+            int x, y;
+            do {
+                x = random.nextInt(cols);
+                y = random.nextInt(rows);
+            } while (tiles[x][y].getEntity() != MazeTile.EntityType.EMPTY || (x == goalX && y == goalY));
+            tiles[x][y].setEntity(MazeTile.EntityType.TRAP);
+        }
+
+        for (int i = 0; i < powerCount; i++) {
+            int x, y;
+            do {
+                x = random.nextInt(cols);
+                y = random.nextInt(rows);
+            } while (tiles[x][y].getEntity() != MazeTile.EntityType.EMPTY || (x == goalX && y == goalY));
+            tiles[x][y].setEntity(MazeTile.EntityType.POWER_UP);
+        }
+    }
+
+    private void rotateCorridor() {
+        boolean rotateRow = random.nextBoolean();
+        int index = rotateRow ? random.nextInt(rows) : random.nextInt(cols); //1=row, 2=col
+        int goalX = cols / 2, goalY = rows / 2; //coordinats of goal
+
+        /////////////////////////////////////////////
+        if (rotateRow && index == goalY)
+        {
+            return;
+        }
+        if (!rotateRow && index == goalX) {
+            return;
+        }
+
+        if (rotateRow && index == agent1.getY())
+        {
+            return;
+        }
+        //for not touching goal,agent1, agent2
+        if (!rotateRow && index == agent1.getX()) {
+            return;
+        }
+
+        if (!rotateRow && index == agent2.getX()) {
+            return;
+        }
+        if (rotateRow && index == agent2.getY()) {
+            return;
+        }
+        /////////////////////////////////////////////
+
+        if (rotateRow) {
+            CircularLinkedList<MazeTile.EntityType> entityList = new CircularLinkedList<>();
+            CircularLinkedList<Boolean> activePowerUp = new CircularLinkedList<>();
+
+            // taking data of every tile( entity type, is trap active, is powerup active)
+
+            //taking them  to same circular linked list
+            CircularLinkedList<Boolean> activeTrap = new CircularLinkedList<>();
+
+
+            //rewrite every tiles
+            for (int x = 0; x < cols; x++) {
+                MazeTile tile = tiles[x][index];
+                entityList.add(tile.getEntity());
+
+                activeTrap.add( tile.isTrapActive());
+
+                activePowerUp.add(tile.isPowerUpActive());
+            }
+
+            entityList.rotateOneStep(1);
+            activeTrap.rotateOneStep(1);
+            activePowerUp.rotateOneStep(1);
+
+
+            for (int x = 0; x < cols; x++) {
+
+
+                tiles[x][index].setPowerUpActive(activePowerUp.get(x));
+                tiles[x][index].setEntity(entityList.get(x));
+                tiles[x][index].setTrapActive(activeTrap.get(x));
+            }
+
+        } else {
+
+            CircularLinkedList<Boolean> trapActiveList = new CircularLinkedList<>();
+
+            CircularLinkedList<Boolean> powerUpActiveList =  new CircularLinkedList<>();
+
+            CircularLinkedList<MazeTile.EntityType> entityList = new CircularLinkedList<>();
+
+
+            for (int y = 0; y < rows; y++) {
+                MazeTile tile = tiles[index][y];
+                entityList.add(tile.getEntity());
+                trapActiveList.add(tile.isTrapActive());
+                powerUpActiveList.add(tile.isPowerUpActive());
+            }
+
+            entityList.rotateOneStep(1);
+            trapActiveList.rotateOneStep(1);
+            powerUpActiveList.rotateOneStep(1);
+
+            for (int y = 0; y < rows; y++) {
+                tiles[index][y].setEntity(entityList.get(y));
+                tiles[index][y].setTrapActive(trapActiveList.get(y));
+                tiles[index][y].setPowerUpActive(powerUpActiveList.get(y));
+            }
+        }
+    }
+
+    public boolean isInMaze(int x, int y) {
+        return x >= 0 && y >= 0 && x < cols && y < rows;
+    }
+
+    public MazeTile getTile(int x, int y) {
+        return tiles[x][y];
+    }
+
+    public int getCols() {
+        return cols;
+    }
+
+    public int getRows() {
+        return rows;
+    }
+
+    private String finalReport(Agent a1, Agent a2, Agent winner) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(winner.getName()).append(" reached the target!\nnumber of rount played: ").append(currRount).append("\n\n");
+        for (Agent agent : new Agent[]{a1, a2}) {
+            sb.append(agent.getName()).append(":\n");
+            Stack<String> stack = agent.getMoveHistory();
+            for (int i = 0; i < stack.getSize(); i++) {
+
+                sb.append(stack.getElements()[i]).append("");
+            }
+            sb.append("\n");
+        }
+        return sb.toString();
+    }
+
+    private void GameLog(Agent winner, Agent loser) {
+        // preparing console screen before printing results
+        System.out.print("\033[H\033[2J");   
+        System.out.flush();
+        //-----------
+        System.out.println("\n=== Game Over ===");
+        System.out.println("Winner Agent: " + winner.getName());
+        System.out.println("Number of rount played: " + currRount);
+        System.out.println("----------------------");
+
+        System.out.println(winner.getName() + " Statistics:");
+        System.out.println("- Step number: " + winner.getStepCount());
+        System.out.println("- Trap number: " + winner.getTrapHits());
+        System.out.println("- Power-Up usage: " + winner.getPowerUpUses());
+        System.out.println();
+
+        System.out.println(loser.getName() + " Statistics:");
+        System.out.println("- Step number: " + loser.getStepCount());
+        System.out.println("- Trap number: " + loser.getTrapHits());
+        System.out.println("- Power-Up usage: " + loser.getPowerUpUses());
+
+        try (FileWriter writer = new FileWriter("game_log.txt", true)) {
+            writer.write("=== Game Over ===\n");
+            writer.write("Winner Agent: " + winner.getName() + " (ID: " + winner.getId() + ")\n");
+            writer.write("Number of rount played: " + currRount + "\n\n");
+
+            for (Agent agent : new Agent[]{winner, loser}) {
+                writer.write(agent.getName() + " (ID: " + agent.getId() + ")\n");
+                writer.write("- Step number: " + agent.getStepCount() +     "\n");
+                writer.write("- Trap number: " + agent.getTrapHits() + "\n");
+                writer.write("- Power-Up usage: " + agent.getPowerUpUses() + "\n");
+                writer.write("- Moves: ");
+                Stack<String> stack = agent.getMoveHistory();
+                for (int i = 0; i < stack.getSize(); i++) {
+                    Object move = stack.getElements()[i];
+                    writer.write(String.valueOf(move));
+                }
+
+                writer.write("\n--------------------------\n");
+            }
+
+        } catch (IOException e) {
+            System.out.println("Log file error: ");
+        }
+        
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        g.setColor(Color.BLACK);
+
+        for (int x = 0; x < cols; x++) {
+            for (int y = 0; y < rows; y++) {
+                int px = x * cellSize;
+                int py = y * cellSize;
+
+                if (walls[x][y][3]) g.drawLine(px, py, px, py + cellSize);
+                if (walls[x][y][1]) g.drawLine(px + cellSize, py, px + cellSize, py + cellSize);
+                if (walls[x][y][0]) g.drawLine(px, py, px + cellSize, py);
+                if (walls[x][y][2]) g.drawLine(px, py + cellSize, px + cellSize, py + cellSize);
+
+                switch (tiles[x][y].getEntity()) {
+                    case GOAL -> {
+                        g.setColor(Color.GREEN);
+                        g.fillRect(px + 4, py + 4, cellSize - 8, cellSize - 8);
+                        g.setColor(Color.BLACK);
+                    }
+
+                    case POWER_UP -> {
+                        g.setColor(tiles[x][y].isPowerUpActive() ? Color.YELLOW : Color.GRAY);
+                        g.fillRect(px + 4, py + 4, cellSize - 8, cellSize - 8);
+                        g.setColor(Color.BLACK);
+                    }
+                    case TRAP -> {
+                        g.setColor(tiles[x][y].isTrapActive() ? Color.RED : Color.GRAY);
+                        g.fillRect(px + 4, py + 4, cellSize - 8, cellSize - 8);
+                        g.setColor(Color.BLACK);
+                    }
+                }
+            }
+        }
+
+        for (Agent agent : new Agent[]{agent1, agent2}) {
+            g.setColor(agent.passedWallThisTurn() ? Color.MAGENTA : agent.getColor());
+            g.fillOval(agent.getX() * cellSize + 5, agent.getY() * cellSize + 5, cellSize - 10, cellSize - 10);
+        }
+
+        g.setColor(Color.BLACK);
+        g.drawString("Curr Round: " + currRount, 10, 15);
+    }
+}

mazeDataStructure/mazeDeneme/src/MazeTile.java

@@ -0,0 +1,41 @@
+public class MazeTile {
+    public enum EntityType {
+        EMPTY, GOAL, TRAP, POWER_UP
+    }
+
+    private EntityType entity = EntityType.EMPTY;
+    private boolean trapActive = true;
+    private boolean powerUpActive = true;
+
+    public EntityType getEntity() {
+        return entity;
+    }
+
+    public void setEntity(EntityType entity) {
+        this.entity = entity;
+    }
+
+    public boolean isTrapActive() {
+        return trapActive;
+    }
+
+    public void deactivateTrap() {
+        this.trapActive = false;
+    }
+
+    public boolean isPowerUpActive() {
+        return powerUpActive;
+    }
+
+    public void deactivatePowerUp() {
+        this.powerUpActive = false;
+    }
+
+    public void setTrapActive(boolean active) {
+        this.trapActive = active;
+    }
+
+    public void setPowerUpActive(boolean active) {
+        this.powerUpActive = active;
+    }
+}

mazeDataStructure/mazeDeneme/src/Queue.java

@@ -0,0 +1,43 @@
+public class Queue<T> {
+    private Object[] elementsofqueue;
+    private int head = 0;
+    private int tail = 0;
+    private int sizeofqueue = 0;
+    private int capacity;
+
+    public Queue(int capacityval) {
+        this.capacity = capacityval;
+        elementsofqueue = new Object[capacityval];
+    }
+
+    public void enqueue(T item) {
+        if (sizeofqueue == capacity) {
+            System.out.println("Queue is full");
+            return;
+        }
+        elementsofqueue[tail] = item;
+        tail = (tail + 1) % capacity;
+        sizeofqueue++;
+    }
+
+    public T dequeue() {
+        if (isEmpty()) {
+            System.out.println("Queue is empty");
+            return null;
+        }
+        T item = (T) elementsofqueue[head];
+        head = (head + 1) % capacity;
+        sizeofqueue--;
+        return item;
+    }
+
+
+
+    public boolean isEmpty() {
+        return sizeofqueue == 0;
+    }
+
+    public int getSize() {
+        return sizeofqueue;
+    }
+}

mazeDataStructure/mazeDeneme/src/Stack.java

@@ -0,0 +1,55 @@
+public class Stack<T> {
+    private Object[] elementsofstack;
+    private int size = 0;
+
+    public Stack(int capacity) {
+        elementsofstack = new Object[capacity];
+    }
+
+    public void push(T item) {
+        int lengthofstack = elementsofstack.length;
+        if (size == lengthofstack) {
+            System.out.println("Stack is full!");
+            return;
+        }
+        //size= size +1;
+        elementsofstack[size] = item;
+        size = size + 1;
+    }
+
+    public T pop() {
+        if (isempty()) {
+            System.out.println("Stack is empty!");
+            return null;
+        }
+        size= size - 1;
+        return (T) elementsofstack[size];
+    }
+
+    public boolean isempty() {
+        if(size == 0)
+        {
+            return true;
+        }
+        else if(size<=0)
+        {
+            System.out.println("there might be issue!\n>size value:"+size);
+            return false;
+        }
+        else
+        {
+            return false;
+        }
+        
+    }
+
+    public Object[] getElements() {
+        return elementsofstack;
+    }
+
+    public int getSize() {
+        //System.out.println("used getSize func.\n>size value:"+size);
+        return size;
+    }
+
+}