diff --git a/pom.xml b/pom.xml
index cd4143e395a16392aff997098fb3123119b49301..18006fdd52d6f9d33b1091183cfcd2d8f36050de 100644
--- a/pom.xml
+++ b/pom.xml
@@ -3,10 +3,10 @@
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>cz.vsb.fei.java2</groupId>
-	<artifactId>java2-lab05-v1</artifactId>
+	<artifactId>java2-lab06-v1</artifactId>
 	<version>0.0.1-SNAPHOST</version>
 
-	<name>java2-lab05-v1</name>
+	<name>java2-lab06-v1</name>
 	<packaging>jar</packaging>
 	<properties>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
@@ -15,8 +15,17 @@
 		<lombok.version>1.18.34</lombok.version>
 	</properties>
 	<dependencies>
-	
-		<!-- https://mvnrepository.com/artifact/jakarta.persistence/jakarta.persistence-api -->
+
+		<dependency>
+			<groupId>org.hibernate</groupId>
+			<artifactId>hibernate-jpamodelgen</artifactId>
+			<scope>provided</scope>
+			<version>6.6.11.Final</version>
+		</dependency>
+
+
+		<!--
+		https://mvnrepository.com/artifact/jakarta.persistence/jakarta.persistence-api -->
 		<dependency>
 			<groupId>jakarta.persistence</groupId>
 			<artifactId>jakarta.persistence-api</artifactId>
@@ -36,14 +45,16 @@
 			<scope>provided</scope>
 		</dependency>
 
-		<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
+		<!--
+		https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
 		<dependency>
 			<groupId>org.apache.logging.log4j</groupId>
 			<artifactId>log4j-core</artifactId>
 			<version>2.24.3</version>
 		</dependency>
 
-		<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-api -->
+		<!--
+		https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-api -->
 		<dependency>
 			<groupId>org.apache.logging.log4j</groupId>
 			<artifactId>log4j-api</artifactId>
@@ -111,10 +122,43 @@
 							<artifactId>lombok</artifactId>
 							<version>${lombok.version}</version>
 						</path>
+						<path>
+							<groupId>org.hibernate</groupId>
+							<artifactId>hibernate-jpamodelgen</artifactId>
+							<version>6.6.11.Final</version>
+						</path>
+
 					</annotationProcessorPaths>
 				</configuration>
+				<executions>
+					<execution>
+						<id>process</id>
+						<phase>generate-sources</phase>
+					</execution>
+				</executions>
+
+			</plugin>
+			<plugin>
+				<groupId>org.codehaus.mojo</groupId>
+				<artifactId>build-helper-maven-plugin</artifactId>
+				<version>3.6.0</version>
+				<configuration>
+					<sources>
+						<source>target/generated-sources/annotations</source>
+					</sources>
+				</configuration>
+				<executions>
+					<execution>
+						<id>add-source</id>
+						<phase>process-resources</phase>
+						<goals>
+							<goal>add-source</goal>
+						</goals>
+					</execution>
+				</executions>
 			</plugin>
 
+
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-dependency-plugin</artifactId>
diff --git a/scores.csv b/scores.csv
deleted file mode 100644
index 310f42d7b93a936028ac58fb0cfe41ba5fe16fe4..0000000000000000000000000000000000000000
--- a/scores.csv
+++ /dev/null
@@ -1,17 +0,0 @@
-NetworkNinja;122
-VirtualVoyager;198
-TweetTrendsetter;109
-WebWizard;262
-ScreenSage;95
-CodeCommander;276
-FunctionFanatic;288
-DataDetective;112
-ScreenSage;181
-PixelArtist;242
-RenderRogue;62
-siast;101
-ByteBishop;53
-PixelProdigy;196
-PixelArtist;70
-AppAlchemist;106
-ScriptSensei;283
diff --git a/src/main/java/lab/App.java b/src/main/java/lab/App.java
new file mode 100644
index 0000000000000000000000000000000000000000..be7b48deffae11f03fca3713dea9848fd64f0910
--- /dev/null
+++ b/src/main/java/lab/App.java
@@ -0,0 +1,62 @@
+package lab;
+
+import java.io.IOException;
+import java.sql.SQLException;
+
+import org.h2.tools.Server;
+
+import lab.storage.JpaConnector;
+import lombok.extern.log4j.Log4j2;
+
+/**
+ * Class <b>App</b> - extends class Application and it is an entry point of the
+ * program
+ * 
+ * @author Java I
+ */
+@Log4j2
+public class App {
+
+	public static void main(String[] args) {
+		log.info("Application lauched");
+
+		Server server = startDBWebServer();
+
+		JpaConnector connector = new JpaConnector();
+
+		//TODO
+
+		waitForKeyPress();
+		stopDBWebServer(server);
+	}
+
+	private static Server startDBWebServer() {
+		// Start HTTP server for access H2 DB for look inside
+		try {
+			Server server = Server.createWebServer();
+			log.info(server.getURL());
+			server.start();
+			log.info("DB Web server started!");
+			return server;
+		} catch (SQLException e) {
+			log.error("Cannot create DB web server.", e);
+			return null;
+		}
+	}
+
+	private static void stopDBWebServer(Server server) {
+		// Stop HTTP server for access H2 DB
+		log.info("Ending DB web server BYE.");
+		server.stop();
+	}
+
+	private static void waitForKeyPress() {
+		log.info("Waitnig for Key press (ENTER)");
+		try {
+			System.in.read();
+		} catch (IOException e) {
+			log.error("Cannot read input from keyboard.", e);
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/main/java/lab/Setting.java b/src/main/java/lab/Setting.java
deleted file mode 100644
index a392f92bad53ac0e2edbda93a3651bda2a01baf1..0000000000000000000000000000000000000000
--- a/src/main/java/lab/Setting.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package lab;
-
-import lab.storage.DbConnector;
-import lab.storage.ScoreStorageInterface;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Builder.Default;
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
-import lombok.ToString;
-
-@Getter
-@Builder(toBuilder = true)
-@EqualsAndHashCode
-@ToString
-@AllArgsConstructor
-public class Setting {
-
-	@Getter
-	private static Setting instance;
-
-
-	@Default
-	private ScoreStorageInterface scoreStorageInterface = new DbConnector();
-	@Default
-	private double gravity = 9.81;
-	@Default
-	private double normalBulletSpeed = 30;
-	@Default
-	private int numberOfUfos = 3;
-	@Default
-	private double ufoMinPercentageHeight = 0.3;
-	@Default
-	private double ufoMinSpeed = 70;
-	@Default
-	private double ufoMaxSpeed = 150;
-	@Default
-	private double bulletMinSpeed = 30;
-	@Default
-	private double bulletMaxSpeed = 300;
-
-	public static void configure(Setting setting) {
-		instance = setting;
-	}
-
-	public static Setting getInstanceForHardcoreGame() {
-		return builder().numberOfUfos(50).ufoMinPercentageHeight(0.9).ufoMinSpeed(200).ufoMaxSpeed(500).build();
-	}
-
-
-}
diff --git a/src/main/java/lab/Tools.java b/src/main/java/lab/Tools.java
new file mode 100644
index 0000000000000000000000000000000000000000..3eb4473cdd112f01b637c6d1cff9f17ea985c39b
--- /dev/null
+++ b/src/main/java/lab/Tools.java
@@ -0,0 +1,149 @@
+package lab;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+public class Tools {
+
+	public static final Random RANDOM = new Random();
+
+	public static final List<String> FIRST_NAMES = List.of("Petr", "Marie", "Jan", "Jana", "Tomáš", "Kateřina", "Lukáš",
+			"Tereza", "Martin", "Veronika", "David", "Eva", "Jakub", "Lucie", "Michal", "Anna", "Adam", "Monika", "Tom",
+			"Klára", "Robert", "Kristýna", "Marek", "Simona", "Filip", "Petra", "Ondřej", "Lenka", "Matěj", "Markéta",
+			"Pavel", "Hana", "Jakub", "Adéla", "Daniel", "Barbora", "Lukáš", "Eliška", "Josef");
+	public static final List<String> LAST_NAMES = List.of("Novák", "Svoboda", "Novotný", "Dvořák", "Černý",
+			"Procházková", "Kučera", "Veselý", "Horák", "Němec", "Pokorný", "Mareš", "Pospíšilová", "Hájek", "Jelínek",
+			"Král", "Růžička", "Beneš", "Fiala", "Sedláček", "Kříž", "Němcová", "Vlček", "Kolář", "Bartoš", "Bílý",
+			"Veselá", "Kovařík", "Havelka", "Malý", "Urban", "Kopecký", "Vlach", "Šimek", "Konečný", "Doležal",
+			"Šťastný", "Kopečná", "Holub", "Pospíchal");
+
+	public static final List<String> STREETS = List.of("Panská", "Hlavní", "Ulice Nová", "Náměstí Svobody", "Hřbitovní",
+			"Revoluční", "Sadová", "Jiráskova", "Školní", "Vinohradská", "Komenského", "Mírová", "Křížová",
+			"Masarykova", "Třída Svobody", "Karlova", "Dlouhá", "Žižkova", "Purkyňova", "Rybářská", "Sokolská",
+			"Rybníček", "Vrchlického", "Štefánikova", "Veselá", "Lipová", "Na Hrázi", "Výšinná", "Nová Cesta", "Česká");
+	public static final List<String> CITIES = Collections.unmodifiableList(
+			Arrays.asList("Praha", "Brno", "Ostrava", "Plzeň", "Liberec", "Olomouc", "České Budějovice",
+					"Hradec Králové", "Ústí nad Labem", "Pardubice", "Zlín", "Karlovy Vary", "Jihlava", "Tábor",
+					"Havířov", "Český Těšín", "Mladá Boleslav", "Trutnov", "Přerov", "Kladno", "Opava", "Frýdek-Místek",
+					"Děčín", "Karviná", "Jablonec nad Nisou", "Třebíč", "Žďár nad Sázavou", "Kolín", "Uherské Hradiště",
+					"Znojmo", "Prostějov", "Litoměřice", "Kroměříž", "Chomutov", "Příbram", "Příbram", "Cheb",
+					"Teplice", "Uherský Brod", "Sokolov", "Břeclav", "Litvínov", "Klatovy", "Vsetín", "Nový Jičín"));
+
+	public static final List<String> POST_NUMBER = List.of("10000", "11000", "12000", "13000", "14000", "15000",
+			"16000", "17000", "18000", "19000", "20000", "21000", "22000", "23000", "24000", "25000", "26000", "27000",
+			"28000", "29000", "30000", "31000", "32000", "33000", "34000", "35000", "36000", "37000", "38000", "39000");
+
+	public static final List<String> COMPANY_NAMES = List.of("Inova", "Sprint", "Polaris", "Forte", "Nexus", "Vertex",
+			"Synergie", "Horizon", "Astra", "Axiom", "Optima", "Integra", "Evolve", "Apex", "Dynasty", "Eclipse",
+			"Paragon", "Fusion", "Oasis", "Equinox", "Voyage", "Genesis", "Zenith", "Elite", "Harmony", "Stratos",
+			"Aurora", "Quantum", "Spectrum");
+
+	public static final List<String> BIRD_NAMES = List.of("Vlaštovka", "Sýkorka", "Krkavec", "Sokol", "Káně",
+			"Střízlík", "Sojka", "Datel", "Drozd", "Rorýs", "Husa", "Labuť", "Krahujec", "Sova", "Výr", "Husice",
+			"Havran", "Špaček", "Ledňáček", "Sup");
+
+	public static final List<String> NICKNAMES = List.of("CyberSurfer", "PixelPioneer", "SocialSavvy", "DigitalDynamo",
+			"ByteBuddy", "InstaGuru", "TikTokTornado", "SnapMaster", "TweetTrendsetter", "ChatChampion", "HashtagHero",
+			"EmojiEnthusiast", "StoryStylist", "SelfieStar", "FilterFanatic", "VlogVirtuoso", "Memelord",
+			"InfluencerInsider", "StreamSupreme", "GeekyGizmo", "CodeCommander", "JavaJuggernaut", "ByteNinja",
+			"SyntaxSamurai", "ClassyCoder", "ObjectOmnipotent", "LoopLegend", "VariableVirtuoso", "DebugDemon",
+			"CompilerCrusader", "PixelProdigy", "VirtualVoyager", "AlgorithmAce", "DataDynamo", "ExceptionExpert",
+			"BugBuster", "SyntaxSorcerer", "CodeCrusader", "JavaJester");
+
+	public static final List<String> PLAYER_NICKS = List.of("CyberSurfer", "PixelPioneer", "SocialSavvy",
+			"DigitalDynamo", "ByteBuddy", "InstaGuru", "TikTokTornado", "SnapMaster", "TweetTrendsetter",
+			"ChatChampion", "HashtagHero", "EmojiEnthusiast", "StoryStylist", "SelfieStar", "FilterFanatic",
+			"VlogVirtuoso", "Memelord", "InfluencerInsider", "StreamSupreme", "GeekyGizmo", "CodeCommander",
+			"JavaJuggernaut", "ByteNinja", "SyntaxSamurai", "ClassyCoder", "ObjectOmnipotent", "LoopLegend",
+			"VariableVirtuoso", "DebugDemon", "CompilerCrusader", "PixelProdigy", "VirtualVoyager", "AlgorithmAce",
+			"DataDynamo", "ExceptionExpert", "BugBuster", "SyntaxSorcerer", "CodeCrusader", "JavaJester",
+			"NerdyNavigator", "CryptoCaptain", "SocialButterfly", "AppArchitect", "WebWizard", "FunctionFreak",
+			"PixelArtist", "CyberPhantom", "HackHero", "CacheChampion", "ScreenSage", "WebWeaver", "LogicLover",
+			"BitBlazer", "NetworkNomad", "ProtocolPioneer", "BinaryBoss", "StackSultan", "SocialScribe", "RenderRuler",
+			"ScriptSorcerer", "HTMLHero", "PixelProwler", "FrameFreak", "DataDreamer", "BotBuilder", "ByteBishop",
+			"KeyboardKnight", "DesignDaredevil", "JavaJuggler", "SyntaxStrategist", "TechTactician", "ProgramProdigy",
+			"BinaryBard", "PixelPoet", "GigabyteGuru", "TechTrekker", "NetworkNinja", "DataDetective", "MatrixMaster",
+			"CodeConductor", "AppAlchemist", "ServerSage", "ClusterChampion", "ScriptSensei", "KeyboardKicker",
+			"CacheCrafter", "SocialSpark", "BinaryBeast", "CodeConnoisseur", "BitBrain", "VirtualVanguard",
+			"SystemSculptor", "RenderRogue", "CryptoConqueror", "MachineMonarch", "PixelPal", "CompilerCaptain",
+			"BitBuilder", "TechTitan", "CloudConqueror", "EchoExplorer", "FunctionFanatic", "RobotRanger");
+
+	public static final List<String> NAME_OF_GAMES = List.of("Call of Duty: Warzone", "Counter-Strike 2", "Battlefield 2042",
+			"Overwatch 2", "Team Fortress 2", "Halo Infinite", "Apex Legends", "Rainbow Six Siege", "Valorant",
+			"Fortnite", "PUBG: Battlegrounds", "Destiny 2", "Titanfall 2", "Splatoon 3", "Gears of War 5",
+			"Left 4 Dead 2", "Dota 2", "League of Legends", "Minecraft (Bedrock/Java - multiplayer)", "Rust",
+			"Escape from Tarkov", "DayZ", "Hell Let Loose", "Hunt: Showdown", "Chivalry 2", "Payday 3", "War Thunder",
+			"Enlisted", "World of Tanks", "Sea of Thieves");
+
+	public static String randomGameName() {
+		return randomElementFrom(NAME_OF_GAMES);
+	}
+
+	public static String randomNick() {
+		return randomElementFrom(PLAYER_NICKS);
+	}
+
+	public static String randomFistName() {
+		return randomElementFrom(FIRST_NAMES);
+	}
+
+	public static String randomLastName() {
+		return randomElementFrom(LAST_NAMES);
+	}
+
+	public static final List<String> COURSE_NAMES = List.of("Java 1", "Java 2", "C# 1", "C# 2", "Python", "Databáze I",
+			"Databáze II", "Funkcionální programování", "OOP", "PS", "APPS", "SWI");
+
+	public static String generateCompanyName() {
+		StringBuilder name = new StringBuilder();
+		int numberOfWords = RANDOM.nextInt(2) + 1;
+		for (int j = 0; j < numberOfWords; j++) {
+			name.append(randomElementFrom(COMPANY_NAMES));
+			if (j < numberOfWords - 1) {
+				name.append(" ");
+			}
+		}
+		return name.toString();
+	}
+
+	public static String generateAddress() {
+		return String.format("%s %d, %s, %s", randomElementFrom(STREETS), RANDOM.nextInt(99) + 1,
+				randomElementFrom(CITIES), randomElementFrom(POST_NUMBER));
+	}
+
+	public static <T> T randomElementFrom(List<T> list) {
+		return randomElementFrom(list, RANDOM);
+	}
+
+	public static <T> T random(T[] array) {
+		return array[RANDOM.nextInt(array.length)];
+	}
+
+	public static <T> T randomElementFrom(List<T> list, Random r) {
+		if (list.isEmpty()) {
+			return null;
+		}
+		return list.get(r.nextInt(list.size()));
+	}
+
+	public static LocalDate generatePreviousDate() {
+		return LocalDate.of(LocalDate.now().getYear() - RANDOM.nextInt(80), RANDOM.nextInt(12) + 1, 1)
+				.plusDays(RANDOM.nextInt(31));
+	}
+
+	public static LocalDate generateDateInFuture() {
+		return LocalDate.now().plusDays(RANDOM.nextInt(400));
+	}
+
+	public static LocalDateTime generatePreviousDateTime() {
+		return LocalDateTime.now().minusMinutes(RANDOM.nextInt(100000));
+	}
+
+	private Tools() {
+		/* hide public one - nothing to do */
+	}
+}
diff --git a/src/main/java/lab/data/Difficult.java b/src/main/java/lab/data/Difficult.java
new file mode 100644
index 0000000000000000000000000000000000000000..e49d76b1e3fa559ba1eb366ee9091c5eecd1fdaf
--- /dev/null
+++ b/src/main/java/lab/data/Difficult.java
@@ -0,0 +1,2 @@
+package lab.data;
+
diff --git a/src/main/java/lab/data/FirstPersonShooter.java b/src/main/java/lab/data/FirstPersonShooter.java
new file mode 100644
index 0000000000000000000000000000000000000000..62b7b3b4c9d1b2f11af405da5e7c8f68a9f1f81b
--- /dev/null
+++ b/src/main/java/lab/data/FirstPersonShooter.java
@@ -0,0 +1,36 @@
+package lab.data;
+
+import java.util.List;
+
+import jakarta.persistence.Entity;
+import lab.Tools;
+import lab.data.PlatformGame.PlatformType;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+
+@Getter
+@Setter
+@ToString(callSuper = true)
+public class FirstPersonShooter extends Game{
+
+	private FPSType fpsType;
+	private int playersCount;
+
+	enum FPSType{
+		DEATHMATCH, TEAM_DEATHMATCH, KING_OF_THE_HILL, ASSAULT, BATTLE_ROYALE, INFECTION;
+	}
+
+	public FirstPersonShooter(Long id, String name, List<Score> scores, FPSType fpsType, int playersCount) {
+		super(id, name, scores);
+		this.fpsType = fpsType;
+		this.playersCount = playersCount;
+	}
+
+	public static FirstPersonShooter generate() {
+		return new FirstPersonShooter(null, Tools.randomGameName(), null, Tools.random(FPSType.values()), Tools.random(new Integer[]{1,2,5,10,20,50,100}));
+	}
+	
+}
diff --git a/src/main/java/lab/data/Game.java b/src/main/java/lab/data/Game.java
new file mode 100644
index 0000000000000000000000000000000000000000..4bbec16f7b7ceffe3acbb59fa0da30a7a50428b6
--- /dev/null
+++ b/src/main/java/lab/data/Game.java
@@ -0,0 +1,33 @@
+package lab.data;
+
+import java.util.List;
+
+import lab.Tools;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@Getter
+@Setter
+@ToString
+@Builder(toBuilder = true)
+public class Game implements MyEntity{
+
+	private Long id;
+	private String name;
+	private List<Score> scores;
+
+	public static Game generate() {
+		return new Game(null, Tools.randomGameName(), null);
+	}
+
+	public static Game generateAny() {
+		return switch (Tools.RANDOM.nextInt(3)) {
+		case 0 -> generate();
+		case 1 -> PlatformGame.generate();
+		case 2 -> FirstPersonShooter.generate();
+		default -> generate();
+		};
+	}
+}
diff --git a/src/main/java/lab/data/Level.java b/src/main/java/lab/data/Level.java
deleted file mode 100644
index fc4e0318fc17ab7eb9863e7b4ae8ca4fb9e5154e..0000000000000000000000000000000000000000
--- a/src/main/java/lab/data/Level.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package lab.data;
-
-public enum Level {
-	EASY,  MEDIUM, HARD;
-}
diff --git a/src/main/java/lab/data/MyEntity.java b/src/main/java/lab/data/MyEntity.java
new file mode 100644
index 0000000000000000000000000000000000000000..f4005209d5759add24ff06d62cbb340f77fd9880
--- /dev/null
+++ b/src/main/java/lab/data/MyEntity.java
@@ -0,0 +1,6 @@
+package lab.data;
+
+public interface MyEntity {
+
+	Long getId();
+}
diff --git a/src/main/java/lab/data/PlatformGame.java b/src/main/java/lab/data/PlatformGame.java
new file mode 100644
index 0000000000000000000000000000000000000000..93d146533ce7ebe995144d45f26be109dbf4947a
--- /dev/null
+++ b/src/main/java/lab/data/PlatformGame.java
@@ -0,0 +1,32 @@
+package lab.data;
+
+import java.util.List;
+
+import lab.Tools;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@Getter
+@Setter
+@ToString(callSuper = true)
+public class PlatformGame extends Game{
+
+	private boolean retro;
+	private PlatformType platformType;
+	
+	enum PlatformType{
+		SINGLE_SCREEN, SCROLLING;
+	}
+	
+	 public PlatformGame(Long id, String name, List<Score> scores, boolean retro, PlatformType platformType) {
+		super(id, name, scores);
+		this.retro = retro;
+		this.platformType = platformType;
+	}
+
+	public static PlatformGame generate() {
+		return new PlatformGame(null, Tools.randomGameName(), null, Tools.RANDOM.nextBoolean(), Tools.random(PlatformType.values()));
+	}
+
+}
diff --git a/src/main/java/lab/data/Player.java b/src/main/java/lab/data/Player.java
new file mode 100644
index 0000000000000000000000000000000000000000..faedbd39736fa009a78260282064886d3c1a764b
--- /dev/null
+++ b/src/main/java/lab/data/Player.java
@@ -0,0 +1,28 @@
+package lab.data;
+
+import java.util.List;
+
+import lab.Tools;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+@Getter
+@Setter
+@ToString
+@Builder(toBuilder = true)
+public class Player  implements MyEntity{
+
+	
+	private Long id;
+	private String firstName;
+	private String lastName;
+	private String nick;
+	private List<Score> scores;
+
+	public static Player generate() {
+		return new Player(null, Tools.randomFistName(), Tools.randomLastName(), Tools.randomNick(), null);
+	}
+
+}
diff --git a/src/main/java/lab/data/Score.java b/src/main/java/lab/data/Score.java
index 2be798381f3f0f0634acc64df29fa574b38e4ee7..314677ec506d27c384a56c98c36045a8674fc4d7 100644
--- a/src/main/java/lab/data/Score.java
+++ b/src/main/java/lab/data/Score.java
@@ -1,66 +1,34 @@
 package lab.data;
 
-import java.util.Random;
+import java.util.List;
 
-import jakarta.persistence.Entity;
 import jakarta.persistence.EnumType;
 import jakarta.persistence.Enumerated;
-import jakarta.persistence.GeneratedValue;
-import jakarta.persistence.GenerationType;
-import jakarta.persistence.Id;
-import lombok.AllArgsConstructor;
+import lab.Tools;
 import lombok.Builder;
-import lombok.EqualsAndHashCode;
 import lombok.Getter;
-import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.ToString;
 
-@Entity
 @Getter
 @Setter
-@AllArgsConstructor
-@NoArgsConstructor
-@EqualsAndHashCode
 @ToString
 @Builder(toBuilder = true)
-public class Score {
+public class Score  implements MyEntity{
 
-	private static final Random RANDOM = new Random();
-	
-	@Id
-	@GeneratedValue(strategy = GenerationType.AUTO)
 	private Long id;
-	private String name;
 	private int points;
 	@Enumerated(EnumType.STRING)
-	private Level level;
+	private Difficult level;
+	private Player player;
+	private Game game;
 	
 	
-	public static Score generate() {
-		return new Score(null, getRandomNick(), RANDOM.nextInt(50, 300), Level.values()[RANDOM.nextInt(Level.values().length)]);
+	public static Score generate(List<Player> players, List<Game> games) {
+		return new Score(null, Tools.RANDOM.nextInt(100, 2000), Tools.random(Difficult.values()), Tools.randomElementFrom(players), Tools.randomElementFrom(games));
 	}
 	
-	public static final String[] nicks = { "CyberSurfer", "PixelPioneer", "SocialSavvy", "DigitalDynamo", "ByteBuddy", "InstaGuru",
-			"TikTokTornado", "SnapMaster", "TweetTrendsetter", "ChatChampion", "HashtagHero", "EmojiEnthusiast",
-			"StoryStylist", "SelfieStar", "FilterFanatic", "VlogVirtuoso", "Memelord", "InfluencerInsider",
-			"StreamSupreme", "GeekyGizmo", "CodeCommander", "JavaJuggernaut", "ByteNinja", "SyntaxSamurai",
-			"ClassyCoder", "ObjectOmnipotent", "LoopLegend", "VariableVirtuoso", "DebugDemon", "CompilerCrusader",
-			"PixelProdigy", "VirtualVoyager", "AlgorithmAce", "DataDynamo", "ExceptionExpert", "BugBuster",
-			"SyntaxSorcerer", "CodeCrusader", "JavaJester", "NerdyNavigator", "CryptoCaptain", "SocialButterfly",
-			"AppArchitect", "WebWizard", "FunctionFreak", "PixelArtist", "CyberPhantom", "HackHero", "CacheChampion",
-			"ScreenSage", "WebWeaver", "LogicLover", "BitBlazer", "NetworkNomad", "ProtocolPioneer", "BinaryBoss",
-			"StackSultan", "SocialScribe", "RenderRuler", "ScriptSorcerer", "HTMLHero", "PixelProwler", "FrameFreak",
-			"DataDreamer", "BotBuilder", "ByteBishop", "KeyboardKnight", "DesignDaredevil", "JavaJuggler",
-			"SyntaxStrategist", "TechTactician", "ProgramProdigy", "BinaryBard", "PixelPoet", "GigabyteGuru",
-			"TechTrekker", "NetworkNinja", "DataDetective", "MatrixMaster", "CodeConductor", "AppAlchemist",
-			"ServerSage", "ClusterChampion", "ScriptSensei", "KeyboardKicker", "CacheCrafter", "SocialSpark",
-			"BinaryBeast", "CodeConnoisseur", "BitBrain", "VirtualVanguard", "SystemSculptor", "RenderRogue",
-			"CryptoConqueror", "MachineMonarch", "PixelPal", "CompilerCaptain", "BitBuilder", "TechTitan",
-			"CloudConqueror", "EchoExplorer", "FunctionFanatic", "RobotRanger" };
-	
-	public static String getRandomNick() {
-		return nicks[RANDOM.nextInt(nicks.length)];
+	public enum Difficult {
+		EASY,  MEDIUM, HARD;
 	}
-
 }
diff --git a/src/main/java/lab/game/AngleChange.java b/src/main/java/lab/game/AngleChange.java
deleted file mode 100644
index 5bb3467c53bde38df1a22ea8b83105d29a6947ec..0000000000000000000000000000000000000000
--- a/src/main/java/lab/game/AngleChange.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package lab.game;
-
-public enum AngleChange {
-	UP, DOWN;
-}
diff --git a/src/main/java/lab/game/Bullet.java b/src/main/java/lab/game/Bullet.java
deleted file mode 100644
index 709849e4c86c49d87ba9b86f9ffdbed2a65b0e0b..0000000000000000000000000000000000000000
--- a/src/main/java/lab/game/Bullet.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package lab.game;
-
-import javafx.geometry.Point2D;
-import javafx.geometry.Rectangle2D;
-import javafx.scene.canvas.GraphicsContext;
-import javafx.scene.paint.Color;
-
-public class Bullet extends WorldEntity implements Collisionable{
-	private static final double SIZE = 20;
-
-	protected final Point2D acceleration;
-	protected Point2D velocity;
-
-	public Bullet(World world, Point2D position, Point2D velocity, Point2D acceleration) {
-		super(world, position);
-		this.velocity = velocity;
-		this.acceleration = acceleration;
-	}
-
-	@Override
-	public void drawInternal(GraphicsContext gc) {
-		gc.setFill(Color.SILVER);
-		gc.fillOval(position.getX(), position.getY(), SIZE, SIZE);
-	}
-
-	@Override
-	public void simulate(double deltaT) {
-		position = position.add(velocity.multiply(deltaT));
-		velocity = velocity.add(acceleration.multiply(deltaT));
-	}
-
-	@Override
-	public Rectangle2D getBoundingBox() {
-		return new Rectangle2D(position.getX(), position.getY(), SIZE, SIZE);
-	}
-
-	@Override
-	public boolean intersect(Rectangle2D another) {
-		return getBoundingBox().intersects(another);
-	}
-
-	@Override
-	public void hitBy(Collisionable another) {
-		
-	}
-
-	public void setVelocity(Point2D velocity) {
-		this.velocity = velocity;
-	}
-
-}
diff --git a/src/main/java/lab/game/BulletAnimated.java b/src/main/java/lab/game/BulletAnimated.java
deleted file mode 100644
index 25ba35bd9d862012d34bf632ec31e1798468d4ef..0000000000000000000000000000000000000000
--- a/src/main/java/lab/game/BulletAnimated.java
+++ /dev/null
@@ -1,59 +0,0 @@
-package lab.game;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import javafx.geometry.Point2D;
-import javafx.geometry.Rectangle2D;
-import javafx.scene.canvas.GraphicsContext;
-import javafx.scene.image.Image;
-
-public class BulletAnimated extends Bullet {
-
-	private static final double SIZE = 40;
-	private final Point2D initVelocity;
-	private Cannon cannon;
-	private static Image image = new Image(BulletAnimated.class.getResourceAsStream("fireball-transparent.gif"));
-	
-	private List<HitListener> hitListeners = new ArrayList<>();
-
-	public BulletAnimated(World world, Cannon cannon, Point2D position, Point2D velocity, Point2D acceleration) {
-		super(world, position, velocity, acceleration);
-		this.initVelocity = velocity;
-		this.cannon = cannon;
-	}
-
-	@Override
-	public void drawInternal(GraphicsContext gc) {
-		gc.drawImage(image, getPosition().getX(), getPosition().getY(), SIZE, SIZE);
-		gc.strokeRect(position.getX(), position.getY(), SIZE, SIZE);
-	}
-
-	@Override
-	public void hitBy(Collisionable another) {
-		if (another instanceof Ufo) {
-			world.remove(this);
-			fireUfoDestroyed();
-		}
-	}
-
-	public void reload() {
-		position = cannon.getPosition();
-		velocity = new Point2D(0, 0);
-	}
-
-	public boolean addHitListener(HitListener e) {
-		return hitListeners.add(e);
-	}
-
-	public boolean removeHitListener(HitListener o) {
-		return hitListeners.remove(o);
-	}
-
-	private void fireUfoDestroyed() {
-		for (HitListener hitListener : hitListeners) {
-			hitListener.ufoDestroyed();
-		}
-	}
-
-}
\ No newline at end of file
diff --git a/src/main/java/lab/game/Cannon.java b/src/main/java/lab/game/Cannon.java
deleted file mode 100644
index cf53855d94fb781ea4dc6437e37f9f4d9bb08976..0000000000000000000000000000000000000000
--- a/src/main/java/lab/game/Cannon.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package lab.game;
-
-import javafx.geometry.Point2D;
-import javafx.scene.canvas.GraphicsContext;
-import javafx.scene.paint.Color;
-import javafx.scene.transform.Affine;
-import javafx.scene.transform.Transform;
-
-public class Cannon extends WorldEntity{
-
-	private static final double LENGTH = 60;
-	private static final double WIDTH = 15;
-	private double angle;
-	private double angleDelta = -25;
-
-	public Cannon(World world, Point2D position, double angle) {
-		super(world, position);
-		this.angle = angle;
-	}
-
-	@Override
-	public void drawInternal(GraphicsContext gc) {
-		gc.transform(new Affine(Transform.rotate(angle, position.getX(), position.getY() + WIDTH / 2)));
-		gc.setFill(Color.BROWN);
-		gc.fillRect(position.getX(), position.getY(), LENGTH, WIDTH);
-	}
-
-	@Override
-	public void simulate(double deltaT) {
-//		angle += angleDelta * deltaT;
-//		if (angle >= 0 || angle <= -90) {
-//			angleDelta = -angleDelta;
-//		}
-	}
-
-	public double getAngle() {
-		return angle;
-	}
-
-	public void setAngle(double angle) {
-		this.angle = -angle;
-	}
-	
-}
diff --git a/src/main/java/lab/game/Collisionable.java b/src/main/java/lab/game/Collisionable.java
deleted file mode 100644
index cf0bcdf8d4599ae18a428362a81c16c429fc1b8b..0000000000000000000000000000000000000000
--- a/src/main/java/lab/game/Collisionable.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package lab.game;
-
-import javafx.geometry.Rectangle2D;
-
-public interface Collisionable {
-
-	Rectangle2D getBoundingBox();
-
-	boolean intersect(Rectangle2D another);
-
-	void hitBy(Collisionable another);
-
-}
diff --git a/src/main/java/lab/game/DrawableSimulable.java b/src/main/java/lab/game/DrawableSimulable.java
deleted file mode 100644
index 244dd11f8ab75c3964d3415e7d8542fd1cd7da94..0000000000000000000000000000000000000000
--- a/src/main/java/lab/game/DrawableSimulable.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package lab.game;
-
-import javafx.scene.canvas.GraphicsContext;
-
-public interface DrawableSimulable {
-	void draw(GraphicsContext gc);
-
-	void simulate(double deltaT);
-}
diff --git a/src/main/java/lab/game/DrawingThread.java b/src/main/java/lab/game/DrawingThread.java
deleted file mode 100644
index 426b8c0a48f1d5f387401dedac7c414e99c4baa0..0000000000000000000000000000000000000000
--- a/src/main/java/lab/game/DrawingThread.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package lab.game;
-
-import javafx.animation.AnimationTimer;
-import javafx.scene.canvas.Canvas;
-import javafx.scene.canvas.GraphicsContext;
-
-public class DrawingThread extends AnimationTimer {
-
-	private final Canvas canvas;
-	private final GraphicsContext gc;
-	private final World world;
-	private long lastTime;
-
-	public DrawingThread(Canvas canvas) {
-		this.canvas = canvas;
-		this.gc = canvas.getGraphicsContext2D();
-		world = new World(canvas.getWidth(), canvas.getHeight());
-		lastTime = System.nanoTime();
-	}
-
-	/**
-	 * Draws objects into the canvas. Put you code here.
-	 */
-	@Override
-	public void handle(long now) {
-		double deltaT = (now - lastTime) / 1e9;
-		// call draw on world
-		this.world.draw(gc);
-		// call simulate on world
-		this.world.simulate(deltaT);
-		lastTime = now;
-	}
-
-	public World getWorld() {
-		return world;
-	}
-
-}
diff --git a/src/main/java/lab/game/ForceChange.java b/src/main/java/lab/game/ForceChange.java
deleted file mode 100644
index b8cadc9e945fb64f8174dd420e1a29c700db215d..0000000000000000000000000000000000000000
--- a/src/main/java/lab/game/ForceChange.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package lab.game;
-
-public enum ForceChange {
-	UP, DOWN; 
-}
diff --git a/src/main/java/lab/game/HitListener.java b/src/main/java/lab/game/HitListener.java
deleted file mode 100644
index c40f90306d42beb9394d09a2adef4434ff876501..0000000000000000000000000000000000000000
--- a/src/main/java/lab/game/HitListener.java
+++ /dev/null
@@ -1,6 +0,0 @@
-package lab.game;
-
-@FunctionalInterface
-public interface HitListener {
-	void ufoDestroyed();
-}
diff --git a/src/main/java/lab/game/Routines.java b/src/main/java/lab/game/Routines.java
deleted file mode 100644
index 47e508c666c9eee42ab601836b4706e8ff9b83e9..0000000000000000000000000000000000000000
--- a/src/main/java/lab/game/Routines.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package lab.game;
-
-public class Routines {
-
-	
-	
-	public static void sleep(int timeInMilisenonds) {
-		try {
-			Thread.sleep(timeInMilisenonds);
-		} catch (InterruptedException e) {
-			Thread.currentThread().interrupt();
-		}
-	}
-	
-	public static boolean isEndOfThreadRequestedByJavaVM() {
-		return Thread.interrupted();
-	}
-}
diff --git a/src/main/java/lab/game/Ufo.java b/src/main/java/lab/game/Ufo.java
deleted file mode 100644
index 9aa6bdf550268b2f86efc494818d82eb82c9ed18..0000000000000000000000000000000000000000
--- a/src/main/java/lab/game/Ufo.java
+++ /dev/null
@@ -1,85 +0,0 @@
-package lab.game;
-
-import java.time.LocalDateTime;
-import java.util.Random;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
-import javafx.geometry.Point2D;
-import javafx.geometry.Rectangle2D;
-import javafx.scene.canvas.GraphicsContext;
-import javafx.scene.image.Image;
-import lab.Setting;
-
-public class Ufo extends WorldEntity implements Collisionable {
-
-	private static Logger log = LogManager.getLogger(Ufo.class);
-
-	private static final Random RANDOM = new Random();
-	private Image image;
-	private Point2D velocity;
-	
-	public Ufo(World world) {
-		this(world,
-				new Point2D(RANDOM.nextDouble(world.getWidth()),
-						RANDOM.nextDouble(0, world.getHeight() * Setting.getInstance().getUfoMinPercentageHeight())),
-				new Point2D(RANDOM.nextDouble(Setting.getInstance().getUfoMinSpeed(),
-						Setting.getInstance().getUfoMaxSpeed()), 0));
-	}
-
-	public Ufo(World world, Point2D position, Point2D velocity) {
-		super(world, position);
-		this.velocity = velocity;
-	}
-
-	private Image getImage() {
-		if (image == null) {
-			image = new Image(Ufo.class.getResourceAsStream("ufo-small.gif"));
-		}
-		return image;
-
-	}
-
-	@Override
-	public void drawInternal(GraphicsContext gc) {
-		gc.drawImage(getImage(), getPosition().getX(), getPosition().getY());
-	}
-
-	public void changeDirection() {
-		velocity = velocity.multiply(-1);
-		log.debug("Ufo chaned direction.");
-	}
-
-	@Override
-	public void simulate(double deltaT) {
-		position = position.add(velocity.multiply(deltaT));
-		position = new Point2D(position.getX() % world.getWidth(), position.getY());
-		if (position.getX() < -getImage().getWidth()) {
-			position = new Point2D(world.getWidth(), position.getY());
-		}
-		log.trace("Ufo position: {}", position);
-	}
-
-	@Override
-	public Rectangle2D getBoundingBox() {
-		return new Rectangle2D(position.getX(), position.getY(), getImage().getWidth(), getImage().getHeight());
-	}
-
-	@Override
-	public boolean intersect(Rectangle2D another) {
-		return getBoundingBox().intersects(another);
-	}
-
-	@Override
-	public void hitBy(Collisionable another) {
-		log.trace("Ufo hitted by {}.", another);
-		if (another instanceof BulletAnimated || another instanceof Bullet) {
-			world.add(new UfoDestroyLog(LocalDateTime.now(), getPosition()));
-			world.remove(this);
-		}
-	}
-	
-	record UfoDestroyLog(LocalDateTime time, Point2D position) {}
-	
-}
diff --git a/src/main/java/lab/game/World.java b/src/main/java/lab/game/World.java
deleted file mode 100644
index 929445f4697c160641ef6f832b3ae1007a772192..0000000000000000000000000000000000000000
--- a/src/main/java/lab/game/World.java
+++ /dev/null
@@ -1,112 +0,0 @@
-package lab.game;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
-
-import javafx.geometry.Point2D;
-import javafx.scene.canvas.GraphicsContext;
-import lab.Setting;
-import lab.game.Ufo.UfoDestroyLog;
-import lombok.extern.log4j.Log4j2;
-
-@Log4j2
-public class World {
-
-	public static final Point2D GRAVITY = new Point2D(0, Setting.getInstance().getGravity());
-	private final double width;
-
-	private final double height;
-
-	private List<DrawableSimulable> entities;
-	private Collection<DrawableSimulable> entitiesToRemove = new LinkedList<>();
-	private Collection<DrawableSimulable> entitiesToAdd = new LinkedList<>();
-	private List<UfoDestroyLog> destroyLogs = new LinkedList<>();
-
-	private Cannon cannon;
-//	private BulletAnimated bulletAnimated;
-
-	public World(double width, double height) {
-		this.width = width;
-		this.height = height;
-		entities = new ArrayList<>();
-		cannon = new Cannon(this, new Point2D(0, height - 20), -45);
-		entities.add(cannon);
-		entities.add(new Bullet(this, new Point2D(0, height),
-				new Point2D(Setting.getInstance().getNormalBulletSpeed(), -Setting.getInstance().getNormalBulletSpeed()),
-				GRAVITY));
-		for (int i = 0; i < Setting.getInstance().getNumberOfUfos(); i++) {
-			entities.add(new Ufo(this));
-		}
-	}
-
-	
-	public void add(UfoDestroyLog ufoDestroyLog) {
-		destroyLogs.add(ufoDestroyLog);
-	}
-
-	public void pringDestroylog() {
-		for (UfoDestroyLog ufoDestroyLog : destroyLogs) {
-			log.info(ufoDestroyLog);
-		}
-	}
-
-	public void draw(GraphicsContext gc) {
-		gc.clearRect(0, 0, width, height);
-
-		gc.save();
-		for (DrawableSimulable entity : entities) {
-			entity.draw(gc);
-		}
-		gc.restore();
-	}
-
-	public void simulate(double deltaT) {
-		for (DrawableSimulable entity : entities) {
-			entity.simulate(deltaT);
-		}
-		for (int i = 0; i < entities.size(); i++) {
-			if (entities.get(i) instanceof Collisionable c1) {
-				for (int j = i + 1; j < entities.size(); j++) {
-					if (entities.get(j) instanceof Collisionable c2) {
-						if (c1.intersect(c2.getBoundingBox())) {
-							c1.hitBy(c2);
-							c2.hitBy(c1);
-						}
-					}
-				}
-			}
-		}
-		entities.removeAll(entitiesToRemove);
-		entities.addAll(entitiesToAdd);
-		entitiesToAdd.clear();
-		entitiesToRemove.clear();
-	}
-
-	public double getWidth() {
-		return width;
-	}
-
-	public void add(DrawableSimulable entity) {
-		entitiesToAdd.add(entity);
-	}
-
-	public void remove(DrawableSimulable entity) {
-		entitiesToRemove.add(entity);
-
-	}
-
-	public double getHeight() {
-		return height;
-	}
-
-	public Cannon getCannon() {
-		return cannon;
-	}
-
-//	public BulletAnimated getBulletAnimated() {
-//		return bulletAnimated;
-//	}
-//
-}
\ No newline at end of file
diff --git a/src/main/java/lab/game/WorldEntity.java b/src/main/java/lab/game/WorldEntity.java
deleted file mode 100644
index 73e0f0b00e5d5ea773fc46266cb15837b7c3b772..0000000000000000000000000000000000000000
--- a/src/main/java/lab/game/WorldEntity.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package lab.game;
-
-import javafx.geometry.Point2D;
-import javafx.scene.canvas.GraphicsContext;
-
-public abstract  class WorldEntity implements DrawableSimulable{
-
-	protected final World world;
-	protected Point2D position;
-
-	protected WorldEntity(World world, Point2D position) {
-		this.world = world;
-		this.position = position;
-	}
-
-	@Override
-	public final void draw(GraphicsContext gc) {
-		gc.save();
-		drawInternal(gc);
-		gc.restore();
-	}
-	
-	public abstract void drawInternal(GraphicsContext gc);
-
-	public Point2D getPosition() {
-		return position;
-	}
-
-	
-}
diff --git a/src/main/java/lab/gui/App.java b/src/main/java/lab/gui/App.java
deleted file mode 100644
index 8381fc319d55520e3590466506b33d19e50a1140..0000000000000000000000000000000000000000
--- a/src/main/java/lab/gui/App.java
+++ /dev/null
@@ -1,81 +0,0 @@
-package lab.gui;
-
-import java.sql.SQLException;
-
-import org.h2.tools.Server;
-
-import javafx.application.Application;
-import javafx.fxml.FXMLLoader;
-import javafx.scene.Parent;
-import javafx.scene.Scene;
-import javafx.stage.Stage;
-import javafx.stage.WindowEvent;
-import lab.Setting;
-import lab.storage.JpaConnector;
-import lombok.extern.log4j.Log4j2;
-
-/**
- * Class <b>App</b> - extends class Application and it is an entry point of the
- * program
- * 
- * @author Java I
- */
-@Log4j2
-public class App extends Application {
-
-	private GameController gameController;
-
-	public static void main(String[] args) {
-		log.info("Application lauched");
-		Setting.configure(Setting.builder().scoreStorageInterface(new JpaConnector()).build());
-
-		startH2WebServerToInspectDb();
-
-		launch(args);
-	}
-
-	private static void startH2WebServerToInspectDb() {
-		//Start HTTP server for access H2 DB for look inside 
-		try {
-		    Server server = Server.createWebServer();
-		    log.info(server.getURL());
-		    server.start();
-		} catch (SQLException e) {
-		    e.printStackTrace();
-		}
-	}
-
-	@Override
-	public void start(Stage primaryStage) {
-		try {
-			// Construct a main window with a canvas.
-			FXMLLoader gameLoader = new FXMLLoader(getClass().getResource("/lab/gui/gameWindow.fxml"));
-			Parent root = gameLoader.load();
-			gameController = gameLoader.getController();
-			Scene scene = new Scene(root);
-			primaryStage.setScene(scene);
-			primaryStage.setTitle("Java 2 - 2nd laboratory");
-			primaryStage.show();
-			// Exit program when main window is closed
-			primaryStage.setOnCloseRequest(this::exitProgram);
-		} catch (Exception e) {
-			log.error("Error during game play.", e);
-		}
-	}
-
-	@Override
-	public void stop() throws Exception {
-		gameController.stop();
-		super.stop();
-		log.info("Gamne stoped");
-	}
-
-	private void exitProgram(WindowEvent evt) {
-		if (gameController != null) {
-			gameController.stop();
-		}
-		Setting.getInstance().getScoreStorageInterface().stop();
-		log.info("Exiting game");
-		System.exit(0);
-	}
-}
\ No newline at end of file
diff --git a/src/main/java/lab/gui/GameController.java b/src/main/java/lab/gui/GameController.java
deleted file mode 100644
index 6ee31ad394841659d04139ef2de68e376bb2f5d4..0000000000000000000000000000000000000000
--- a/src/main/java/lab/gui/GameController.java
+++ /dev/null
@@ -1,177 +0,0 @@
-package lab.gui;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
-import javafx.collections.ListChangeListener;
-import javafx.event.ActionEvent;
-import javafx.fxml.FXML;
-import javafx.geometry.Point2D;
-import javafx.scene.canvas.Canvas;
-import javafx.scene.control.Button;
-import javafx.scene.control.Label;
-import javafx.scene.control.SelectionMode;
-import javafx.scene.control.Slider;
-import javafx.scene.control.TableColumn;
-import javafx.scene.control.TableView;
-import javafx.scene.control.cell.PropertyValueFactory;
-import javafx.scene.input.KeyEvent;
-import javafx.scene.input.MouseEvent;
-import lab.Setting;
-import lab.data.Level;
-import lab.data.Score;
-import lab.game.BulletAnimated;
-import lab.game.DrawingThread;
-import lab.game.World;
-
-public class GameController {
-
-	private static Logger log = LogManager.getLogger(GameController.class);
-
-	@FXML
-	private Button btnGenerateScore;
-
-	@FXML
-	private Button btnLoadAll;
-
-	@FXML
-	private Button btnLoadFirstTen;
-
-	@FXML
-	private Button btnDelete;
-
-	@FXML
-	private Slider angle;
-
-	@FXML
-	private Slider speed;
-
-	@FXML
-	private Canvas canvas;
-
-	@FXML
-	private TableView<Score> scores;
-
-	@FXML
-	private TableColumn<Score, String> nickColumn;
-
-	@FXML
-	private TableColumn<Score, Integer> pointsColumn;
-
-	@FXML
-	private TableColumn<Score, Level> levelColumn;
-
-	private DrawingThread timer;
-
-	@FXML
-	private Label hits;
-	private int hitcount = 0;
-
-	@FXML
-	void fire(ActionEvent event) {
-		double angle = timer.getWorld().getCannon().getAngle();
-		double angleRad = Math.toRadians(angle);
-		double speedValue = speed.getValue();
-		Point2D velocity = new Point2D(Math.cos(angleRad) * speedValue, Math.sin(angleRad) * speedValue);
-		BulletAnimated bulletAnimated = new BulletAnimated(timer.getWorld(), timer.getWorld().getCannon(),
-				timer.getWorld().getCannon().getPosition(), velocity, World.GRAVITY);
-		timer.getWorld().add(bulletAnimated);
-		bulletAnimated.addHitListener(this::increaseHits);
-		bulletAnimated.addHitListener(() -> log.info("au!!!!"));
-	}
-
-	@FXML
-	void btnGenerateScoreAction(ActionEvent event) {
-		Score score = Score.generate();
-		this.scores.getItems().add(score);
-		Setting.getInstance().getScoreStorageInterface().save(score);
-	}
-
-	@FXML
-	void btnLoadAllAction(ActionEvent event) {
-		updateScoreTable(Setting.getInstance().getScoreStorageInterface().getAll());
-	}
-
-	@FXML
-	void btnLoadFirstTenAction(ActionEvent event) {
-		updateScoreTable(Setting.getInstance().getScoreStorageInterface().getFirstTen());
-	}
-
-	@FXML
-	void btnDeleteAction(ActionEvent event) {
-		List<Score> selectedScores = new ArrayList<>(scores.getSelectionModel().getSelectedItems());
-		Setting.getInstance().getScoreStorageInterface().delete(selectedScores);
-		updateScoreTable(Setting.getInstance().getScoreStorageInterface().getAll());
-	}
-
-	@FXML
-	void keyPressed(KeyEvent event) {
-		log.info(event.getCode());
-		event.consume();
-	}
-
-	@FXML
-	void canvasClicked(MouseEvent event) {
-		canvas.requestFocus();
-	}
-
-	@FXML
-	void keyReleased(KeyEvent event) {
-
-	}
-
-	private void updateScoreTable(List<Score> scores) {
-		this.scores.getItems().clear();
-		this.scores.getItems().addAll(scores);
-	}
-
-	private void updateHits() {
-		hits.setText(String.format("Hit count: %03d", hitcount));
-	}
-
-	private void increaseHits() {
-		hitcount++;
-		updateHits();
-	}
-
-	@FXML
-	void initialize() {
-		assert angle != null : "fx:id=\"angle\" was not injected: check your FXML file 'gameWindow.fxml'.";
-		assert canvas != null : "fx:id=\"canvas\" was not injected: check your FXML file 'gameWindow.fxml'.";
-		assert speed != null : "fx:id=\"speed\" was not injected: check your FXML file 'gameWindow.fxml'.";
-		speed.setMin(Setting.getInstance().getBulletMinSpeed());
-		speed.setMax(Setting.getInstance().getBulletMaxSpeed());
-		timer = new DrawingThread(canvas);
-		timer.start();
-		angle.valueProperty().addListener(
-				(observable, oldValue, newValue) -> timer.getWorld().getCannon().setAngle(newValue.doubleValue()));
-
-		nickColumn.setCellValueFactory(new PropertyValueFactory<>("name"));
-		pointsColumn.setCellValueFactory(new PropertyValueFactory<>("points"));
-		levelColumn.setCellValueFactory(new PropertyValueFactory<>("level"));
-
-		btnDelete.setDisable(true);
-		scores.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
-		scores.getSelectionModel().getSelectedItems()
-				.addListener((ListChangeListener.Change<? extends Score> change) -> 
-					btnDelete.setDisable(change.getList().isEmpty()));
-
-		initStorage();
-		log.info("Screeen initialized.");
-		canvas.requestFocus();
-	}
-
-	private void initStorage() {
-		Setting.getInstance().getScoreStorageInterface().init();
-		scores.getItems().addAll(Setting.getInstance().getScoreStorageInterface().getAll());
-	}
-
-	public void stop() {
-		timer.getWorld().pringDestroylog();
-		timer.stop();
-	}
-
-}
diff --git a/src/main/java/lab/storage/DbConnector.java b/src/main/java/lab/storage/DbConnector.java
deleted file mode 100644
index 4b1e19084c83c05b136ef332e9addf755eb2b7b8..0000000000000000000000000000000000000000
--- a/src/main/java/lab/storage/DbConnector.java
+++ /dev/null
@@ -1,84 +0,0 @@
-package lab.storage;
-
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.util.ArrayList;
-import java.util.List;
-
-import lab.data.Score;
-
-public class DbConnector implements ScoreStorageInterface {
-
-	private static final String JDBC_CONECTIN_STRING = "jdbc:h2:file:./scoreDB";
-
-	@Override
-	public List<Score> getAll() {
-		return queryScore("select * from scores;");
-	}
-
-	@Override
-	public List<Score> getFirstTen() {
-		return queryScore("select * from scores order by points  desc limit 10;");
-	}
-
-	private List<Score> queryScore(String query) {
-		List<Score> result = new ArrayList<>();
-		try (Connection con = DriverManager.getConnection(JDBC_CONECTIN_STRING);
-				Statement stm = con.createStatement();
-				ResultSet rs = stm.executeQuery(query);) {
-			while (rs.next()) {
-				result.add(new Score(null, rs.getString("nick"), rs.getInt("points"), null));
-			}
-		} catch (SQLException e) {
-			e.printStackTrace();
-		}
-		return result;
-	}
-
-	@Override
-	public void init() {
-		try (Connection con = DriverManager.getConnection(JDBC_CONECTIN_STRING);
-				Statement stm = con.createStatement();) {
-			stm.executeUpdate("CREATE TABLE if not exists scores (nick VARCHAR(50) NOT NULL, points INT NOT NULL);");
-		} catch (SQLException e) {
-			e.printStackTrace();
-		}
-	}
-
-	@Override
-	public Score save(Score score) {
-		try (Connection con = DriverManager.getConnection(JDBC_CONECTIN_STRING);
-				PreparedStatement stm = con.prepareStatement("INSERT INTO scores VALUES (?, ?)");) {
-			stm.setString(1, score.getName());
-			stm.setInt(2, score.getPoints());
-			stm.executeUpdate();
-		} catch (SQLException e) {
-			e.printStackTrace();
-		}
-		return score;
-	}
-
-	@Override
-	public void delete(List<Score> scores) {
-		try (Connection con = DriverManager.getConnection(JDBC_CONECTIN_STRING);
-				PreparedStatement stm = con.prepareStatement("DELETE FROM scores WHERE nick=? AND points=?");) {
-			for (Score score : scores) {
-				stm.setString(1, score.getName());
-				stm.setInt(2, score.getPoints());
-				stm.executeUpdate();
-			}
-		} catch (SQLException e) {
-			e.printStackTrace();
-		}
-	}
-
-	@Override
-	public void stop() {
-		/*nothing to do*/
-	}
-		
-}
diff --git a/src/main/java/lab/storage/FileStorage.java b/src/main/java/lab/storage/FileStorage.java
deleted file mode 100644
index 828ca068af9f5b7539ab0dec4c62fedf417d4fc4..0000000000000000000000000000000000000000
--- a/src/main/java/lab/storage/FileStorage.java
+++ /dev/null
@@ -1,75 +0,0 @@
-package lab.storage;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.nio.file.StandardOpenOption;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.stream.Stream;
-
-import lab.data.Score;
-
-public class FileStorage implements ScoreStorageInterface {
-
-	private static final String SCORE_FILE_NAME = "scores.csv";
-
-	@Override
-	public List<Score> getAll() {
-		if (Files.exists(Paths.get(SCORE_FILE_NAME))) {
-			try (Stream<String> lines = Files.lines(Paths.get(SCORE_FILE_NAME))) {
-				List<Score> result = lines.map(line -> line.split(";"))
-						.map(parts -> new Score(null, parts[0], Integer.parseInt(parts[1]), null)).toList();
-				return new ArrayList<>(result);
-			} catch (IOException e) {
-				e.printStackTrace();
-			}
-		}
-		return new ArrayList<>();
-	}
-
-	@Override
-	public List<Score> getFirstTen() {
-		List<Score> all = getAll();
-		Collections.sort(all, Comparator.comparing(Score::getPoints).reversed());
-		return all.subList(0, 10);
-	}
-
-	@Override
-	public void init() {
-		/* noting to do */
-	}
-
-	@Override
-	public Score save(Score score) {
-		List<Score> all = getAll();
-		all.add(score);
-		storeAll(all);
-		return score;
-	}
-
-	private void storeAll(List<Score> all) {
-		List<String> lines = all.stream().map(s -> String.format("%s;%d", s.getName(), s.getPoints())).toList();
-		try {
-			Files.write(Paths.get(SCORE_FILE_NAME), lines, StandardOpenOption.TRUNCATE_EXISTING);
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-	}
-
-	@Override
-	public void delete(List<Score> scores) {
-		List<Score> all = getAll();
-		all.removeAll(scores);
-		storeAll(all);
-		
-	}
-
-	@Override
-	public void stop() {
-		/*nothing to do*/
-	}
-
-}
diff --git a/src/main/java/lab/storage/JpaConnector.java b/src/main/java/lab/storage/JpaConnector.java
index 3dc74583703c73a1a552dd522a7d347cc89a8a08..2115152d0d1394c3f7ba8d662761a902e5cd1e6a 100644
--- a/src/main/java/lab/storage/JpaConnector.java
+++ b/src/main/java/lab/storage/JpaConnector.java
@@ -6,9 +6,10 @@ import java.util.function.Consumer;
 import jakarta.persistence.EntityManager;
 import jakarta.persistence.EntityManagerFactory;
 import jakarta.persistence.Persistence;
+import lab.data.MyEntity;
 import lab.data.Score;
 
-public class JpaConnector implements ScoreStorageInterface {
+public class JpaConnector {
 
 	private EntityManagerFactory emf;
 	private EntityManager em;
@@ -18,57 +19,32 @@ public class JpaConnector implements ScoreStorageInterface {
 		em = emf.createEntityManager();
 	}
 
-	@Override
-	public List<Score> getAll() {
-		return em.createQuery("select s from Score s", Score.class).getResultList();
+	public<T extends MyEntity> List<T> getAll(Class<T> clazz) {
+		return null;
 	}
 
-	@Override
-	public List<Score> getFirstTen() {
-		return em.createQuery("select s from Score s order by s.points DESC", Score.class).setMaxResults(10)
-				.getResultList();
-	}
-
-	@Override
 	public void init() {
 	}
 
-	@Override
-	public Score save(Score score) {
-		Score result;
-		em.getTransaction().begin();
-		if (score.getId() == null || score.getId() == 0) {
-			em.persist(score);
-			result = score;
-		} else {
-			result = em.merge(score);
-		}
-		em.getTransaction().commit();
-		return result;
+	public<T extends MyEntity> T save(T score) {
+		return null;
 	}
 
-	@Override
-	public void delete(List<Score> scores) {
-		em.getTransaction().begin();
-		for (Score score : scores) {
-			em.remove(score);
-		}
-		em.getTransaction().commit();
+	public void delete(List<? extends MyEntity> e) {
 	}
 
-	@Override
 	public void stop() {
 		em.close();
 		emf.close();
 	}
 
-	public Object getEntityManager() {
+	public EntityManager getEntityManager() {
 		//return entity manager. Type Object is there because of compilation of empty task assignment
 		return em;
 	}
 
-	public Score find(long id) {
-		return em.find(Score.class, id);
+	public<T> T find(long id, Class<T> clazz) {
+		return em.find(clazz, id);
 	}
 	
 	public void modifyNoPersistOrMerge(long id, Consumer<Score> motificator) {
@@ -77,5 +53,10 @@ public class JpaConnector implements ScoreStorageInterface {
 		motificator.accept(score);
 		em.getTransaction().commit();
 	}
+
+	
+	public List<Score> findBy(String partialName, Score.Difficult difficult){
+		return null;
+	}
 	
 }
diff --git a/src/main/java/lab/storage/ScoreStorageInterface.java b/src/main/java/lab/storage/ScoreStorageInterface.java
deleted file mode 100644
index af8932ec4fbdf9ba3fe85d9649f2131f02edf461..0000000000000000000000000000000000000000
--- a/src/main/java/lab/storage/ScoreStorageInterface.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package lab.storage;
-
-import java.util.List;
-
-import lab.data.Score;
-
-public interface ScoreStorageInterface {
-
-	List<Score> getAll();
-
-	List<Score> getFirstTen();
-
-	void init();
-
-	Score save(Score score);
-	
-	void delete(List<Score> scores);
-	
-	void stop();
-
-}
\ No newline at end of file
diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
index fb40c0131622735321624afd1208812cd2519922..60e43a3c1627a4b8c278839704d87e5bcd976798 100644
--- a/src/main/java/module-info.java
+++ b/src/main/java/module-info.java
@@ -1,16 +1,12 @@
-module cz.vsb.fei.java2.lab05_module {
-	requires transitive javafx.controls;
-	requires javafx.fxml;
-	requires javafx.base;
+module cz.vsb.fei.java2.lab06_module {
 	requires java.sql;
 	requires org.apache.logging.log4j;
 	requires static lombok;
 	requires jakarta.persistence;
 	requires com.h2database;
 	requires org.hibernate.orm.core;
+	requires jakarta.annotation;
 	
-	opens lab.gui to javafx.fxml;
 	opens lab.data;
 
-	exports lab.gui to javafx.fxml, javafx.graphics;
 }
\ No newline at end of file
diff --git a/src/main/resources/lab/game/fireball-transparent.gif b/src/main/resources/lab/game/fireball-transparent.gif
deleted file mode 100644
index ed734a665d6208de17057a378b4d4520126301b5..0000000000000000000000000000000000000000
Binary files a/src/main/resources/lab/game/fireball-transparent.gif and /dev/null differ
diff --git a/src/main/resources/lab/game/ufo-small.gif b/src/main/resources/lab/game/ufo-small.gif
deleted file mode 100644
index a1aca24e41f2d04912a45c703663c2b607f722dd..0000000000000000000000000000000000000000
Binary files a/src/main/resources/lab/game/ufo-small.gif and /dev/null differ
diff --git a/src/main/resources/lab/game/ufo.gif b/src/main/resources/lab/game/ufo.gif
deleted file mode 100644
index d07613c8999847572bffb44d7b161cffd874ca0f..0000000000000000000000000000000000000000
Binary files a/src/main/resources/lab/game/ufo.gif and /dev/null differ
diff --git a/src/main/resources/lab/gui/application.css b/src/main/resources/lab/gui/application.css
deleted file mode 100644
index 83d6f3343843c65d5dfaf3fedb97b6494c19113d..0000000000000000000000000000000000000000
--- a/src/main/resources/lab/gui/application.css
+++ /dev/null
@@ -1 +0,0 @@
-/* JavaFX CSS - Leave this comment until you have at least create one rule which uses -fx-Property */
\ No newline at end of file
diff --git a/src/main/resources/lab/gui/gameWindow.fxml b/src/main/resources/lab/gui/gameWindow.fxml
deleted file mode 100644
index 3aea4d029679126b804e8c47207d33d423d7f328..0000000000000000000000000000000000000000
--- a/src/main/resources/lab/gui/gameWindow.fxml
+++ /dev/null
@@ -1,75 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<?import javafx.geometry.Insets?>
-<?import javafx.scene.Cursor?>
-<?import javafx.scene.canvas.Canvas?>
-<?import javafx.scene.control.Button?>
-<?import javafx.scene.control.Label?>
-<?import javafx.scene.control.Slider?>
-<?import javafx.scene.control.TableColumn?>
-<?import javafx.scene.control.TableView?>
-<?import javafx.scene.layout.BorderPane?>
-<?import javafx.scene.layout.HBox?>
-<?import javafx.scene.layout.StackPane?>
-<?import javafx.scene.layout.VBox?>
-<?import javafx.scene.text.Font?>
-
-<BorderPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="388.0" prefWidth="911.0" xmlns="http://javafx.com/javafx/21" xmlns:fx="http://javafx.com/fxml/1" fx:controller="lab.gui.GameController">
-   <bottom>
-      <VBox BorderPane.alignment="CENTER">
-         <children>
-            <Label fx:id="hits" maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" text="Hits count: 0" VBox.vgrow="ALWAYS" />
-            <HBox alignment="TOP_CENTER" prefHeight="66.0" prefWidth="866.0">
-               <children>
-                  <Slider fx:id="angle" majorTickUnit="15.0" max="90.0" maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" minorTickCount="5" showTickLabels="true" showTickMarks="true" HBox.hgrow="ALWAYS" />
-                  <Button mnemonicParsing="false" onAction="#fire" style="-fx-background-color: RED;" text="Fire" textAlignment="CENTER">
-                     <font>
-                        <Font name="System Bold" size="24.0" />
-                     </font>
-                     <cursor>
-                        <Cursor fx:constant="CROSSHAIR" />
-                     </cursor>
-                     <opaqueInsets>
-                        <Insets bottom="10.0" left="10.0" right="10.0" top="10.0" />
-                     </opaqueInsets>
-                     <HBox.margin>
-                        <Insets bottom="5.0" left="5.0" right="5.0" top="5.0" />
-                     </HBox.margin>
-                  </Button>
-                  <Slider fx:id="speed" max="200.0" maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" min="50.0" minorTickCount="5" showTickLabels="true" showTickMarks="true" value="50.0" HBox.hgrow="ALWAYS" />
-               </children>
-            </HBox>
-         </children>
-      </VBox>
-   </bottom>
-   <left>
-      <StackPane style="-fx-border-image-width: 3px; -fx-border-style: SOLID;" BorderPane.alignment="CENTER">
-         <BorderPane.margin>
-            <Insets />
-         </BorderPane.margin>
-         <children>
-            <Canvas fx:id="canvas" focusTraversable="true" height="306.0" onKeyPressed="#keyPressed" onKeyReleased="#keyReleased" onMouseClicked="#canvasClicked" style="-fx-border-width: 3px; -fx-border-style: SOLID; -fx-border-color: RGB(100.0,0.0,0.0);" width="582.0" StackPane.alignment="TOP_LEFT" />
-         </children>
-      </StackPane>
-   </left>
-   <center>
-      <VBox maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" BorderPane.alignment="CENTER">
-         <children>
-            <TableView fx:id="scores" maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" prefHeight="2000.0">
-              <columns>
-                <TableColumn fx:id="nickColumn" prefWidth="75.0" text="Nick" />
-                <TableColumn fx:id="pointsColumn" prefWidth="75.0" text="Points" />
-                  <TableColumn fx:id="levelColumn" prefWidth="75.0" text="Úroveň" />
-              </columns>
-               <columnResizePolicy>
-                  <TableView fx:constant="CONSTRAINED_RESIZE_POLICY" />
-               </columnResizePolicy>
-            </TableView>
-            <Button fx:id="btnGenerateScore" maxWidth="1.7976931348623157E308" mnemonicParsing="false" onAction="#btnGenerateScoreAction" text="Generate new score" />
-            <Button fx:id="btnLoadAll" maxWidth="1.7976931348623157E308" mnemonicParsing="false" onAction="#btnLoadAllAction" text="Load all from DB" />
-            <Button fx:id="btnLoadFirstTen" maxWidth="1.7976931348623157E308" mnemonicParsing="false" onAction="#btnLoadFirstTenAction" text="Load First 10 from DB" />
-            <Button fx:id="btnDelete" maxWidth="1.7976931348623157E308" mnemonicParsing="false" onAction="#btnDeleteAction" text="Delete score" />
-         </children>
-      </VBox>
-   </center>
-</BorderPane>
diff --git a/src/test/java/jez04/structure/test/ClassStructureTest.java b/src/test/java/jez04/structure/test/ClassStructureTest.java
index 21c3023a1e362b7c8191843eee2cbda6fabde061..b850b1e322800e90cb08cb103b3bf1432cd3000b 100644
--- a/src/test/java/jez04/structure/test/ClassStructureTest.java
+++ b/src/test/java/jez04/structure/test/ClassStructureTest.java
@@ -2,32 +2,17 @@ package jez04.structure.test;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
 import java.net.URISyntaxException;
-import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.List;
-import java.util.Objects;
-import java.util.regex.Pattern;
 
 import org.hamcrest.Matchers;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
-import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.TestMethodOrder;
 
 import cz.vsb.fei.kelvin.unittest.ProjectContains;
 import cz.vsb.fei.kelvin.unittest.StructureHelper;
 import cz.vsb.fei.kelvin.unittest.TextFileContains;
 import cz.vsb.fei.kelvin.unittest.XmlFileContains;
-import lab.data.Level;
-import lab.data.Score;
-import lab.storage.JpaConnector;
 
 class ClassStructureTest {
 
@@ -65,113 +50,4 @@ class ClassStructureTest {
 				new TextFileContains("Score.java", "@Enumerated\\(\\s*EnumType.STRING\\s*\\)"));
 	}
 
-	@TestMethodOrder(OrderAnnotation.class)
-	@Nested
-	class JpaConnectorTests {
-
-		private Score template = new Score(null, "Tester", 100, Level.EASY);
-		private JpaConnector connector;
-
-		@BeforeEach
-		void init() {
-			connector = new JpaConnector();
-		}
-
-		@AfterEach
-		void cleanUp() {
-			connector.stop();
-		}
-
-		boolean same(Score s1, Score s2) {
-			return s1.getLevel() == s2.getLevel() && s1.getPoints() == s2.getPoints()
-					&& Objects.equals(s1.getName(), s2.getName());
-		}
-
-		@Test
-		@Order(100)
-		void jpaScoreInsertTest() {
-			Score savedScore = connector.save(template);
-			assertThat(savedScore.getId(), Matchers.notNullValue());
-		}
-
-		@Test
-		@Order(200)
-		void jpaScoreReadTest() {
-			List<Score> savedScores = connector.getAll().stream().filter(s -> same(s, template)).toList();
-			assertThat(savedScores, Matchers.not(Matchers.hasSize(0)));
-		}
-
-		@Test
-		@Order(250)
-		void jpaReadSortedTest() {
-			for (int i = 0; i < 20; i++) {
-				connector.save(template.toBuilder().points(i).build());
-			}
-			List<Score> result = connector.getFirstTen();
-			assertThat(result, Matchers.hasSize(10));
-			for (int i = 0; i < result.size()-1; i++) {
-				assertThat(result.get(i).getPoints(), Matchers.greaterThanOrEqualTo(result.get(i+1).getPoints()));
-			}
-		}
-
-		@Test
-		@Order(300)
-		void jpaScoreModifyTest() {
-			List<Score> savedScores = connector.getAll().stream().filter(s -> same(s, template)).toList();
-			List<Long> savedIds = savedScores.stream().map(Score::getId).toList();
-			assertThat(savedScores, Matchers.not(Matchers.hasSize(0)));
-			for (Score score : savedScores) {
-				score.setLevel(Level.HARD);
-				connector.save(score);
-			}
-			List<Score> modifiedScores = connector.getAll().stream().filter(s -> savedIds.contains(s.getId())).toList();
-			assertThat(modifiedScores, Matchers.not(Matchers.hasSize(0)));
-			List<Score> originalDataScores = connector.getAll().stream().filter(s -> same(s, template)).toList();
-			assertThat(originalDataScores, Matchers.hasSize(0));
-		}
-
-		@Test
-		@Order(400)
-		void jpaScoreDeleteTest() {
-			template.setLevel(Level.HARD);
-			List<Score> savedScores = connector.getAll().stream().filter(s -> same(s, template)).toList();
-			List<Long> savedIds = savedScores.stream().map(Score::getId).toList();
-			assertThat(savedScores, Matchers.not(Matchers.hasSize(0)));
-			connector.delete(savedScores);
-			List<Score> modifiedScores = connector.getAll().stream().filter(s -> savedIds.contains(s.getId())).toList();
-			assertThat(modifiedScores, Matchers.hasSize(0));
-			List<Score> originalDataScores = connector.getAll().stream().filter(s -> same(s, template)).toList();
-			assertThat(originalDataScores, Matchers.hasSize(0));
-		}
-
-		@Test
-		@Order(400)
-		void jpaMergeTest() {
-			connector.save(template);
-			connector.find(template.getId());
-			Score copy = template.toBuilder().points(500).build();
-			Score result = connector.save(copy);
-			assertThat(result, Matchers.not(Matchers.sameInstance(copy)));
-		}
-
-		@Test
-		@Order(500)
-		void jpamodifyNoPersistNoMergeTest() throws URISyntaxException, IOException, IllegalAccessException, InvocationTargetException, NoSuchMethodException, SecurityException {
-			template.setName("aaa");
-			connector.save(template);
-			connector.modifyNoPersistOrMerge(template.getId(), score -> score.setName("ok"));
-			Object em = connector.getEntityManager();
-			em.getClass().getMethod("clear").invoke(em);
-			
-			assertThat(connector.find(template.getId()).getName(), Matchers.equalTo("ok"));
-			TextFileContains textFileContains = new TextFileContains("JpaConnector.java",
-					"void\\s+modifyNoPersistOrMerge[\\s\\S]*}").multiline(true);
-			assertThat(TextFileContains.getProjectRoot(ClassStructureTest.class), textFileContains);
-			Path score = textFileContains.getFoundFiles().getFirst();
-			String src = Files.readString(score);
-			String method = Pattern.compile("void\\s+modifyNoPersistOrMerge[\\s\\S]*}").matcher(src).results().findFirst().get().group();
-			assertThat(method, Matchers.not(Matchers.containsString("persist")));
-			assertThat(method, Matchers.not(Matchers.containsString("merge")));
-		}
-	}
 }