.gitignore

@@ -1,25 +0,0 @@
-# ---> Java
-*.class
-
-# Mobile Tools for Java (J2ME)
-.mtj.tmp/
-
-# Package Files #
-*.jar
-*.war
-*.ear
-
-# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
-hs_err_pid*
-
-# ---> Maven
-target/
-pom.xml.tag
-pom.xml.releaseBackup
-pom.xml.versionsBackup
-pom.xml.next
-release.properties
-dependency-reduced-pom.xml
-buildNumber.properties
-.mvn/timing.properties
-

LICENSE

@@ -1,8 +0,0 @@
-MIT License
-Copyright (c) <year> <copyright holders>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,3 +0,0 @@
-# JavaAdventureRepo
-
-Code for Java text adventure. Have fun

dependency-reduced-pom.xml

@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 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.davza</groupId>
+  <artifactId>StudentAdventure</artifactId>
+  <name>StudentAdventure</name>
+  <version>1.1.0</version>
+  <build>
+    <testSourceDirectory>${project.basedir}/test</testSourceDirectory>
+    <plugins>
+      <plugin>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.13.0</version>
+        <configuration>
+          <source>21</source>
+          <target>21</target>
+        </configuration>
+      </plugin>
+      <plugin>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>3.6.0</version>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+            <configuration>
+              <transformers>
+                <transformer>
+                  <mainClass>cz.davza.studentadventure.main.Main</mainClass>
+                </transformer>
+              </transformers>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+  <dependencies>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-api</artifactId>
+      <version>5.12.1</version>
+      <scope>test</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>opentest4j</artifactId>
+          <groupId>org.opentest4j</groupId>
+        </exclusion>
+        <exclusion>
+          <artifactId>junit-platform-commons</artifactId>
+          <groupId>org.junit.platform</groupId>
+        </exclusion>
+        <exclusion>
+          <artifactId>apiguardian-api</artifactId>
+          <groupId>org.apiguardian</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-engine</artifactId>
+      <version>5.12.1</version>
+      <scope>test</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>junit-platform-engine</artifactId>
+          <groupId>org.junit.platform</groupId>
+        </exclusion>
+        <exclusion>
+          <artifactId>apiguardian-api</artifactId>
+          <groupId>org.apiguardian</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+  </dependencies>
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <junit.version>5.12.1</junit.version>
+  </properties>
+</project>

mvnw

@@ -0,0 +1,316 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Maven Start Up Batch script
+#
+# Required ENV vars:
+# ------------------
+#   JAVA_HOME - location of a JDK home dir
+#
+# Optional ENV vars
+# -----------------
+#   M2_HOME - location of maven2's installed home dir
+#   MAVEN_OPTS - parameters passed to the Java VM when running Maven
+#     e.g. to debug Maven itself, use
+#       set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+#   MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+# ----------------------------------------------------------------------------
+
+if [ -z "$MAVEN_SKIP_RC" ] ; then
+
+  if [ -f /usr/local/etc/mavenrc ] ; then
+    . /usr/local/etc/mavenrc
+  fi
+
+  if [ -f /etc/mavenrc ] ; then
+    . /etc/mavenrc
+  fi
+
+  if [ -f "$HOME/.mavenrc" ] ; then
+    . "$HOME/.mavenrc"
+  fi
+
+fi
+
+# OS specific support.  $var _must_ be set to either true or false.
+cygwin=false;
+darwin=false;
+mingw=false
+case "`uname`" in
+  CYGWIN*) cygwin=true ;;
+  MINGW*) mingw=true;;
+  Darwin*) darwin=true
+    # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
+    # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
+    if [ -z "$JAVA_HOME" ]; then
+      if [ -x "/usr/libexec/java_home" ]; then
+        export JAVA_HOME="`/usr/libexec/java_home`"
+      else
+        export JAVA_HOME="/Library/Java/Home"
+      fi
+    fi
+    ;;
+esac
+
+if [ -z "$JAVA_HOME" ] ; then
+  if [ -r /etc/gentoo-release ] ; then
+    JAVA_HOME=`java-config --jre-home`
+  fi
+fi
+
+if [ -z "$M2_HOME" ] ; then
+  ## resolve links - $0 may be a link to maven's home
+  PRG="$0"
+
+  # need this for relative symlinks
+  while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+      PRG="$link"
+    else
+      PRG="`dirname "$PRG"`/$link"
+    fi
+  done
+
+  saveddir=`pwd`
+
+  M2_HOME=`dirname "$PRG"`/..
+
+  # make it fully qualified
+  M2_HOME=`cd "$M2_HOME" && pwd`
+
+  cd "$saveddir"
+  # echo Using m2 at $M2_HOME
+fi
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched
+if $cygwin ; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME=`cygpath --unix "$M2_HOME"`
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+  [ -n "$CLASSPATH" ] &&
+    CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
+fi
+
+# For Mingw, ensure paths are in UNIX format before anything is touched
+if $mingw ; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME="`(cd "$M2_HOME"; pwd)`"
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
+fi
+
+if [ -z "$JAVA_HOME" ]; then
+  javaExecutable="`which javac`"
+  if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
+    # readlink(1) is not available as standard on Solaris 10.
+    readLink=`which readlink`
+    if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
+      if $darwin ; then
+        javaHome="`dirname \"$javaExecutable\"`"
+        javaExecutable="`cd \"$javaHome\" && pwd -P`/javac"
+      else
+        javaExecutable="`readlink -f \"$javaExecutable\"`"
+      fi
+      javaHome="`dirname \"$javaExecutable\"`"
+      javaHome=`expr "$javaHome" : '\(.*\)/bin'`
+      JAVA_HOME="$javaHome"
+      export JAVA_HOME
+    fi
+  fi
+fi
+
+if [ -z "$JAVACMD" ] ; then
+  if [ -n "$JAVA_HOME"  ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+    fi
+  else
+    JAVACMD="`\\unset -f command; \\command -v java`"
+  fi
+fi
+
+if [ ! -x "$JAVACMD" ] ; then
+  echo "Error: JAVA_HOME is not defined correctly." >&2
+  echo "  We cannot execute $JAVACMD" >&2
+  exit 1
+fi
+
+if [ -z "$JAVA_HOME" ] ; then
+  echo "Warning: JAVA_HOME environment variable is not set."
+fi
+
+CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher
+
+# traverses directory structure from process work directory to filesystem root
+# first directory with .mvn subdirectory is considered project base directory
+find_maven_basedir() {
+
+  if [ -z "$1" ]
+  then
+    echo "Path not specified to find_maven_basedir"
+    return 1
+  fi
+
+  basedir="$1"
+  wdir="$1"
+  while [ "$wdir" != '/' ] ; do
+    if [ -d "$wdir"/.mvn ] ; then
+      basedir=$wdir
+      break
+    fi
+    # workaround for JBEAP-8937 (on Solaris 10/Sparc)
+    if [ -d "${wdir}" ]; then
+      wdir=`cd "$wdir/.."; pwd`
+    fi
+    # end of workaround
+  done
+  echo "${basedir}"
+}
+
+# concatenates all lines of a file
+concat_lines() {
+  if [ -f "$1" ]; then
+    echo "$(tr -s '\n' ' ' < "$1")"
+  fi
+}
+
+BASE_DIR=`find_maven_basedir "$(pwd)"`
+if [ -z "$BASE_DIR" ]; then
+  exit 1;
+fi
+
+##########################################################################################
+# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+# This allows using the maven wrapper in projects that prohibit checking in binary data.
+##########################################################################################
+if [ -r "$BASE_DIR/.mvn/wrapper/maven-wrapper.jar" ]; then
+    if [ "$MVNW_VERBOSE" = true ]; then
+      echo "Found .mvn/wrapper/maven-wrapper.jar"
+    fi
+else
+    if [ "$MVNW_VERBOSE" = true ]; then
+      echo "Couldn't find .mvn/wrapper/maven-wrapper.jar, downloading it ..."
+    fi
+    if [ -n "$MVNW_REPOURL" ]; then
+      jarUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+    else
+      jarUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+    fi
+    while IFS="=" read key value; do
+      case "$key" in (wrapperUrl) jarUrl="$value"; break ;;
+      esac
+    done < "$BASE_DIR/.mvn/wrapper/maven-wrapper.properties"
+    if [ "$MVNW_VERBOSE" = true ]; then
+      echo "Downloading from: $jarUrl"
+    fi
+    wrapperJarPath="$BASE_DIR/.mvn/wrapper/maven-wrapper.jar"
+    if $cygwin; then
+      wrapperJarPath=`cygpath --path --windows "$wrapperJarPath"`
+    fi
+
+    if command -v wget > /dev/null; then
+        if [ "$MVNW_VERBOSE" = true ]; then
+          echo "Found wget ... using wget"
+        fi
+        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+            wget "$jarUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+        else
+            wget --http-user=$MVNW_USERNAME --http-password=$MVNW_PASSWORD "$jarUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+        fi
+    elif command -v curl > /dev/null; then
+        if [ "$MVNW_VERBOSE" = true ]; then
+          echo "Found curl ... using curl"
+        fi
+        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+            curl -o "$wrapperJarPath" "$jarUrl" -f
+        else
+            curl --user $MVNW_USERNAME:$MVNW_PASSWORD -o "$wrapperJarPath" "$jarUrl" -f
+        fi
+
+    else
+        if [ "$MVNW_VERBOSE" = true ]; then
+          echo "Falling back to using Java to download"
+        fi
+        javaClass="$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.java"
+        # For Cygwin, switch paths to Windows format before running javac
+        if $cygwin; then
+          javaClass=`cygpath --path --windows "$javaClass"`
+        fi
+        if [ -e "$javaClass" ]; then
+            if [ ! -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
+                if [ "$MVNW_VERBOSE" = true ]; then
+                  echo " - Compiling MavenWrapperDownloader.java ..."
+                fi
+                # Compiling the Java class
+                ("$JAVA_HOME/bin/javac" "$javaClass")
+            fi
+            if [ -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
+                # Running the downloader
+                if [ "$MVNW_VERBOSE" = true ]; then
+                  echo " - Running MavenWrapperDownloader.java ..."
+                fi
+                ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$MAVEN_PROJECTBASEDIR")
+            fi
+        fi
+    fi
+fi
+##########################################################################################
+# End of extension
+##########################################################################################
+
+export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
+if [ "$MVNW_VERBOSE" = true ]; then
+  echo $MAVEN_PROJECTBASEDIR
+fi
+MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME=`cygpath --path --windows "$M2_HOME"`
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
+  [ -n "$CLASSPATH" ] &&
+    CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
+  [ -n "$MAVEN_PROJECTBASEDIR" ] &&
+    MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"`
+fi
+
+# Provide a "standardized" way to retrieve the CLI args that will
+# work with both Windows and non-Windows executions.
+MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $@"
+export MAVEN_CMD_LINE_ARGS
+
+WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+exec "$JAVACMD" \
+  $MAVEN_OPTS \
+  $MAVEN_DEBUG_OPTS \
+  -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
+  "-Dmaven.home=${M2_HOME}" \
+  "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
+  ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"

mvnw.cmd

@@ -0,0 +1,188 @@
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    https://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Maven Start Up Batch script
+@REM
+@REM Required ENV vars:
+@REM JAVA_HOME - location of a JDK home dir
+@REM
+@REM Optional ENV vars
+@REM M2_HOME - location of maven2's installed home dir
+@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
+@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
+@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
+@REM     e.g. to debug Maven itself, use
+@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+@REM ----------------------------------------------------------------------------
+
+@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
+@echo off
+@REM set title of command window
+title %0
+@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
+@if "%MAVEN_BATCH_ECHO%" == "on"  echo %MAVEN_BATCH_ECHO%
+
+@REM set %HOME% to equivalent of $HOME
+if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
+
+@REM Execute a user defined script before this one
+if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
+@REM check for pre script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %*
+if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %*
+:skipRcPre
+
+@setlocal
+
+set ERROR_CODE=0
+
+@REM To isolate internal variables from possible post scripts, we use another setlocal
+@setlocal
+
+@REM ==== START VALIDATION ====
+if not "%JAVA_HOME%" == "" goto OkJHome
+
+echo.
+echo Error: JAVA_HOME not found in your environment. >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+:OkJHome
+if exist "%JAVA_HOME%\bin\java.exe" goto init
+
+echo.
+echo Error: JAVA_HOME is set to an invalid directory. >&2
+echo JAVA_HOME = "%JAVA_HOME%" >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+@REM ==== END VALIDATION ====
+
+:init
+
+@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
+@REM Fallback to current working directory if not found.
+
+set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
+IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
+
+set EXEC_DIR=%CD%
+set WDIR=%EXEC_DIR%
+:findBaseDir
+IF EXIST "%WDIR%"\.mvn goto baseDirFound
+cd ..
+IF "%WDIR%"=="%CD%" goto baseDirNotFound
+set WDIR=%CD%
+goto findBaseDir
+
+:baseDirFound
+set MAVEN_PROJECTBASEDIR=%WDIR%
+cd "%EXEC_DIR%"
+goto endDetectBaseDir
+
+:baseDirNotFound
+set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
+cd "%EXEC_DIR%"
+
+:endDetectBaseDir
+
+IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
+
+@setlocal EnableExtensions EnableDelayedExpansion
+for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
+@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
+
+:endReadAdditionalConfig
+
+SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
+set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
+set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+set DOWNLOAD_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+
+FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
+    IF "%%A"=="wrapperUrl" SET DOWNLOAD_URL=%%B
+)
+
+@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
+if exist %WRAPPER_JAR% (
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Found %WRAPPER_JAR%
+    )
+) else (
+    if not "%MVNW_REPOURL%" == "" (
+        SET DOWNLOAD_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+    )
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Couldn't find %WRAPPER_JAR%, downloading it ...
+        echo Downloading from: %DOWNLOAD_URL%
+    )
+
+    powershell -Command "&{"^
+		"$webclient = new-object System.Net.WebClient;"^
+		"if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
+		"$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
+		"}"^
+		"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%DOWNLOAD_URL%', '%WRAPPER_JAR%')"^
+		"}"
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Finished downloading %WRAPPER_JAR%
+    )
+)
+@REM End of extension
+
+@REM Provide a "standardized" way to retrieve the CLI args that will
+@REM work with both Windows and non-Windows executions.
+set MAVEN_CMD_LINE_ARGS=%*
+
+%MAVEN_JAVA_EXE% ^
+  %JVM_CONFIG_MAVEN_PROPS% ^
+  %MAVEN_OPTS% ^
+  %MAVEN_DEBUG_OPTS% ^
+  -classpath %WRAPPER_JAR% ^
+  "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^
+  %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
+if ERRORLEVEL 1 goto error
+goto end
+
+:error
+set ERROR_CODE=1
+
+:end
+@endlocal & set ERROR_CODE=%ERROR_CODE%
+
+if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost
+@REM check for post script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat"
+if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd"
+:skipRcPost
+
+@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
+if "%MAVEN_BATCH_PAUSE%"=="on" pause
+
+if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE%
+
+cmd /C exit /B %ERROR_CODE%

pom.xml

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>cz.davza</groupId>
+    <artifactId>StudentAdventure</artifactId>
+    <version>1.1.0</version>
+    <name>StudentAdventure</name>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <junit.version>5.12.1</junit.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.reflections</groupId>
+            <artifactId>reflections</artifactId>
+            <version>0.10.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>2.0.12</version>
+<!--            <scope>test</scope>-->
+        </dependency>
+<!--        Adding the api package to rewrite what reflections package uses and upgrade to newest version-->
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>2.0.12</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <testSourceDirectory>${project.basedir}/test</testSourceDirectory>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.13.0</version>
+                <configuration>
+                    <source>21</source>
+                    <target>21</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.6.0</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <transformers>
+                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                                    <mainClass>cz.davza.studentadventure.main.Main</mainClass>
+                                </transformer>
+                            </transformers>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

src/main/java/cz/davza/studentadventure/Items/Bed.java

@@ -0,0 +1,31 @@
+package cz.davza.studentadventure.Items;
+
+import cz.davza.studentadventure.base.ItemBase;
+import cz.davza.studentadventure.commands.SleepCommand;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.interfaces.IInteractable;
+/**
+ * An interactable bed in the player's bedroom.
+ *
+ * <p>Interacting with the bed is equivalent to using the {@code sleep} command
+ * and will fully restore the player's stats and advance time to the next morning.</p>
+ *
+ * @see cz.davza.studentadventure.commands.SleepCommand
+ */
+public class Bed extends ItemBase implements IInteractable {
+    /** Creates a new Bed instance. */
+    public Bed() {
+        super("Bed", "A single bed with crumpled sheets. Very inviting.", "bed", 1);
+    }
+    /**
+     * {@inheritDoc}
+     * Delegates directly to {@link SleepCommand#Execute(GameData)}.
+     */
+    @Override
+    public CommandResult Interact(GameData context) {
+
+        return new SleepCommand().Execute(context);
+
+    }
+}

src/main/java/cz/davza/studentadventure/Items/Book.java

@@ -0,0 +1,19 @@
+package cz.davza.studentadventure.Items;
+
+import cz.davza.studentadventure.base.ItemBase;
+import cz.davza.studentadventure.interfaces.ICollectable;
+/**
+ * A programming textbook that can be picked up and carried by the player.
+ *
+ * <p>Required to enter the {@link cz.davza.studentadventure.rooms.ClassroomRoom}.
+ * Stacks up to 4 per inventory slot.</p>
+ *
+ * @see cz.davza.studentadventure.rooms.ClassroomRoom#onEnter
+ */
+public class Book extends ItemBase implements ICollectable {
+    /** Creates a new Book instance. */
+    public Book() {
+        super("Book", "A hefty programming textbook.", "book", 3);
+    }
+
+}

src/main/java/cz/davza/studentadventure/Items/Computer.java

@@ -0,0 +1,116 @@
+package cz.davza.studentadventure.Items;
+
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.base.ItemBase;
+import cz.davza.studentadventure.interfaces.ICommandable;
+import cz.davza.studentadventure.interfaces.IInteractable;
+import cz.davza.studentadventure.managers.CommandManager;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+
+import java.util.List;
+/**
+ * A password-protected university workstation that hosts its own sub-command loop.
+ *
+ * <p>Interacting with the computer for the first time triggers a password prompt.
+ * Once the correct password is entered the computer remains unlocked for the rest
+ * of the session. Inside the active session the player can:</p>
+ * <ul>
+ *   <li>{@code study <hours>} — study using the computer.</li>
+ *   <li>{@code studentid} — look up their student ID.</li>
+ *   <li>{@code exit} — step away and return to normal room commands.</li>
+ * </ul>
+ *
+ * <p>The computer implements {@link ICommandable} so the game loop can route
+ * subsequent player input directly to {@link #handleCommand} until the player
+ * types {@code exit}.</p>
+ *
+ * @see cz.davza.studentadventure.rooms.ComputerLabRoom
+ * @see IInteractable
+ * @see ICommandable
+ */
+public class Computer extends ItemBase implements IInteractable, ICommandable {
+
+    private enum ComputerState { PASSWORD, ACTIVE }
+    private ComputerState computerState = ComputerState.PASSWORD;
+    private final List<String> allowedCommands = List.of("study", "exit", "studentid");
+    private final String password;
+    /**
+     * Creates a computer locked with the given password.
+     *
+     * @param password the password the player must enter to unlock the workstation
+     */
+    public Computer(String password) {
+        super("Computer", "A university workstation.", "computer", 1);
+        this.password = password;
+    }
+    /**
+     * {@inheritDoc}
+     *
+     * <p>If the computer is locked, returns an {@link CommandResult#actionPending} result
+     * with a password prompt. If already unlocked, returns an {@code actionPending}
+     * result with a welcome message, routing further input to this computer.</p>
+     */
+    @Override
+    public CommandResult Interact(GameData context) {
+        if (computerState == ComputerState.PASSWORD) {
+            return CommandResult.actionPending(this, "The computer is locked.\nEnter password (or 'exit' to walk away):");
+        }
+        computerState = ComputerState.ACTIVE;
+        return CommandResult.actionPending(this, "You sit down at the computer. (write 'exit' to walk away)");
+    }
+    /**
+     * {@inheritDoc}
+     *
+     * <p>Routes input to either the password handler or the active session handler
+     * depending on the current {@link ComputerState}.</p>
+     */
+    @Override
+    public CommandResult handleCommand(String input, GameData context) {
+        return switch (computerState) {
+            case PASSWORD -> handlePassword(input);
+            case ACTIVE -> handleActive(input, context);
+        };
+    }
+    /**
+     * Handles input while the computer is in the password-prompt state.
+     *
+     * <p>Typing {@code exit} cancels and returns control to the room.
+     * The correct password unlocks the computer and transitions to the active state.
+     * Any other input returns a failure with a retry prompt.</p>
+     *
+     * @param input the raw input string from the player
+     * @return the result of the password attempt
+     */
+    private CommandResult handlePassword(String input) {
+        if (input.equalsIgnoreCase("exit")) {
+            return CommandResult.actionResumed("You step away from the computer.");
+        }
+        if (input.equals(password)) {
+            computerState = ComputerState.ACTIVE;
+            return CommandResult.success("Password accepted. The computer unlocks.\nYou sit down at the computer. (write 'exit' to walk away)");
+        }
+        return CommandResult.failed("Incorrect password. Try again.");
+    }
+    /**
+     * Handles input while the computer is unlocked and in use.
+     *
+     * <p>Typing {@code exit} ends the session and returns control to the room.
+     * Other input is parsed against the computer's restricted command list
+     * ({@code study}, {@code studentid}). Unrecognised commands return a failure.</p>
+     *
+     * @param input   the raw input string from the player
+     * @param context the current game state passed to commands that need it
+     * @return the result of the command or a failure if the input is unrecognised
+     */
+    private CommandResult handleActive(String input, GameData context) {
+        if (input.equalsIgnoreCase("exit")) {
+            return CommandResult.actionResumed("You step away from the computer.");
+        }
+        CommandBase command = CommandManager.parseCommand(input, allowedCommands);
+        if (command == null) {
+            return CommandResult.failed("You can't do that here.");
+        }
+        return command.Execute(context);
+    }
+}

src/main/java/cz/davza/studentadventure/Items/EnergyDrink.java

@@ -0,0 +1,35 @@
+package cz.davza.studentadventure.Items;
+
+import cz.davza.studentadventure.base.ItemBase;
+import cz.davza.studentadventure.interfaces.IConsumable;
+import cz.davza.studentadventure.objects.Player;
+/**
+ * A canned energy drink sold at the campus shop.
+ *
+ * <p>Consuming one restores {@value #ENERGY_RESTORE} energy to the player.
+ * Costs {@value #COST} coins and stacks up to 5 per inventory slot.</p>
+ *
+ * @see cz.davza.studentadventure.commands.BuyCommand
+ * @see cz.davza.studentadventure.commands.ConsumeCommand
+ */
+public class EnergyDrink extends ItemBase implements IConsumable {
+    /** The purchase price of one energy drink in coins. */
+    public static final int COST           = 20;
+    /** The amount of energy restored when consumed. */
+    public static final int ENERGY_RESTORE = 40;
+    /** Creates a new EnergyDrink instance. */
+    public EnergyDrink() {
+        super("Energy Drink", "A cold can of something that smells like chemicals.",
+                "energy_drink", 2);
+    }
+    /** {@inheritDoc} Restores {@value #ENERGY_RESTORE} energy. */
+    @Override
+    public void consume(Player player) {
+        player.getEnergy().increase(ENERGY_RESTORE);
+    }
+    /** {@inheritDoc} */
+    @Override
+    public String getConsumeMessage() {
+        return "You crack open the energy drink and skull it. Energy +" + ENERGY_RESTORE + ".";
+    }
+}

src/main/java/cz/davza/studentadventure/Items/Money.java

@@ -0,0 +1,51 @@
+package cz.davza.studentadventure.Items;
+
+import cz.davza.studentadventure.base.ItemBase;
+import cz.davza.studentadventure.interfaces.ICollectable;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+/**
+ * Loose coins found on the ground.
+ *
+ * <p>Unlike most collectables, picking up {@code Money} does not add it to the
+ * inventory. Instead, {@link #onPickup} directly adds the coin value to the player's
+ * balance and prints a confirmation message.</p>
+ *
+ * <p>Can be constructed with a fixed amount or a random amount within a range.</p>
+ */
+public class Money extends ItemBase implements ICollectable {
+    private final int amount;
+
+    /**
+     * Creates a money item with a fixed coin value.
+     *
+     * @param amount the exact number of coins this item represents
+     */
+    public Money(int amount) {
+        super("Money", amount + " coins on the ground.", "money", 1);
+        this.amount = amount;
+    }
+
+    /**
+     * Creates a money item with a randomly determined coin value within the given range.
+     *
+     * @param min the minimum number of coins (inclusive)
+     * @param max the maximum number of coins (inclusive)
+     */
+    public Money(int min, int max) {
+        super("Money", "Some loose change on the ground.", "money", 1);
+        this.amount = min + (int)(Math.random() * (max - min + 1));
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>Overridden to add coins directly to the player's balance rather than
+     * occupying an inventory slot. Always returns {@code 0} (never fails).</p>
+     */
+    @Override
+    public CommandResult onPickup(GameData context, int amount){
+        context.getPlayer().getWallet().earnMoney(this.amount);
+        return CommandResult.success("Picked up " + this.amount + " " + this.getCode() + ".\n");
+    }
+}

src/main/java/cz/davza/studentadventure/Items/MouldyCheese.java

@@ -0,0 +1,33 @@
+package cz.davza.studentadventure.Items;
+
+import cz.davza.studentadventure.base.ItemBase;
+import cz.davza.studentadventure.interfaces.IConsumable;
+import cz.davza.studentadventure.objects.Player;
+/**
+ * A forgotten block of mouldy cheese.
+ *
+ * <p>Consuming it is inadvisable — it drains {@value #ENERGY_COST} energy from
+ * the player. Stacks up to 5 per slot.</p>
+ */
+public class MouldyCheese extends ItemBase implements IConsumable {
+    public static final int COST           = 20;
+    /** The energy cost inflicted on the player when consumed. */
+    public static final int ENERGY_COST = 15;
+    /** Creates a new MouldyCheese instance. */
+    public MouldyCheese() {
+        super("Mouldy Cheese", "A block of mouldy cheese someone forgot to stick in the fridge.",
+                "mouldy_cheese", 5);
+    }
+    /** {@inheritDoc} Drains {@value #ENERGY_COST} energy. */
+
+    @Override
+    public void consume(Player player) {
+        player.getEnergy().decrease(ENERGY_COST);
+    }
+    /** {@inheritDoc} */
+
+    @Override
+    public String getConsumeMessage() {
+        return "You bite into the block of cheese and start feeling unwell. Energy -" + ENERGY_COST + ".";
+    }
+}

src/main/java/cz/davza/studentadventure/Items/StickyNote.java

@@ -0,0 +1,34 @@
+package cz.davza.studentadventure.Items;
+
+import cz.davza.studentadventure.base.ItemBase;
+import cz.davza.studentadventure.interfaces.IInteractable;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+/**
+ * A sticky note left in a room, containing a readable message.
+ *
+ * <p>Interacting with the note prints its contents. Notes are not collectable
+ * and stay in the room permanently. Max stack of 1 (each note is unique).</p>
+ *
+ * <p>Used throughout the world to hint at passwords, lore, and jokes.</p>
+ */
+public class StickyNote extends ItemBase implements IInteractable {
+    private final String note;
+    /**
+     * Creates a sticky note with the given message text.
+     *
+     * @param note the text written on the note
+     */
+    public StickyNote(String note) {
+        super("Sticky Note", "A sticky note with scribbled text. You may be able to just read it", "sticky_note", 1);
+        this.note = note;
+    }
+    /**
+     * {@inheritDoc}
+     * Prints the note's message to {@code System.out}.
+     */
+    @Override
+    public CommandResult Interact(GameData context) {
+        return CommandResult.success("You lean in to read the note. \n It reads: \n " + note + "\n");
+    }
+}

src/main/java/cz/davza/studentadventure/annotations/CommandKeyword.java

@@ -0,0 +1,34 @@
+package cz.davza.studentadventure.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+/**
+ * Marks a class as a player command and associates it with a keyword string.
+ *
+ * <p>The {@link cz.davza.studentadventure.managers.CommandFactory} scans for all classes
+ * annotated with {@code @CommandKeyword} at runtime and registers them in its
+ * command registry. When a player types the matching keyword, the annotated class
+ * is instantiated and executed.</p>
+ *
+ * <p>Usage example:</p>
+ * <pre>{@code
+ * @CommandKeyword("walk")
+ * public class WalkCommand extends CommandBase { ... }
+ * }</pre>
+ *
+ * @see cz.davza.studentadventure.managers.CommandFactory
+ * @see cz.davza.studentadventure.base.CommandBase
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface CommandKeyword {
+    /**
+     * The keyword the player must type to trigger this command.
+     * This is matched case-insensitively by the {@link cz.davza.studentadventure.managers.CommandManager}.
+     *
+     * @return the command keyword string (e.g. {@code "walk"}, {@code "study"})
+     */
+    String value();
+}

src/main/java/cz/davza/studentadventure/base/CommandBase.java

@@ -0,0 +1,71 @@
+package cz.davza.studentadventure.base;
+
+import cz.davza.studentadventure.interfaces.ICommand;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import java.util.List;
+
+// DU Z 12. CVIČENÍ - Dědičnost - Základní třída pro veškeré příkazy které z této dědí a přepisují funkci Execute
+
+
+
+/**
+ * Abstract base class for all player commands.
+ *
+ * <p>Provides shared parameter handling that all commands rely on. When the
+ * {@link cz.davza.studentadventure.managers.CommandFactory} instantiates a command, it
+ * calls {@link #setParams(List)} with the arguments the player typed
+ * after the keyword.</p>
+ *
+ * <p>Concrete subclasses must be annotated with
+ * {@link cz.davza.studentadventure.annotations.CommandKeyword} so the factory can
+ * discover and register them. They must implement {@link #Execute(GameData)} to
+ * define their behaviour.</p>
+ *
+ * <p>Example — a command typed as {@code "pickup book 2"} will have params
+ * {@code ["book", "2"]} when {@code Execute} is called.</p>
+ *
+ * @see cz.davza.studentadventure.interfaces.ICommand
+ * @see cz.davza.studentadventure.managers.CommandFactory
+ */
+public abstract class CommandBase implements ICommand {
+    private List<String> params;
+    /**
+     * Sets the parameter list parsed from the player's input.
+     * Called by {@link cz.davza.studentadventure.managers.CommandFactory} before {@link #Execute}.
+     *
+     * @param params the list of argument strings following the command keyword
+     */
+    public void setParams(List<String> params) {
+        this.params = params;
+    }
+    /**
+     * Returns the parameter list for this command invocation.
+     *
+     * @return the parameter list, or {@code null} if params have not been set
+     */
+    public List<String> getParams() {
+        return params;
+    }
+
+    /**
+     * Checks whether at least {@code minimum} parameters were supplied.
+     *
+     * <p>Commands should call this at the start of {@link #Execute} to guard
+     * against missing arguments, returning {@link CommandState#INVALID_PARAMS}
+     * if the check fails.</p>
+     *
+     * @param minimum the minimum number of parameters required
+     * @return {@code true} if the param list is non-null and has at least {@code minimum} entries
+     */
+    protected boolean hasParams(int minimum) {
+        return params != null && params.size() >= minimum;
+    }
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public abstract CommandResult Execute(GameData context);
+
+}

src/main/java/cz/davza/studentadventure/base/ItemBase.java

@@ -0,0 +1,61 @@
+package cz.davza.studentadventure.base;
+
+import cz.davza.studentadventure.interfaces.IItem;
+
+// DU Z 12. CVIČENÍ - Dědičnost - Základní třída pro veškeré věci (Items), které ve hře figurují
+
+
+/**
+ * Abstract base class for all items in the game.
+ *
+ * <p>{@code ItemBase} provides the core identity fields every item needs —
+ * a display name, a description, a unique code, and a max stack size.
+ * Concrete item classes extend this and additionally implement one or more
+ * item behaviour interfaces ({@link cz.davza.studentadventure.interfaces.ICollectable},
+ * {@link cz.davza.studentadventure.interfaces.IConsumable},
+ * {@link cz.davza.studentadventure.interfaces.IInteractable}).</p>
+ *
+ * <p>The {@code code} field (e.g. {@code "book"}, {@code "energy_drink"}) is the
+ * primary key used by commands and room lookups to identify items, so it must
+ * be unique per item type.</p>
+ *
+ * @see cz.davza.studentadventure.interfaces.IItem
+ */
+public abstract class ItemBase implements IItem {
+    private final String name;
+    private final String description;
+    private final String code;
+    private final int bulk;
+    /**
+     * Constructs a new item with the given identity properties.
+     *
+     * @param name        the human-readable display name (e.g. {@code "Energy Drink"})
+     * @param description a short description shown when the player examines the item
+     * @param code        the unique identifier used in commands (e.g. {@code "energy_drink"})
+     * @param bulk   the maximum number of this item that can occupy a single inventory slot
+     */
+    public ItemBase(String name, String description, String code, int bulk) {
+        this.name = name;
+        this.description = description;
+        this.code = code;
+        this.bulk = bulk;
+    }
+    /** {@inheritDoc} */
+    @Override
+    public String getCode() { return code; }
+    /** {@inheritDoc} */
+    @Override
+    public int getBulk() { return bulk; }
+    /**
+     * Returns the human-readable display name of this item.
+     *
+     * @return the item's name
+     */
+    public String getName() { return name; }
+    /**
+     * Returns a short description of this item.
+     *
+     * @return the item description
+     */
+    public String getDescription() { return description; }
+}

src/main/java/cz/davza/studentadventure/base/ItemCollectionBase.java

@@ -0,0 +1,103 @@
+package cz.davza.studentadventure.base;
+
+import cz.davza.studentadventure.interfaces.ICollection;
+import cz.davza.studentadventure.interfaces.IItem;
+import cz.davza.studentadventure.objects.ItemStack;
+
+import java.util.*;
+
+/**
+ * Abstract base implementation of a fixed-size, slot-based item collection.
+ *
+ * <p>Internally backed by a {@link java.util.HashMap} keyed on item code. Items are stacked
+ * automatically — {@link #Add} first fills existing stacks of the same item code
+ * before opening new slots. Any items that exceed the collection's capacity are
+ * returned as a leftover count.</p>
+ *
+ * <p>Concrete subclasses ({@link cz.davza.studentadventure.objects.PlayerInventory} and
+ * {@link cz.davza.studentadventure.objects.RoomItems}) simply call {@code super(size)}
+ * and inherit all behaviour.</p>
+ *
+ * @param <T> the item type this collection holds, constrained to {@link IItem}
+ *
+ * @see cz.davza.studentadventure.objects.PlayerInventory
+ * @see cz.davza.studentadventure.objects.RoomItems
+ * @see ItemStack
+ */
+public abstract class  ItemCollectionBase<T extends IItem> implements ICollection<T> {
+    private final Map<String,ItemStack> items;
+    private final int capacity;
+    private int usedCapacity;
+    /**
+     * Constructs a new collection with the given capacity
+     *
+     * @param capacity the fixed capacity of this collection (bulk it can hold)
+     */
+    public ItemCollectionBase(int capacity) {
+        this.items = new HashMap<String, ItemStack>();
+        this.capacity = capacity;
+    }
+    /**
+     * {@inheritDoc}
+     *
+     * <p>Adds items to relevant ItemStack.</p>
+     *
+     * @return the number of items that could not
+     * be added due to capacity being full.
+     */
+    @Override
+    public int Add(IItem item, int count){
+        int canInsert = Math.min(count, this.GetRemainingCapacity()/item.getBulk());
+        if (canInsert <= 0){return count;}
+        if (items.containsKey(item.getCode())){
+            items.get(item.getCode()).Add(canInsert);
+        } else{
+            items.put(item.getCode(),new ItemStack(item, canInsert));
+        }
+        // add remaining possible amount to stack
+        usedCapacity += canInsert * item.getBulk();
+        return count - canInsert;
+    }
+    /**
+     * {@inheritDoc}
+     *
+     * <p>If {@code count} meets or exceeds the stack size, the slot is set to
+     * {@code null}. If the item is not present the call is silently ignored.</p>
+     */
+    @Override
+    public void Remove(String code, int count) {
+        ItemStack stack = items.getOrDefault(code, null);
+        if (stack == null) return;
+        int amountToRemove = Math.min(count, stack.getAmount());
+        stack.Remove(amountToRemove);
+        this.usedCapacity -= amountToRemove*stack.getItem().getBulk();
+        if (stack.getAmount() <= 0){ items.remove(code);}
+    }
+    public ItemStack GetByItemCode(String code) {
+        return items.get(code);
+    }
+    /** {@inheritDoc} */
+    @Override
+    public int GetCapacity() {
+        return this.capacity;
+    }
+    @Override
+    public int GetRemainingCapacity(){
+        return this.capacity - this.usedCapacity;
+    }
+    /** {@inheritDoc} */
+    @Override
+    public void Empty() {
+        items.clear();
+        usedCapacity = 0;
+    }
+
+    /**
+     * Returns the Stacks of Items that the collection holds
+     * @return Collection of ItemStacks the collection holds
+     */
+    public Collection<ItemStack> GetItems(){
+        return items.values();
+    }
+//
+}

src/main/java/cz/davza/studentadventure/base/ObservableBase.java

@@ -0,0 +1,65 @@
+package cz.davza.studentadventure.base;
+
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.interfaces.IObservable;
+import cz.davza.studentadventure.interfaces.IObserver;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+// DU Z 12. CVIČENÍ - Návrhový vzor Observer, který se zejména využívá pro sledování ukončení hry
+
+/**
+ * Base implementation of the Observer pattern for game state events.
+ *
+ * <p>Maintains a map of {@link CommandState} keys to sets of registered
+ * {@link IObserver} listeners. Any class that needs to broadcast state-change
+ * events (e.g. {@link cz.davza.studentadventure.objects.Game},
+ * {@link cz.davza.studentadventure.objects.GameMap}) can extend this class and
+ * call {@link #notifyObservers(CommandState)} when the relevant state occurs.</p>
+ *
+ * <p>Multiple observers can be registered for the same state. Observers are stored
+ * in a {@link HashSet}, so duplicate registrations of the same instance are ignored.</p>
+ *
+ * @see IObservable
+ * @see IObserver
+ */
+public class ObservableBase implements IObservable {
+
+    private final Map<CommandState, Set<IObserver>> observers = new HashMap<>();
+    /**
+     * Registers an observer to be notified when the given state is fired.
+     *
+     * <p>If no observer set exists for {@code registeringState} yet, one is
+     * created automatically. Registering the same observer instance twice for
+     * the same state has no effect (set semantics).</p>
+     *
+     * @param registeringState the event state this observer wants to listen for
+     * @param newObserver      the observer to register
+     */
+    @Override
+    public void addObserver(CommandState registeringState,IObserver newObserver) {
+        if  (!observers.containsKey(registeringState)) observers.put(registeringState, new HashSet<>());
+        observers.get(registeringState).add(newObserver);
+    }
+
+    /**
+     * Notifies all observers registered for the given state.
+     *
+     * <p>If no observers are registered for {@code notifiedState}, the call is
+     * silently ignored. Each registered observer's {@link IObserver#update()} method
+     * is called in an unspecified order.</p>
+     *
+     * @param notifiedState the state event that has occurred
+     */
+    @Override
+    public void notifyObservers(CommandState notifiedState) {
+    if   (!observers.containsKey(notifiedState)) return;
+
+    for (IObserver observer : observers.get(notifiedState)) {
+        observer.update();
+    }
+    }
+}

src/main/java/cz/davza/studentadventure/base/RoomBase.java

@@ -0,0 +1,200 @@
+package cz.davza.studentadventure.base;
+
+import cz.davza.studentadventure.interfaces.ICollectable;
+import cz.davza.studentadventure.interfaces.IInteractable;
+import cz.davza.studentadventure.interfaces.IItem;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.ItemStack;
+import cz.davza.studentadventure.objects.RoomItems;
+
+import java.util.*;
+
+/**
+ * Abstract base class for all rooms in the game world.
+ *
+ * <p>A room holds a set of items, a map of named exits to neighbouring rooms,
+ * and a list of commands that are valid while the player is present.
+ *
+ * <p>Subclasses configure the room by adding to {@link #allowedCommands} in
+ * their constructor and can override {@link #onEnter(GameData)} to enforce
+ * entry conditions (e.g. requiring the player to carry a book before entering
+ * a classroom).</p>
+ *
+ * @see cz.davza.studentadventure.rooms.BedroomRoom
+ * @see cz.davza.studentadventure.rooms.ClassroomRoom
+ */
+public abstract class RoomBase {
+    private final String name;
+    private final String exitCode;
+    private final String description;
+    private final ItemCollectionBase<IItem> items;
+    private final Map<String, RoomBase> exits = new HashMap<>();
+
+    /**
+     * Commands permitted in this room in addition to the global commands.
+     * Subclasses add entries (e.g. {@code "study"}, {@code "sleep"}) in their constructor.
+     */
+    protected final List<String> allowedCommands = new ArrayList<>();
+
+
+
+    /**
+     * Constructs a new room with the given name, description and item capacity.
+     *
+     * <p>All rooms automatically allow {@code "pickup"}, {@code "interact"}, and
+     * {@code "walk"} by default.</p>
+     *
+     * @param name         the display name of the room (e.g. {@code "Bedroom"})
+     * @param description  the text shown when the player enters or looks around
+     * @param itemCapacity the maximum number of item slots in this room
+     */
+    public RoomBase(String name,String exitCode, String description, int itemCapacity) {
+        this.name = name;
+        this.exitCode = exitCode;
+        this.description = description;
+        this.items = new RoomItems(itemCapacity);
+
+        // All rooms support these by default
+        allowedCommands.add("pickup");
+        allowedCommands.add("interact");
+        allowedCommands.add("walk");
+        allowedCommands.add("drop");
+    }
+
+
+    /**
+     * Registers a one-way exit from this room to another.
+     *
+     * @param room the room this exit leads to
+     */
+    public void addExit(RoomBase room) {
+        exits.put(room.getExitCode(), room);
+    }
+    /**
+     * Returns the room connected by the given exit key, or {@code null} if no
+     * such exit exists.
+     *
+     * @param key the direction keyword (case-insensitive)
+     * @return the connected room, or {@code null}
+     */
+    public RoomBase getExit(String key) {
+        return exits.get(key.toLowerCase());
+    }
+    /**
+     * Returns an unmodifiable view of all exits registered on this room.
+     *
+     * @return a map of exit keywords to destination rooms
+     */
+    public Map<String, RoomBase> getExits() {
+        return exits;
+    }
+
+    /**
+     * Searches this room's items for an {@link IInteractable} with the given code.
+     *
+     * @param code the item code to look for
+     * @return the matching {@link ItemBase} (cast-safe as {@link IInteractable}),
+     *         or {@code null} if not found
+     */
+    public ItemStack getInteractable(String code) {
+        ItemStack stack = items.GetByItemCode(code);
+        if (stack != null && stack.getItem() instanceof IInteractable) { return stack;}
+        return null;
+    }
+    /**
+     * Searches this room's items for an {@link ICollectable} with the given code.
+     *
+     * @param code the item code to look for
+     * @return the matching item as {@link ICollectable}, or {@code null} if not found
+     */
+    public ItemStack getCollectable(String code) {
+        ItemStack stack = items.GetByItemCode(code);
+        if (stack != null && stack.getItem() instanceof ICollectable) { return stack;}
+        return null;
+    }
+
+    /**
+     * Prints the room's name, description, available exits, and visible items
+     * to {@code System.out}.
+     */
+    public String describe() {
+        StringBuilder description = new StringBuilder();
+        description.append("===").append(name).append(" ===\n");
+        description.append(getDescription()).append("\n");
+        description.append(describeExits());
+        description.append(describeItems());
+        return description.toString();
+    }
+
+    private String describeExits() {
+        if (exits.isEmpty()) {
+            return "There are no exits.\n";
+        }
+        return "Exits: " + String.join(", ", exits.keySet()) + "\n";
+    }
+
+    private String describeItems() {
+        StringBuilder output = new StringBuilder();
+        Collection<ItemStack> roomItems = items.GetItems();
+        if (roomItems.isEmpty()) {
+            output.append("There are no items in this room.\n");
+        }else{
+            for(ItemStack item : roomItems){
+                output.append(item.toString()).append("\n");
+            }
+        }
+        return output.toString();
+    }
+    /**
+     * Removes up to {@code count} of the item with the given code from this room.
+     * If the item is not found the call is silently ignored.
+     *
+     * @param code  the item code to remove
+     * @param count the number of items to remove
+     */
+    public void removeItem(String code, int count) {
+        items.Remove(code, count);
+    }
+    /**
+     * Returns the item collection for this room.
+     *
+     * @return this room's {@link RoomItems}
+     */
+    public ItemCollectionBase<IItem> getItems() { return items; }
+    /**
+     * Returns the display name of this room.
+     *
+     * @return the room name
+     */
+    public String getName() { return name; }
+    /**
+     * Returns the description of this room.
+     *
+     * @return the room description
+     */
+    public String getDescription() { return description; }
+    /**
+     *
+     * <p>Subclasses can override this to enforce entry conditions. To block entry,
+     * call {@code context.getGame().setNextRoom(null)} inside the override.
+     * The default implementation does nothing.</p>
+     *
+     * @param context the current game state
+     * @return CommandResult result of the Walk command
+     */
+    public CommandResult onEnter(GameData context){
+        return CommandResult.success();
+    }
+    public List<String> getAllowedCommands() {
+        return allowedCommands;
+    }
+
+    public String getExitCode() {
+        return exitCode;
+    }
+    @Override
+    public String toString() {
+        return exitCode;
+    }
+}

src/main/java/cz/davza/studentadventure/commands/AvailableCommandsCommand.java

@@ -0,0 +1,32 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+/**
+ * Lists all commands currently available to the player in their location.
+ *
+ * <p>Usage: {@code availablecommands}</p>
+ *
+ * <p>The list is derived from the current room's allowed commands merged with the
+ * global commands that are always available. Useful when the player is unsure
+ * what actions are valid in an unfamiliar room.</p>
+ */
+@CommandKeyword("availablecommands")
+public class AvailableCommandsCommand extends CommandBase {
+
+    /**
+     * {@inheritDoc}
+     * Outputs a bullet-point list of every command keyword the player can currently use.
+     */
+    @Override
+    public CommandResult Execute(GameData context) {
+        StringBuilder output = new StringBuilder();
+        output.append("Commands you can run here are:\n");
+        for (String command:context.getAllowedCommands()){
+            output.append("-").append(command).append("\n");
+        }
+        return CommandResult.success(output.toString());
+    }
+}

src/main/java/cz/davza/studentadventure/commands/BuyCommand.java

@@ -0,0 +1,51 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.Player;
+import cz.davza.studentadventure.Items.EnergyDrink;
+/**
+ * Purchases an item from the campus shop and adds it to the player's inventory.
+ *
+ * <p>Usage: {@code buy <itemCode>} (e.g. {@code buy energy_drink})</p>
+ *
+ * <p>Currently only {@code energy_drink} is available. The command checks the
+ * player's balance and inventory space before completing the transaction.</p>
+ */
+@CommandKeyword("buy")
+public class BuyCommand extends CommandBase {
+    /** {@inheritDoc} Requires one parameter: the item code to purchase. */
+    @Override
+    public CommandResult Execute(GameData context) {
+        if (!hasParams(1)) return CommandResult.invalidParams();
+
+        String itemCode = getParams().get(0).toLowerCase();
+        Player player   = context.getPlayer();
+
+        switch (itemCode) {
+            case "energy_drink":
+                return buyEnergyDrink(player);
+            default:
+                return CommandResult.failed("The shop doesn't sell that.\n");
+        }
+    }
+
+    private CommandResult buyEnergyDrink(Player player) {
+        if (player.getWallet().getMoney() < EnergyDrink.COST) {
+            return CommandResult.failed("You can't afford that. You need "
+                    + EnergyDrink.COST + " coins but only have "
+                    + player.getWallet().getMoney() + ".\n");
+        }
+
+        int leftOver = player.getInventory().Add(new EnergyDrink(), 1);
+        if (leftOver > 0) {
+            return CommandResult.inventoryFull("Your inventory is full, no room for the drink.");
+        }
+
+        player.getWallet().spendMoney(EnergyDrink.COST);
+        return CommandResult.success("You buy an energy drink for " + EnergyDrink.COST
+                + " coins. Money remaining: " + player.getWallet().getMoney() + " coins.\n");
+    }
+}

src/main/java/cz/davza/studentadventure/commands/ConsumeCommand.java

@@ -0,0 +1,44 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.interfaces.IConsumable;
+import cz.davza.studentadventure.objects.ItemStack;
+import cz.davza.studentadventure.objects.Player;
+/**
+ * Consumes an item from the player's inventory, applying its effect.
+ *
+ * <p>Usage: {@code consume <itemcode>} (e.g. {@code consume 2})</p>
+ *
+ * <p>The item at the given slot must implement {@link IConsumable}. One instance
+ * is removed from the slot after consumption. Player stats are printed after the
+ * effect is applied.</p>
+ */
+@CommandKeyword("consume")
+public class ConsumeCommand extends CommandBase {
+    /** {@inheritDoc} Requires one parameter: the items codename. */
+    @Override
+    public CommandResult Execute(GameData context) {
+        if (!hasParams(1)) return CommandResult.invalidParams();
+        String itemCode = getParams().get(0);
+        Player player   = context.getPlayer();
+        ItemStack stack = player.getInventory().GetByItemCode(itemCode);
+
+        if (stack == null) {
+            return CommandResult.itemNotFound("You do not have a(n) " + itemCode + ".\n");
+        }
+
+        if (!(stack.getItem() instanceof IConsumable)) {
+            return CommandResult.failed("You can't consume that.\n");
+        }
+
+        IConsumable consumable = (IConsumable) stack.getItem();
+        consumable.consume(player);
+        player.getInventory().Remove(itemCode, 1);
+
+        player.printStats();
+        return CommandResult.success(consumable.getConsumeMessage());
+    }
+}

src/main/java/cz/davza/studentadventure/commands/DescribeCommand.java

@@ -0,0 +1,26 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+/**
+ * Describes the player's current room — its name, exits, and visible items.
+ *
+ * <p>Usage: {@code describe}</p>
+ *
+ * <p>Delegates to {@link cz.davza.studentadventure.base.RoomBase#describe()}.
+ * Useful after moving to a new room or when the player wants a reminder of
+ * what is around them. No parameters are required.</p>
+ */
+@CommandKeyword("describe")
+public class DescribeCommand extends CommandBase {
+    /**
+     * {@inheritDoc}
+     * Returns the current room's full description string.
+     */
+    @Override
+    public CommandResult Execute(GameData context){
+        return CommandResult.success(context.getMap().getCurrentRoom().describe());
+    }
+}

src/main/java/cz/davza/studentadventure/commands/DropCommand.java

@@ -0,0 +1,70 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.interfaces.IItem;
+import cz.davza.studentadventure.objects.ItemStack;
+import cz.davza.studentadventure.objects.Player;
+/**
+ * Drops an item from the inventory into the current room.
+ *
+ * <p>Usage: {@code drop <itemcode> <amount>} (e.g. {@code drop 0})</p>
+ *
+ * <p>Only the number of items that actually fit in the room are removed from
+ * the inventory. Any items the room could not accommodate remain in the slot.</p>
+ */
+@CommandKeyword("drop")
+public class DropCommand extends CommandBase {
+    /** {@inheritDoc} Requires one parameter: the item code to drop, and an optional quantity (defaults to 1). */
+    @Override
+    public CommandResult Execute(GameData context) {
+        if (!hasParams(1)) return CommandResult.invalidParams();
+        String itemCode = getParams().get(0);
+        if (itemCode == null || itemCode.trim().isEmpty()) {
+            return CommandResult.invalidParams();
+
+        }
+        int dropAmount;
+        String output;
+        Player player   = context.getPlayer();
+        ItemStack stack = player.getInventory().GetByItemCode(itemCode);
+
+        if (getParams().size() == 2) {
+            try{
+                dropAmount = Integer.parseInt(getParams().get(1));
+            } catch  (NumberFormatException e){
+                return CommandResult.invalidParams();
+            }
+        }else{
+            dropAmount = 1;
+        }
+
+
+        if (stack == null) {
+            return CommandResult.itemNotFound("You do not seem to have a(n) " + itemCode + ".\n");
+        }
+
+        IItem item  = stack.getItem();
+        dropAmount = Math.min(stack.getAmount(), dropAmount);
+        // Add to room first
+        int roomLeftCapacity = context.getMap().getCurrentRoom().getItems().GetRemainingCapacity();
+        int leftOverCapacity = roomLeftCapacity/item.getBulk() - dropAmount;
+        if (leftOverCapacity >= 0) {
+            player.getInventory().Remove(itemCode, dropAmount);
+            context.getMap().getCurrentRoom().getItems().Add(item, dropAmount);
+            output = "You drop " + dropAmount + " " + itemCode + ".\n";
+
+        }else{
+            int droppedAmount = dropAmount - Math.abs(leftOverCapacity);
+            // not everything could be dropped (dropAmount * bulk > available capacity
+            // absolute value of leftOverCapacity = the amount we couldn't drop (as long as leftOverCapacity < 0
+            context.getMap().getCurrentRoom().getItems().Add(item, droppedAmount);
+            player.getInventory().Remove(itemCode, droppedAmount);
+            output = "You drop "+ droppedAmount + " of " + itemCode
+                    + " but the room is cluttered so you cannot drop more.\n";
+        }
+        return CommandResult.success(output);
+    }
+}

src/main/java/cz/davza/studentadventure/commands/HelpCommand.java

@@ -0,0 +1,54 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+/**
+ * Displays the full command reference for the game.
+ *
+ * <p>Usage: {@code help}</p>
+ *
+ * <p>Prints a static list of every command keyword and a short description of
+ * what it does. Available in all rooms. No parameters are required.</p>
+ */
+@CommandKeyword("help")
+public class HelpCommand extends CommandBase {
+
+    /**
+     * {@inheritDoc}
+     * Returns the full command reference as a formatted string.
+     */
+    @Override
+    public CommandResult Execute(GameData context) {
+
+        return CommandResult.success(printHelp());
+    }
+    /**
+     * Builds and returns the command reference text.
+     *
+     * @return a multi-line string listing all available commands and their usage
+     */
+    private String printHelp() {
+        return """
+            === COMMANDS ===
+            walk <exit>        - Move to another room
+            pickup <item> <n>  - Pick up n of an item
+            drop <slot>        - Drop item from inventory slot
+            interact <item>    - Interact with an item
+            study <hours>      - Study for n hours
+            sleep              - Sleep (bedroom and classroom only)
+            steal              - Steal money (study room only)
+            buy <item>         - Buy an item (shop only)
+            consume <slot>     - Consume an item from inventory
+            takeexam           - Take the final exam (exam room only)
+            inventory          - Show your inventory
+            stats              - Show your stats
+            time               - Show current game time
+            describe           - Describe the current scene
+            quit               - Give up
+            studentId          - Tells you your student ID (computer only)
+            availablecommands  - Tells you your currently available commands
+            """;
+    }
+}

src/main/java/cz/davza/studentadventure/commands/InteractCommand.java

@@ -0,0 +1,46 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.base.RoomBase;
+import cz.davza.studentadventure.interfaces.IInteractable;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.ItemStack;
+
+/**
+ * Lets the player interact with an interactable item in the current room.
+ *
+ * <p>Usage: {@code interact <itemCode>} (e.g. {@code interact computer})</p>
+ *
+ * <p>Locates the item via {@link RoomBase#getInteractable(String)} and hands
+ * control to {@link IInteractable#Interact(GameData)}. If the code matches a
+ * collectable instead, a contextual "can't interact" message is shown.</p>
+ */
+@CommandKeyword("interact")
+public class InteractCommand extends CommandBase {
+    /** {@inheritDoc} Requires one parameter: the item code to interact with. */
+    @Override
+    public CommandResult Execute(GameData context) {
+        if (!hasParams(1)) return CommandResult.invalidParams();
+
+        String itemCode = getParams().getFirst();
+        RoomBase room = context.getMap().getCurrentRoom();
+
+        // Check if item exists at all first
+        ItemStack item = room.getInteractable(itemCode);
+        if (item == null) {
+            if (room.getCollectable(itemCode) != null) {
+                return CommandResult.itemNotInteractable("You can't interact with that.\n");
+            }
+            return CommandResult.itemNotInteractable("There is no " + itemCode + " here.\n");
+        }
+
+        // Hand control over to the item's own event loop
+
+        return ((IInteractable) item.getItem()).Interact(context);
+
+    }
+
+
+}

src/main/java/cz/davza/studentadventure/commands/InventoryCommand.java

@@ -0,0 +1,30 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.ItemStack;
+/**
+ * Displays the contents of the player's inventory.
+ *
+ * <p>Usage: {@code inventory}</p>
+ *
+ * <p>Lists all occupied slots with their index, item code, and quantity.
+ * Empty slots are omitted. No parameters are required.</p>
+ */
+@CommandKeyword("inventory")
+public class InventoryCommand extends CommandBase {
+    /** {@inheritDoc} */
+    @Override
+    public CommandResult Execute(GameData context) {
+        // No params needed, inventory is always accessible
+        var inventory = context.getPlayer().getInventory();
+        StringBuilder output = new StringBuilder();
+        output.append("=== Inventory ===\n");
+        for (ItemStack inventoryStack : inventory.GetItems()) {
+            output.append(inventoryStack.toString()).append("\n");
+        }
+        return CommandResult.success(output.toString());
+    }
+}

src/main/java/cz/davza/studentadventure/commands/PickupCommand.java

@@ -0,0 +1,64 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.base.RoomBase;
+import cz.davza.studentadventure.interfaces.ICollectable;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.ItemStack;
+
+/**
+ * Picks up a quantity of a collectable item from the current room.
+ *
+ * <p>Usage: {@code pickup <itemCode> <amount>} (e.g. {@code pickup book 2})</p>
+ *
+ * <p></p>
+ */
+@CommandKeyword("pickup")
+
+    public class PickupCommand extends CommandBase {
+    /** {@inheritDoc} Requires two parameters: item code and quantity. */
+        @Override
+        public CommandResult Execute(GameData context) {
+            if (!hasParams(1)) return CommandResult.invalidParams();
+
+            String itemCode = getParams().get(0);
+            int amount;
+            if (getParams().size() >= 2) {
+            try {
+                amount = Integer.parseInt(getParams().get(1));
+            } catch (NumberFormatException e) {
+                return CommandResult.invalidParams();
+            }
+            }
+            else {
+                amount = 1;
+            }
+
+            RoomBase room = context.getMap().getCurrentRoom();
+
+            // Check item exists in room
+            ItemStack item = room.getItems().GetByItemCode(itemCode);
+            if (item == null) return CommandResult.itemNotFound("There is no " + itemCode + " here.\n");
+            if (!(item.getItem() instanceof ICollectable)) return CommandResult.itemNotCollectable("You can't pick that up.\n");
+
+            CommandResult onPickupResult = ((ICollectable) item.getItem()).onPickup(context, amount);
+            if (onPickupResult != null) return onPickupResult;
+            // Try adding to inventory
+            int leftOver = context.getPlayer().getInventory().Add(item.getItem(), amount);
+            // Remove only what was actually picked up from the room
+            int pickedUp = amount - leftOver;
+            if (pickedUp > 0) {
+                room.removeItem(itemCode, pickedUp);
+            }
+
+            if (leftOver > 0) {
+                return CommandResult.inventoryFull("Picked up " + pickedUp + " " + itemCode
+                        + ". Inventory full, " + leftOver + " left on the ground.\n");
+            }
+
+            return CommandResult.success("Picked up " + amount + " " + itemCode + ".\n");
+        }
+    }
+

src/main/java/cz/davza/studentadventure/commands/SleepCommand.java

@@ -0,0 +1,77 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.base.RoomBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.rooms.BedroomRoom;
+import cz.davza.studentadventure.rooms.ClassroomRoom;
+import cz.davza.studentadventure.objects.Player;
+import java.util.Random;
+/**
+ * Lets the player sleep, restoring energy and reducing stress.
+ *
+ * <p>Behaviour differs by location:</p>
+ * <ul>
+ *   <li><b>Bedroom</b> — always succeeds; fully restores stats and advances to next morning.</li>
+ *   <li><b>Classroom</b> — has a {@value #CATCH_CHANCE} chance of being caught, which ends
+ *       the game. On success, partially restores stats and advances time by 2 hours.</li>
+ *   <li><b>Anywhere else</b> — fails with a message.</li>
+ * </ul>
+ */
+@CommandKeyword("sleep")
+public class SleepCommand extends CommandBase {
+
+    private static final double CATCH_CHANCE = 0.30;
+    private final Random random = new Random();
+    /** {@inheritDoc} */
+    @Override
+    public CommandResult Execute(GameData context) {
+        RoomBase room = context.getMap().getCurrentRoom();
+        CommandResult output;
+        if (room instanceof BedroomRoom) {
+            output = sleepInBed(context.getPlayer());
+            context.getPlayer().resetHoursAwake();
+            context.getTime().advanceToNextMorning();
+            return output;
+        } else if (room instanceof ClassroomRoom) {
+            output = sleepInClass(context.getPlayer());
+            context.getPlayer().addHoursAwake(-2);
+            context.getTime().advanceHours(2);
+            return output;
+        }
+
+        return CommandResult.failed("You can't sleep here.\n");
+    }
+
+    private CommandResult sleepInBed(Player player) {
+        restoreStats(player);
+        return CommandResult.success("You crawl into bed and sleep...\n" +
+                "You wake up feeling refreshed.\n" +
+                player.printStats());
+    }
+
+    private CommandResult sleepInClass(Player player) {
+        if (random.nextDouble() < CATCH_CHANCE) {
+            return CommandResult.gameOver(
+                    "You try to sneak in a nap during class...\n" +
+                            "The professor slams a book on your desk.\n" +
+                            "\"Get out of my classroom and don't come back!\"\n" +
+                            "\nGAME OVER - You were caught sleeping in class and kicked out of school.");
+        }
+
+        restoreStats(player);
+        return CommandResult.success(
+                "You try to sneak in a nap during class...\n" +
+                        "You manage to sleep without being noticed.\n" +
+                        "You wake up just in time. Lucky.\n" +
+                        player.printStats());
+    }
+
+    private void restoreStats(Player player) {
+        player.getEnergy().increase(100);
+        player.getStress().decrease(100);
+    }
+}

src/main/java/cz/davza/studentadventure/commands/StatsCommand.java

@@ -0,0 +1,23 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.enums.CommandState;
+/**
+ * Prints the player's current stats to the console.
+ *
+ * <p>Usage: {@code stats}</p>
+ *
+ * <p>Delegates to {@link cz.davza.studentadventure.objects.Player#printStats()}.
+ * No parameters are required.</p>
+ */
+@CommandKeyword("stats")
+public class StatsCommand extends CommandBase {
+    /** {@inheritDoc} */
+    @Override
+    public CommandResult Execute(GameData context) {
+        return CommandResult.success(context.getPlayer().printStats());
+    }
+}

src/main/java/cz/davza/studentadventure/commands/StealCommand.java

@@ -0,0 +1,61 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.Player;
+import java.util.Random;
+/**
+ * Attempts to steal coins from an unattended bag in the study room.
+ *
+ * <p>Usage: {@code steal}</p>
+ *
+ * <p>There is a base {@value #CATCH_CHANCE_NORMAL} chance of being caught. If the
+ * player is in a <em>desperate</em> state (high stress and low energy simultaneously)
+ * the catch chance is reduced to {@value #CATCH_CHANCE_DESPERATE} — desperation makes
+ * the player bolder but also less careful. Getting caught ends the game.</p>
+ *
+ * <p>On success, a random amount between {@value #MIN_STEAL} and {@value #MAX_STEAL}
+ * coins is added to the player's balance.</p>
+ */
+@CommandKeyword("steal")
+public class StealCommand extends CommandBase {
+
+    private static final double CATCH_CHANCE_NORMAL     = 0.40;
+    private static final double CATCH_CHANCE_DESPERATE  = 0.15;
+    private static final int    DESPERATE_STRESS_THRESHOLD = 70;
+    private static final int    DESPERATE_ENERGY_THRESHOLD = 30;
+    private static final int    MIN_STEAL = 10;
+    private static final int    MAX_STEAL = 40;
+
+    private final Random random = new Random();
+    /** {@inheritDoc} */
+    @Override
+    public CommandResult Execute(GameData context) {
+        Player player = context.getPlayer();
+
+        boolean desperate = player.getStress().getValue() > DESPERATE_STRESS_THRESHOLD
+                && player.getEnergy().getValue() < DESPERATE_ENERGY_THRESHOLD;
+
+        double catchChance = desperate ? CATCH_CHANCE_DESPERATE : CATCH_CHANCE_NORMAL;
+        String attempt = desperate
+                ? "Hands shaking, you eye the unattended bag next to you..."
+                : "You glance around and reach for someone's bag...";
+
+        if (random.nextDouble() < catchChance) {
+            return CommandResult.gameOver(
+                    attempt + "\n" +
+                            "Someone shouts \"Hey! Thief!\"\n" +
+                            "Security escorts you out of the building.\n" +
+                            "\nGAME OVER - You were caught stealing.");
+        }
+
+        int stolen = MIN_STEAL + random.nextInt(MAX_STEAL - MIN_STEAL + 1);
+        player.getWallet().earnMoney(stolen);
+        return CommandResult.success(
+                attempt + "\n" +
+                        "You pocket " + stolen + " coins without anyone noticing.\n" +
+                        "Money: " + player.getWallet().getMoney() + " coins");
+    }
+}

src/main/java/cz/davza/studentadventure/commands/StudentIDCommand.java

@@ -0,0 +1,29 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+/**
+ * Displays the player's unique student ID.
+ *
+ * <p>Usage: {@code studentId}</p>
+ *
+ * <p>The student ID is required to enter the exam room. The player can look it up
+ * here while at a computer terminal, then remember (or note) it for later.
+ * No parameters are required.</p>
+ *
+ * @see cz.davza.studentadventure.rooms.ExamRoomRoom
+ */
+@CommandKeyword("studentId")
+public class StudentIDCommand extends CommandBase {
+
+    /**
+     * {@inheritDoc}
+     * Returns the player's student ID string.
+     */
+    @Override
+    public CommandResult Execute(GameData context) {
+        return CommandResult.success("Your student ID is: " + context.getPlayer().getId()+"\n");
+    }
+}

src/main/java/cz/davza/studentadventure/commands/StudyCommand.java

@@ -0,0 +1,106 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.Player;
+/**
+ * Allows the player to study for a given number of hours, gaining intelligence
+ * at the cost of energy and stress.
+ *
+ * <p>Usage: {@code study <hours>} (e.g. {@code study 3})</p>
+ *
+ * <p>Each hour of study consumes energy and generates stress. Both costs scale
+ * exponentially with study duration (via a fatigue multiplier) and are further
+ * increased by the player's sleep-deprivation multiplier. Studying while
+ * exhausted (energy ≤ {@code EXHAUSTION_THRESHOLD}) incurs an additional stress penalty.</p>
+ *
+ * <p>The loop terminates early if the player runs out of energy mid-session.</p>
+ */
+@CommandKeyword("study")
+public class StudyCommand extends CommandBase {
+
+    private static final int    INTELLIGENCE_GAIN    = 5;
+    private static final int    ENERGY_COST          = 10;
+    private static final int    STRESS_GAIN          = 5;
+    private static final int    STRESS_GAIN_TIRED    = 10;
+    private static final int    EXHAUSTION_THRESHOLD = 20;
+    private static final double FATIGUE_RATE         = 1.3;
+    /** {@inheritDoc} Requires one parameter: number of hours to study. */
+    @Override
+    public CommandResult Execute(GameData context) {
+        if (!hasParams(1)) return CommandResult.invalidParams();
+
+        int hours;
+        try {
+            hours = Integer.parseInt(getParams().get(0));
+            if (hours <= 0) return CommandResult.invalidParams();
+        } catch (NumberFormatException e) {
+            return CommandResult.invalidParams();
+        }
+
+        Player player = context.getPlayer();
+
+        if (player.getEnergy().getValue() == 0) {
+            return CommandResult.failed("You are too exhausted to study. Get some sleep.");
+        }
+
+        StringBuilder output = new StringBuilder();
+        int hoursCompleted = 0;
+
+        for (int i = 0; i < hours; i++) {
+            boolean exhausted      = player.getEnergy().getValue() <= EXHAUSTION_THRESHOLD;
+            double fatigueMult     = Math.pow(FATIGUE_RATE, i);
+            double deprivationMult = context.getPlayer().getDeprivationMultiplier();
+            double totalMult       = fatigueMult * deprivationMult;
+
+            int energyCost = (int) Math.round(ENERGY_COST * totalMult);
+            int stressCost = (int) Math.round(
+                    (exhausted ? STRESS_GAIN_TIRED : STRESS_GAIN) * totalMult
+            );
+
+            if (player.getEnergy().getValue() < energyCost) {
+                output.append("You run out of energy after ")
+                        .append(hoursCompleted)
+                        .append(" hour(s) and have to stop.\n");
+                break;
+            }
+
+
+
+            player.getIntelligence().increase(INTELLIGENCE_GAIN);
+            player.getEnergy().decrease(energyCost);
+            player.getStress().increase(stressCost);
+
+            hoursCompleted++;
+            player.addHoursAwake(1);
+            context.getTime().advanceHours(1);
+
+            if (exhausted) {
+                output.append("Hour ").append(hoursCompleted)
+                        .append(": Exhausted, studying is costing you more. ")
+                        .append("(energy -").append(energyCost)
+                        .append(", stress +").append(stressCost).append(")\n");
+            } else {
+                output.append("Hour ").append(hoursCompleted)
+                        .append(": Productive session. ")
+                        .append("(energy -").append(energyCost)
+                        .append(", stress +").append(stressCost).append(")\n");
+            }
+        }
+
+        if (hoursCompleted == hours) {
+            output.append("You finish studying. ").append(buildStatSummary(player));
+        }
+
+        return CommandResult.success(output.toString());
+    }
+
+    private String buildStatSummary(Player player) {
+        return "Stats → "
+                + player.getIntelligence()
+                + " | " + player.getEnergy()
+                + " | " + player.getStress();
+    }
+}

src/main/java/cz/davza/studentadventure/commands/TakeExamCommand.java

@@ -0,0 +1,70 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.Player;
+/**
+ * Triggers the final exam sequence — the win/lose condition of the game.
+ *
+ * <p>Usage: {@code takeexam}</p>
+ *
+ * <p>The player's effective exam score is calculated as:
+ * <pre>effectiveScore = intelligence - (stress / {@value #STRESS_DIVISOR})</pre>
+ * A score of at least {@value #PASS_THRESHOLD} is required to pass. The result
+ * tier (Pass, Merit, Distinction) is based on the effective score.</p>
+ *
+ * <p>Returns {@link CommandState#GAME_WIN} on success or
+ * {@link CommandState#GAME_OVER} on failure.</p>
+ */
+@CommandKeyword("takeexam")
+public class TakeExamCommand extends CommandBase {
+
+    private static final int PASS_THRESHOLD    = 50;
+    private static final int STRESS_DIVISOR    = 10;
+    /** {@inheritDoc} */
+    @Override
+    public CommandResult Execute(GameData context) {
+        Player player = context.getPlayer();
+
+        int intelligence   = player.getIntelligence().getValue();
+        int stressPenalty  = player.getStress().getValue() / STRESS_DIVISOR;
+        int effectiveScore = intelligence - stressPenalty;
+
+        String header = "\n=== FINAL EXAM ===\n" +
+                "You turn over the paper and begin...\n\n" +
+                "Intelligence:    " + intelligence + "\n" +
+                "Stress penalty:  -" + stressPenalty + "\n" +
+                "Effective score: " + effectiveScore + "/" + PASS_THRESHOLD + " needed\n\n";
+
+        if (effectiveScore >= PASS_THRESHOLD) {
+            return pass(effectiveScore, header);
+        } else {
+            return fail(header);
+        }
+    }
+
+    private CommandResult pass(int score, String header) {
+        String result;
+        if (score >= 80) {
+            result = "RESULT: DISTINCTION\nThe professor nods approvingly as you hand in your paper.";
+        } else if (score >= 65) {
+            result = "RESULT: PASS WITH MERIT\nA solid performance. All that studying paid off.";
+        } else {
+            result = "RESULT: PASS\nIt was close, but you scraped through.";
+        }
+        return CommandResult.gameWin(header +
+                "You move through the questions with confidence.\n" +
+                "Two hours later you put your pen down.\n\n" +
+                result + "\n\nCONGRATULATIONS - You passed the exam!");
+    }
+
+    private CommandResult fail(String header) {
+        return CommandResult.gameOver(header +
+                "You stare at the paper. The words blur together.\n" +
+                "You can't remember half of what you studied.\n\n" +
+                "RESULT: FAIL\n\nGAME OVER - You failed the exam.");
+    }
+}

src/main/java/cz/davza/studentadventure/commands/TimeCommand.java

@@ -0,0 +1,29 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+/**
+ * Prints the current in-game time and day.
+ *
+ * <p>Usage: {@code time}</p>
+ *
+ * <p>Delegates to {@link cz.davza.studentadventure.objects.GameTime#toString()},
+ * which formats the time as {@code "Day D, HH:00"}. Useful for tracking how
+ * close the exam deadline is. No parameters are required.</p>
+ *
+ * @see cz.davza.studentadventure.objects.GameTime
+ */
+@CommandKeyword("time")
+public class TimeCommand extends CommandBase {
+
+    /**
+     * {@inheritDoc}
+     * Returns the current game time as a formatted string.
+     */
+    @Override
+    public CommandResult Execute(GameData context) {
+        return CommandResult.success("Current time:" + context.getTime()+"\n");
+    }
+}

src/main/java/cz/davza/studentadventure/commands/WalkCommand.java

@@ -0,0 +1,56 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.base.RoomBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.enums.CommandState;
+/**
+ * Moves the player to a neighbouring room via a named exit.
+ *
+ * <p>Usage: {@code walk <exit>} (e.g. {@code walk hallway})</p>
+ *
+ * <p>Before committing the move, {@link RoomBase#onEnter(GameData)} is called on
+ * the destination room so entry conditions (such as requiring a textbook) can cancel
+ * the walk. Time is only advanced <em>after</em> the entry check passes.</p>
+ *
+ * <p>Returns {@link CommandState#ROOM_CHANGED} on success so the game loop knows to announce room change.</p>
+ */
+@CommandKeyword("walk")
+public class WalkCommand extends CommandBase {
+    /**
+     * {@inheritDoc}
+     *
+     * <p>Requires one parameter: the exit direction string.</p>
+     */
+    @Override
+    public CommandResult Execute(GameData context) {
+        if (!hasParams(1)) return CommandResult.invalidParams();
+
+        String direction = getParams().getFirst();
+        RoomBase nextRoom = context.getMap().getCurrentRoom().getExit(direction);
+
+        if (nextRoom == null) {
+            return CommandResult.failed("There is no exit that way.");
+        }
+
+        CommandResult entryResult = nextRoom.onEnter(context);
+
+        if (entryResult.getResultState() == CommandState.FAILED) {
+            return entryResult; // passes the onEnter failure message back up
+        }
+
+        if (entryResult.getResultState() == CommandState.ACTION_PENDING) {
+            context.getMap().setNextRoom(nextRoom); // hold the pending room change
+            return entryResult; // passes the handler and message back up to Game
+        }
+
+        // normal entry
+        context.getMap().setNextRoom(nextRoom);
+        context.getPlayer().addHoursAwake(2);
+        context.getTime().advanceHours(2);
+        return CommandResult.roomChanged(entryResult.getResultMessage());
+    }
+
+}

src/main/java/cz/davza/studentadventure/enums/CommandState.java

@@ -0,0 +1,53 @@
+package cz.davza.studentadventure.enums;
+
+import cz.davza.studentadventure.objects.Game;
+
+
+// DU Z 12. CVIČENÍ - Návrhový vzor Enum - výčet možných výsledů příkazu
+
+
+/**
+ * Represents the outcome of a command execution.
+ *
+ * <p>Returned by every {@link cz.davza.studentadventure.interfaces.ICommand#Execute} call.
+ * The game loop in {@link Game} switches on this value to
+ * determine how to react — e.g. committing a room change, ending the game, or
+ * displaying a generic error.</p>
+ */
+public enum CommandState {
+    /** The command completed successfully with no side effects requiring special handling. */
+
+    SUCCESS,
+    /** The command succeeded but with a non-fatal issue the player should be aware of. */
+
+    WARNING,
+    /** The command could not be completed (reason already printed to the player). */
+
+    FAILED,
+    /** The command received the wrong number or type of parameters. */
+
+    INVALID_PARAMS,
+    /** The player's inventory was full and could not accept the item. */
+
+    INVENTORY_FULL,
+    /** The specified item was not found in the current context. */
+
+    ITEM_NOT_FOUND,
+    /**
+     * The player successfully walked to a new room.
+     * The game loop commits the room change.
+     */
+    ROOM_CHANGED,
+    /** The item exists but cannot be picked up (e.g. it is interactable-only). */
+    ITEM_NOT_COLLECTABLE,
+    /** The item exists but cannot be interacted with (e.g. it is collectable-only). */
+    ITEM_NOT_INTERACTABLE,
+    /** A fatal event occurred — the game loop should end in defeat. */
+    GAME_OVER,
+    ACTION_PENDING,
+    ACTION_RESUMED,
+    INVENTORY_CHANGE,
+    /** The player won — the game loop should end in victory. */
+    GAME_WIN,
+    GAME_END
+}

src/main/java/cz/davza/studentadventure/enums/DeprivationState.java

@@ -0,0 +1,18 @@
+package cz.davza.studentadventure.enums;
+/**
+ * Represents the player's current sleep-deprivation level.
+ *
+ * <p>Determined by the number of consecutive hours the player has been awake.
+ * Used by {@link cz.davza.studentadventure.objects.Player#getDeprivationMultiplier()}
+ * to scale the cost of tiring activities.</p>
+ *
+ * @see cz.davza.studentadventure.objects.Player#getDeprivationState()
+ */
+public enum DeprivationState {
+    /** The player is well-rested. No penalty multiplier applied. */
+    NORMAL,
+    /** The player is getting tired (14+ hours awake). Mild penalty multiplier applied. */
+    TIRED,
+    /** The player is severely sleep-deprived (20+ hours awake). Escalating penalty applied. */
+    DEPRIVED
+}

src/main/java/cz/davza/studentadventure/gameWrappers/TextGameWrapper.java

@@ -0,0 +1,55 @@
+package cz.davza.studentadventure.gameWrappers;
+
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.interfaces.IGameWrapper;
+import cz.davza.studentadventure.objects.Game;
+
+import java.util.Scanner;
+/**
+ * Text-mode game wrapper — reads player input from {@code System.in} and
+ * drives the main game loop.
+ *
+ * <p>Registers a {@link CommandState#GAME_END} observer on the {@link Game} so the
+ * loop exits cleanly when any end condition (win, lose, or quit) fires, without
+ * the wrapper needing to inspect individual command results.</p>
+ *
+ * @see IGameWrapper
+ * @see Game
+ */
+public class TextGameWrapper implements IGameWrapper {
+    private final Game game;
+    private boolean gameRunning;
+    private final Scanner input;
+    /**
+     * Creates a text wrapper for the given game instance.
+     *
+     * @param game the game to drive
+     */
+    public TextGameWrapper(Game game) {
+        this.game = game;
+        input = new Scanner(System.in);
+    }
+    /**
+     * {@inheritDoc}
+     *
+     * <p>Registers a {@link CommandState#GAME_END} listener that sets
+     * {@code gameRunning} to {@code false}, then enters the read-eval-print loop.
+     * Blank lines are silently skipped. The loop exits when the game signals
+     * {@code GAME_END}.</p>
+     */
+    @Override
+    public void runGame() {
+        this.gameRunning = true;
+        game.addObserver(CommandState.GAME_END, ()->{this.gameRunning = false;});
+        game.printIntro();
+        while(this.gameRunning) {
+            System.out.print(">");
+            String input = this.input.nextLine().trim();
+            if (input.isEmpty()) continue;
+            game.sendCommand(input);
+        }
+        game.printOutro();
+
+
+    }
+}

src/main/java/cz/davza/studentadventure/interfaces/ICollectable.java

@@ -0,0 +1,39 @@
+package cz.davza.studentadventure.interfaces;
+
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+/**
+ * Marks an item as something the player can pick up from a room.
+ *
+ * <p>Items implementing this interface will be found by
+ * {@link cz.davza.studentadventure.base.RoomBase#getCollectable(String)} and can be
+ * acted on by the {@code pickup} command.</p>
+ *
+ * <p>The default {@link #Pickup} implementation adds the item directly to the
+ * provided collection. Classes can override this to produce custom pickup behaviour —
+ * for example, {@link cz.davza.studentadventure.Items.Money} overrides it to add coins
+ * directly to the player's wallet instead of occupying an inventory slot.</p>
+ *
+ * @see cz.davza.studentadventure.commands.PickupCommand
+ * @see cz.davza.studentadventure.Items.Money
+ */
+public interface ICollectable {
+
+    /**
+     * Handles the logic for picking up this item.
+     *
+     * <p>The default implementation attempts to add one instance of this item to
+     * {@code itemCollection}, printing a message if the inventory is full.</p>
+     *
+     * <p>Override this method to implement special pickup behaviour, such as
+     * adding a resource directly to the player rather than to the inventory.</p>
+     *
+     * @param itemCollection the collection to add the item into (typically the player's inventory)
+     * @param context        the current game state, providing access to the player and other data
+     * @return the number of items that could not be picked up (0 if pickup was fully successful)
+     */
+    default CommandResult onPickup(GameData context, int amount){
+        return null;
+
+    }
+}

src/main/java/cz/davza/studentadventure/interfaces/ICollection.java

@@ -0,0 +1,60 @@
+package cz.davza.studentadventure.interfaces;
+import cz.davza.studentadventure.objects.ItemStack;
+/**
+ * Contract for a fixed-size, slot-based item collection.
+ *
+ * <p>Implementations manage a collection of {@link ItemStack} entries, keyed by item code.
+ * Items are stacked automatically up to their {@link IItem#getBulk()} limit,
+ * and any items that cannot fit are returned as a leftover count from {@link #Add}.</p>
+ *
+ * <p>Used by both {@link cz.davza.studentadventure.objects.PlayerInventory} and
+ * {@link cz.davza.studentadventure.objects.RoomItems}.</p>
+ *
+ * @param <T> the type of item this collection holds, must extend {@link IItem}
+ *
+ * @see cz.davza.studentadventure.base.ItemCollectionBase
+ * @see ItemStack
+ */
+public interface ICollection<T> {
+    /**
+     * Adds the specified quantity of an item to the collection.
+     *
+     * <p>The method first attempts to top up any existing stacks of the same item
+     * code, then fills empty slots with new stacks. Items that cannot fit due to
+     * capacity limits are returned as a remainder.</p>
+     *
+     * @param item  the item to add
+     * @param count the number of items to add
+     * @return the number of items that could not be added (0 if all were added)
+     */
+    int Add(T item, int count);
+    /**
+     * Removes a specified number of items from the slot at the given index.
+     *
+     * <p>If {@code count} is greater than or equal to the stack size, the slot
+     * is cleared entirely. If the index is out of bounds or the slot is empty,
+     * the call is silently ignored.</p>
+     *
+     * @param code the items code
+     * @param count the number of items to remove
+     */
+    void Remove(String code, int count);
+
+
+    /**
+     * Returns the overall capacity the collection can hold
+     *
+     * @return Collections bulk capacity
+     */
+    int GetCapacity();
+    /**
+     * Empties collection of all items and resets used capacity
+     */
+    void Empty();
+    /**
+     * Returns the remaining capacity of the collection
+     *
+     * @return Collections remaining bulk capacity (how much can still be added)
+     */
+    int GetRemainingCapacity();
+}

src/main/java/cz/davza/studentadventure/interfaces/ICommand.java

@@ -0,0 +1,32 @@
+package cz.davza.studentadventure.interfaces;
+
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+/**
+ * Contract for all executable player commands.
+ *
+ * <p>Every command the player can type must implement this interface.
+ * Commands are discovered at runtime via the {@link cz.davza.studentadventure.annotations.CommandKeyword}
+ * annotation and instantiated by the {@link cz.davza.studentadventure.managers.CommandFactory}.</p>
+ *
+ * <p>The {@link GameData} context passed to {@link #Execute(GameData)} provides access
+ * to everything a command might need — the player, the current room, game time, etc.</p>
+ *
+ * @see cz.davza.studentadventure.base.CommandBase
+ * @see cz.davza.studentadventure.managers.CommandFactory
+ * @see cz.davza.studentadventure.managers.CommandManager
+ */
+public interface ICommand {
+    /**
+     * Executes this command using the provided game context.
+     *
+     * <p>Implementations are responsible for printing any relevant feedback to
+     * {@code System.out} and returning an appropriate {@link CommandState} to
+     * allow the game loop to react (e.g. changing rooms, ending the game).</p>
+     *
+     * @param gameData the current game state, including player, room, and time
+     * @return a {@link CommandState} describing the outcome of the command
+     */
+    public CommandResult Execute(GameData gameData);
+}

src/main/java/cz/davza/studentadventure/interfaces/ICommandable.java

@@ -0,0 +1,30 @@
+package cz.davza.studentadventure.interfaces;
+
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+/**
+ * Contract for objects that can receive and handle raw player input.
+ *
+ * <p>Implemented by {@link cz.davza.studentadventure.objects.Game} (the main dispatcher)
+ * and by items or rooms that manage their own sub-interaction loops
+ * (e.g. {@link cz.davza.studentadventure.Items.Computer},
+ * {@link cz.davza.studentadventure.rooms.ExamRoomRoom}).</p>
+ *
+ * <p>When a command returns {@link cz.davza.studentadventure.enums.CommandState#ACTION_PENDING},
+ * the embedded {@code ICommandable} becomes the active handler for subsequent
+ * player input until it returns
+ * {@link cz.davza.studentadventure.enums.CommandState#ACTION_RESUMED}.</p>
+ *
+ * @see cz.davza.studentadventure.objects.Game
+ * @see cz.davza.studentadventure.Items.Computer
+ */
+public interface ICommandable {
+    /**
+     * Handles a single line of raw player input.
+     *
+     * @param command the text typed by the player (already trimmed)
+     * @param context the current game state
+     * @return a {@link CommandResult} describing the outcome
+     */
+    CommandResult handleCommand(String command, GameData context);
+}

src/main/java/cz/davza/studentadventure/interfaces/IConsumable.java

@@ -0,0 +1,32 @@
+package cz.davza.studentadventure.interfaces;
+
+import cz.davza.studentadventure.objects.Player;
+/**
+ * Marks an item as consumable by the player.
+ *
+ * <p>Items implementing this interface can be used via the {@code consume} command.
+ * On consumption, {@link #consume(Player)} is called to apply the item's effect,
+ * and the item is then removed from the inventory slot.</p>
+ *
+ * <p>Examples include {@link cz.davza.studentadventure.Items.EnergyDrink} (restores energy)
+ * and {@link cz.davza.studentadventure.Items.MouldyCheese} (reduces energy).</p>
+ *
+ * @see cz.davza.studentadventure.commands.ConsumeCommand
+ */
+public interface IConsumable {
+    /**
+     * Applies this item's effect to the given player.
+     *
+     * <p>This is called before the item is removed from the inventory, so
+     * implementations can safely read or modify player stats here.</p>
+     *
+     * @param player the player consuming this item
+     */
+    void consume(Player player);
+    /**
+     * Returns the message displayed to the player after consuming this item.
+     *
+     * @return a non-null feedback string (e.g. {@code "You skull the energy drink. Energy +40."})
+     */
+    String getConsumeMessage();
+}

src/main/java/cz/davza/studentadventure/interfaces/IGameWrapper.java

@@ -0,0 +1,19 @@
+package cz.davza.studentadventure.interfaces;
+
+/**
+ * Contract for classes that wrap the game loop for a specific UI mode.
+ *
+ * <p>A wrapper owns the read-eval-print loop for one display medium. The text wrapper
+ * ({@link cz.davza.studentadventure.gameWrappers.TextGameWrapper}) reads from
+ * {@code System.in}; a GUI wrapper would read from JavaFX events instead.
+ * Both delegate actual command processing to {@link cz.davza.studentadventure.objects.Game}.</p>
+ *
+ * @see cz.davza.studentadventure.gameWrappers.TextGameWrapper
+ */
+public interface IGameWrapper {
+    /**
+     * Starts the game loop and blocks until the session ends.
+     * Prints the intro, processes player commands in a loop, then prints the outro.
+     */
+    void runGame();
+}

src/main/java/cz/davza/studentadventure/interfaces/IInteractable.java

@@ -0,0 +1,32 @@
+package cz.davza.studentadventure.interfaces;
+
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+/**
+ * Marks an item as interactable by the player.
+ *
+ * <p>Items implementing this interface are found by
+ * {@link cz.davza.studentadventure.base.RoomBase#getInteractable(String)} and can be
+ * used via the {@code interact} command. Unlike consumables, interactable items
+ * remain in the room after use and may contain their own inner event loop
+ * (e.g. {@link cz.davza.studentadventure.Items.Computer}).</p>
+ *
+ * @see cz.davza.studentadventure.commands.InteractCommand
+ * @see cz.davza.studentadventure.Items.Bed
+ * @see cz.davza.studentadventure.Items.Computer
+ * @see cz.davza.studentadventure.Items.StickyNote
+ */
+public interface IInteractable {
+    /**
+     * Handles player interaction with this item.
+     *
+     * <p>Implementations should print feedback directly to {@code System.out} where
+     * needed and return any final message string — or an empty string if the output
+     * was already printed internally. The returned string is printed by
+     * {@link cz.davza.studentadventure.commands.InteractCommand} only if non-empty.</p>
+     *
+     * @param context the current game state
+     * @return a result message, or an empty string if no further output is needed
+     */
+    public CommandResult Interact(GameData context);
+}

src/main/java/cz/davza/studentadventure/interfaces/IItem.java

@@ -0,0 +1,40 @@
+package cz.davza.studentadventure.interfaces;
+
+/**
+ * Base contract for all items in the game world.
+ *
+ * <p>Every item — whether collectable, consumable, or interactable — must implement
+ * this interface. It provides the minimum identity information needed by the inventory
+ * and room item systems to store and retrieve items.</p>
+ *
+ * <p>Items are distinguished from one another by their {@link #getCode()} value, which
+ * is used for lookups throughout the codebase (e.g. {@code "book"}, {@code "energy_drink"}).</p>
+ *
+ * @see cz.davza.studentadventure.base.ItemBase
+ * @see ICollectable
+ * @see IConsumable
+ * @see IInteractable
+ */
+public interface IItem {
+    /**
+     * Returns the unique identifier code for this item type.
+     *
+     * <p>Codes are lowercase strings used by commands and room lookups
+     * (e.g. {@code "book"}, {@code "energy_drink"}, {@code "mouldy_cheese"}).
+     * Two item instances with the same code are treated as the same item type
+     * by the stacking system.</p>
+     *
+     * @return the item's unique code string
+     */
+    String getCode();
+    /**
+     * Returns the maximum number of this item that can be held in a single
+     * {@link cz.davza.studentadventure.objects.ItemStack}.
+     *
+     * <p>Items with a max stack of 1 occupy their own slot per instance.
+     * Higher values allow multiple items to share a slot up to the given limit.</p>
+     *
+     * @return the maximum stack size, always greater than zero
+     */
+    int getBulk();
+}

src/main/java/cz/davza/studentadventure/interfaces/IObservable.java

@@ -0,0 +1,31 @@
+package cz.davza.studentadventure.interfaces;
+
+import cz.davza.studentadventure.enums.CommandState;
+/**
+ * Contract for objects that broadcast state-change events to registered listeners.
+ *
+ * <p>Part of the Observer pattern. Classes that produce events (e.g.
+ * {@link cz.davza.studentadventure.objects.Game},
+ * {@link cz.davza.studentadventure.objects.PlayerInventory}) implement this interface.
+ * Interested parties register via {@link #addObserver} and receive callbacks
+ * via {@link IObserver#update()} when the relevant {@link CommandState} fires.</p>
+ *
+ * @see IObserver
+ * @see cz.davza.studentadventure.base.ObservableBase
+ */
+public interface IObservable {
+    /**
+     * Registers {@code o} to be notified whenever {@code registeringState} is fired.
+     *
+     * @param registeringState the event the observer wants to listen for
+     * @param o                the observer to register
+     */
+    void addObserver(CommandState registeringState, IObserver o);
+    /**
+     * Notifies all observers registered for {@code notifiedState}.
+     * If no observers are registered for the state, the call is silently ignored.
+     *
+     * @param notifiedState the event that has occurred
+     */
+    void notifyObservers(CommandState notifiedState);
+}

src/main/java/cz/davza/studentadventure/interfaces/IObserver.java

@@ -0,0 +1,19 @@
+package cz.davza.studentadventure.interfaces;
+/**
+ * Callback interface for the Observer pattern.
+ *
+ * <p>Implement this interface and register with an {@link IObservable} to receive
+ * notifications when a particular {@link cz.davza.studentadventure.enums.CommandState}
+ * event fires. The {@link #update()} method carries no parameters — the observer
+ * is expected to know the context from the object it registered on, or to query
+ * shared state when called.</p>
+ *
+ * @see IObservable
+ * @see cz.davza.studentadventure.base.ObservableBase
+ */
+public interface IObserver {
+    /**
+     * Called by the observed object when the event this observer is registered for occurs.
+     */
+    void update();
+}

src/main/java/cz/davza/studentadventure/interfaces/IOutputSink.java

@@ -0,0 +1,42 @@
+package cz.davza.studentadventure.interfaces;
+/**
+ * Abstraction over the destination for all game text output.
+ *
+ * <p>Decouples the game logic from the display medium. The text-mode implementation
+ * ({@link cz.davza.studentadventure.outputsinks.TextOutputSink}) buffers output and
+ *
+ * <p>All game output should go through this interface rather than calling
+ * {@code System.out} directly, so the game remains display-agnostic.</p>
+ *
+ * @see cz.davza.studentadventure.outputsinks.TextOutputSink
+ */
+public interface IOutputSink {
+    /**
+     * Appends {@code text} to the internal buffer without a trailing newline.
+     *
+     * @param text the text to buffer
+     */
+    void buffer(String text);
+    /**
+     * Flushes the internal buffer to the underlying output medium and clears it.
+     * Call this after a complete logical unit of output (e.g. after processing
+     * each command) to ensure text appears promptly.
+     */
+    void flush();
+    /**
+     * Convenience method — delegates to {@link #buffer(String)}.
+     *
+     * @param text the text to append
+     */
+    default void append(String text) {
+        buffer(text);
+    }
+    /**
+     * Buffers {@code text} followed by a newline character.
+     *
+     * @param text the line of text to write
+     */
+    default void writeLine(String text) {
+        buffer(text + "\n");
+    }
+}

src/main/java/cz/davza/studentadventure/main/Main.java

@@ -0,0 +1,19 @@
+package cz.davza.studentadventure.main;
+
+import cz.davza.studentadventure.gameWrappers.TextGameWrapper;
+import cz.davza.studentadventure.interfaces.IGameWrapper;
+import cz.davza.studentadventure.objects.Game;
+import cz.davza.studentadventure.outputsinks.TextOutputSink;
+
+public class Main {
+    /**
+     * Application entry point.
+     *
+     * @param args command-line arguments; pass {@code "text"} to start in text mode
+     */
+    public static void main(String[] args) {
+        Game game = new Game(new TextOutputSink());
+        IGameWrapper gameWrapper = new TextGameWrapper(game);
+        gameWrapper.runGame();
+    }
+}

src/main/java/cz/davza/studentadventure/managers/CommandFactory.java

@@ -0,0 +1,99 @@
+package cz.davza.studentadventure.managers;
+
+import cz.davza.studentadventure.annotations.CommandKeyword;
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.commands.*;
+import cz.davza.studentadventure.interfaces.ICommand;
+import org.reflections.Reflections;
+
+
+import java.util.*;
+
+
+/**
+ * Discovers and instantiates {@link CommandBase} subclasses at runtime.
+ *
+ * <p>On first use, {@code CommandFactory} scans the {@code cz.davza.studentadventure.commands}
+ * package for compiled {@code .class} files annotated with
+ * {@link cz.davza.studentadventure.annotations.CommandKeyword}. Each discovered class is
+ * registered in an internal map keyed by its keyword string.</p>
+ *
+ * <p>Subsequent calls to {@link #createCommand} instantiate the registered class
+ * via its no-arg constructor, inject the provided params, and return the result.
+ * The scan only runs once per factory instance (guarded by {@link #loaded}).</p>
+ *
+ * <p><strong>Note:</strong> {@code registry} and {@code loaded} are instance fields.
+ * For efficiency in long-running sessions consider making them {@code static} so the
+ * scan is shared across all factory instances.</p>
+ *
+ * @see CommandManager
+ * @see cz.davza.studentadventure.annotations.CommandKeyword
+ */
+public class CommandFactory {
+    private static final String COMMANDS_PACKAGE = "cz.davza.studentadventure.commands";
+    private static final Map<String, Class<? extends CommandBase>> REGISTRY = new HashMap<>();
+    private static boolean loaded = false;
+    /**
+     * Scans the commands package and populates the registry.
+     * Does nothing if the registry has already been loaded.
+     *
+     * <p>Any class in the package that is annotated with
+     * {@link cz.davza.studentadventure.annotations.CommandKeyword} is registered under
+     * its keyword value. Errors are printed to {@code System.err} and the scan
+     * is considered complete (commands found before the error remain registered).</p>
+     */
+    static {
+        try {
+            Reflections reflections = new Reflections(COMMANDS_PACKAGE);
+            Set<Class<?>> annotatedClasses = reflections.getTypesAnnotatedWith(CommandKeyword.class);
+
+            for (Class<?> clazz : annotatedClasses) {
+                // Defensive design: ensure the annotated class actually extends CommandBase
+                if (CommandBase.class.isAssignableFrom(clazz)) {
+                    CommandKeyword annotation = clazz.getAnnotation(CommandKeyword.class);
+                    String keyword = annotation.value().toLowerCase().trim();
+
+                    Class<? extends CommandBase> commandClass = (Class<? extends CommandBase>) clazz;
+
+                    REGISTRY.put(keyword, commandClass);
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Instantiates the command class registered under {@code keyword} and
+     * sets its parameter list.
+     *
+     * @param keyword the command keyword (case-insensitive)
+     * @param params  the tokenised argument list to pass to the command
+     * @return a configured {@link CommandBase} ready for execution,
+     *         or {@code null} if no command is registered under {@code keyword}
+     */
+    public CommandBase createCommand(String keyword, List<String> params) {
+        Class<?> clazz = REGISTRY.get(keyword.toLowerCase());
+        if (clazz == null) return null;
+
+        try {
+            CommandBase command = (CommandBase) clazz
+                    .getDeclaredConstructor()
+                    .newInstance();
+            command.setParams(params);
+            return command;
+        } catch (Exception e) {
+            System.err.println("Failed to instantiate command: " + keyword);
+            return null;
+        }
+    }
+    /**
+     * Returns whether a command is registered under the given keyword.
+     *
+     * @param keyword the keyword to check (case-insensitive)
+     * @return {@code true} if a command class is registered for this keyword
+     */
+    public boolean isRegistered(String keyword) {
+        return REGISTRY.containsKey(keyword.toLowerCase());
+    }
+}

src/main/java/cz/davza/studentadventure/managers/CommandManager.java

@@ -0,0 +1,47 @@
+package cz.davza.studentadventure.managers;
+
+import cz.davza.studentadventure.base.CommandBase;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
+/**
+ * Parses raw player input into an executable {@link CommandBase}.
+ *
+ * <p>Input is tokenised by whitespace; the first token is treated as the command
+ * keyword and the remainder become the parameter list. The keyword is checked
+ * against the provided {@code allowedCommands} list before a command is created —
+ * this allows rooms to restrict which commands are valid in their context.</p>
+ *
+ * <p>Actual command instantiation is delegated to a {@link CommandFactory}.</p>
+ *
+ * @see CommandFactory
+ */
+public class CommandManager {
+    private static final CommandFactory factory = new CommandFactory();
+    /**
+     * Parses {@code userInput} and returns a ready-to-execute command if the keyword
+     * is in {@code allowedCommands}, otherwise returns {@code null}.
+     *
+     * <p>The returned command already has its parameter list set via
+     * {@link CommandBase#setParams(List)}.</p>
+     *
+     * @param userInput       the raw string typed by the player
+     * @param allowedCommands the set of command keywords valid in the current context
+     * @return a configured {@link CommandBase}, or {@code null} if the input was blank
+     *         or the keyword was not allowed
+     */
+    public static CommandBase parseCommand(String userInput, List<String> allowedCommands) {
+        if (userInput == null || userInput.trim().isEmpty()) return null;
+
+        String[] parts = userInput.trim().toLowerCase().split("\\s+");
+        String keyword = parts[0];
+
+        if (!allowedCommands.contains(keyword)) return null;
+
+        List<String> params = new ArrayList<>(
+                Arrays.asList(parts).subList(1, parts.length)
+        );
+
+        return factory.createCommand(keyword, params);
+    }
+}

src/main/java/cz/davza/studentadventure/objects/CommandResult.java

@@ -0,0 +1,222 @@
+package cz.davza.studentadventure.objects;
+
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.interfaces.ICommandable;
+/**
+ * Immutable value object returned by every command execution.
+ *
+ * <p>Carries three pieces of information:</p>
+ * <ul>
+ *   <li>A {@link CommandState} that tells the game loop how to react.</li>
+ *   <li>A message string to display to the player (may be empty).</li>
+ *   <li>An optional {@link ICommandable} handler for multi-turn interactions
+ *       (e.g. the Computer password prompt). When non-null, the game loop
+ *       redirects subsequent player input to this handler instead of the
+ *       main command dispatcher.</li>
+ * </ul>
+ *
+ * <p>Instances are created exclusively through the static factory methods
+ * (e.g. {@link #success(String)}, {@link #failed(String)}) — the constructor
+ * is private to enforce this.</p>
+ *
+ * @see CommandState
+ * @see cz.davza.studentadventure.interfaces.ICommand
+ */
+
+public class CommandResult {
+    private final CommandState resultState;
+    private final String resultMessage;
+    private final ICommandable newCommandHandler;
+
+    private CommandResult(CommandState resultState, String resultMessage, ICommandable newCommandHandler){
+        this.resultState = resultState;
+        this.resultMessage = resultMessage;
+        this.newCommandHandler = newCommandHandler;
+
+    }
+    // ── Handler switching ─────────────────────────────────────────────
+
+    /**
+     * Creates a result that suspends normal command processing and routes
+     * subsequent input to {@code nextHandler} until it returns
+     * {@link #actionResumed(String)}.
+     *
+     * @param nextHandler the handler to receive the next player input
+     * @param output      the message shown when the pending state begins
+     * @return a new {@link CommandState#ACTION_PENDING} result
+     */
+    public static CommandResult actionPending(ICommandable nextHandler, String output) {
+        return new CommandResult(CommandState.ACTION_PENDING, output, nextHandler);
+    }
+    /**
+     * Creates a result that ends a pending sub-interaction and returns
+     * control to the main game loop.
+     *
+     * @param output the message shown when control is returned
+     * @return a new {@link CommandState#ACTION_RESUMED} result
+     */
+    public static CommandResult actionResumed(String output) {
+        return new CommandResult(CommandState.ACTION_RESUMED, output, null);
+    }
+    // ── General purpose ──────────────────────────────────────────────
+    /**
+     * Creates a successful result with a player-facing message.
+     *
+     * @param output the message to display
+     * @return a new {@link CommandState#SUCCESS} result
+     */
+    public static CommandResult success(String output) {
+        return new CommandResult(CommandState.SUCCESS, output, null);
+    }
+    /**
+     * Creates a successful result with no message.
+     *
+     * @return a new {@link CommandState#SUCCESS} result with an empty message
+     */
+    public static CommandResult success() {
+        return new CommandResult(CommandState.SUCCESS, "", null);
+    }
+    /**
+     * Creates a warning result — the command ran but something was noteworthy.
+     *
+     * @param output the warning message to display
+     * @return a new {@link CommandState#WARNING} result
+     */
+    public static CommandResult warning(String output) {
+        return new CommandResult(CommandState.WARNING, output, null);
+    }
+    /**
+     * Creates a failure result — the command could not be completed.
+     *
+     * @param output the reason shown to the player
+     * @return a new {@link CommandState#FAILED} result
+     */
+    public static CommandResult failed(String output) {
+        return new CommandResult(CommandState.FAILED, output, null);
+    }
+    /**
+     * Creates an invalid-parameters result with no message.
+     * The game loop replaces the empty message with a generic hint.
+     *
+     * @return a new {@link CommandState#INVALID_PARAMS} result
+     */
+    public static CommandResult invalidParams() {
+        return new CommandResult(CommandState.INVALID_PARAMS, "", null);
+    }
+
+    // ── Item specific ─────────────────────────────────────────────────
+    /**
+     * Creates a result indicating the player's inventory is full.
+     *
+     * @param output the message describing what could not be added
+     * @return a new {@link CommandState#INVENTORY_FULL} result
+     */
+    public static CommandResult inventoryFull(String output) {
+        return new CommandResult(CommandState.INVENTORY_FULL, output, null);
+    }
+    /**
+     * Creates a result indicating the target item was not found.
+     *
+     * @param output the message shown to the player
+     * @return a new {@link CommandState#ITEM_NOT_FOUND} result
+     */
+    public static CommandResult itemNotFound(String output) {
+        return new CommandResult(CommandState.ITEM_NOT_FOUND, output, null);
+    }
+    /**
+     * Creates a result indicating the item cannot be picked up.
+     *
+     * @param output the message shown to the player
+     * @return a new {@link CommandState#ITEM_NOT_COLLECTABLE} result
+     */
+    public static CommandResult itemNotCollectable(String output) {
+        return new CommandResult(CommandState.ITEM_NOT_COLLECTABLE, output, null);
+    }
+    /**
+     * Creates a result indicating the item cannot be interacted with.
+     *
+     * @param output the message shown to the player
+     * @return a new {@link CommandState#ITEM_NOT_INTERACTABLE} result
+     */
+    public static CommandResult itemNotInteractable(String output) {
+        return new CommandResult(CommandState.ITEM_NOT_INTERACTABLE, output, null);
+    }
+
+    // ── Navigation ────────────────────────────────────────────────────
+    /**
+     * Creates a result indicating the player successfully moved to a new room.
+     * The game loop will commit the pending room change and describe the new room.
+     *
+     * @param output the message shown after the move (may be empty)
+     * @return a new {@link CommandState#ROOM_CHANGED} result
+     */
+    public static CommandResult roomChanged(String output) {
+        return new CommandResult(CommandState.ROOM_CHANGED, output, null);
+    }
+
+    // ── Handler switching ─────────────────────────────────────────────
+    /**
+     * Creates a result that changes the active command handler without changing state.
+     *
+     * @param nextHandler the new handler to use for subsequent input
+     * @param output      the message shown when the switch occurs
+     * @return a new {@link CommandState#SUCCESS} result with a handler attached
+     */
+    public static CommandResult changeHandler(ICommandable nextHandler, String output) {
+        return new CommandResult(CommandState.SUCCESS, output, nextHandler);
+    }
+
+    // ── Game ending ───────────────────────────────────────────────────
+    /**
+     * Creates a game-over result ending the session in defeat.
+     *
+     * @param output the final message shown to the player
+     * @return a new {@link CommandState#GAME_OVER} result
+     */
+
+    public static CommandResult gameOver(String output) {
+        return new CommandResult(CommandState.GAME_OVER, output, null);
+    }
+    /**
+     * Creates a game-win result ending the session in victory.
+     *
+     * @param output the final message shown to the player
+     * @return a new {@link CommandState#GAME_WIN} result
+     */
+    public static CommandResult gameWin(String output) {
+        return new CommandResult(CommandState.GAME_WIN, output, null);
+    }
+    /**
+     * Creates a generic game-end result (used for graceful shutdown, e.g. quit).
+     *
+     * @param output the final message shown to the player
+     * @return a new {@link CommandState#GAME_END} result
+     */
+    public static CommandResult gameEnd(String output){
+        return new CommandResult(CommandState.GAME_END,  output, null);
+    }
+    /**
+     * Returns the outcome state of this result, used by the game loop to branch.
+     *
+     * @return the {@link CommandState}
+     */
+    public CommandState getResultState() {
+        return resultState;
+    }
+    /**
+     * Returns the message to display to the player.
+     *
+     * @return the result message; never {@code null}, may be empty
+     */
+    public String getResultMessage() {
+        return resultMessage;
+    }
+    /**
+     * Returns the optional next command handler for multi-turn interactions.
+     *
+     * @return the next {@link ICommandable}, or {@code null} for single-turn results
+     */
+    public ICommandable getNewCommandHandler() {
+        return newCommandHandler;
+    }
+}

src/main/java/cz/davza/studentadventure/objects/Game.java

@@ -0,0 +1,256 @@
+package cz.davza.studentadventure.objects;
+
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.base.ObservableBase;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.interfaces.ICommandable;
+import cz.davza.studentadventure.interfaces.IOutputSink;
+import cz.davza.studentadventure.managers.CommandManager;
+/**
+ * Central game controller — the single entry point for all player input.
+ *
+ * <p>Extends {@link ObservableBase} so that wrappers (text, GUI) can register
+ * listeners for lifecycle events such as {@link CommandState#GAME_END}. Implements
+ * {@link ICommandable} so the same {@link #handleCommand} interface is shared with
+ * sub-handlers like {@link cz.davza.studentadventure.Items.Computer}.</p>
+ *
+ * <h2>Command routing</h2>
+ * <p>Each call to {@link #sendCommand(String)} is first checked for a quit request,
+ * then forwarded to {@link #currentCommandHandler}. During normal play that handler
+ * is {@code this} (the Game). When a command returns
+ * {@link CommandState#ACTION_PENDING}, the embedded {@link ICommandable} becomes
+ * the active handler until it returns {@link CommandState#ACTION_RESUMED}.</p>
+ *
+ * <h2>Game-over conditions</h2>
+ * <ul>
+ *   <li>Player stress reaches 100.</li>
+ *   <li>The exam deadline passes without taking the exam.</li>
+ *   <li>Certain commands return {@link CommandState#GAME_OVER} directly.</li>
+ * </ul>
+ *
+ * @see GameData
+ * @see CommandManager
+ * @see cz.davza.studentadventure.interfaces.IOutputSink
+ */
+public class Game extends ObservableBase implements ICommandable {
+    private static final int    INVENTORY_SIZE  = 20;
+    private boolean gameOver = false;
+    private GameData context;
+    private final IOutputSink output;
+    private ICommandable currentCommandHandler;
+
+    /**
+     * Creates a new game instance, initialises all game state, and sets up the world map.
+     *
+     * @param output the sink that receives all text to display (text console or GUI)
+     */
+
+    public Game(IOutputSink output)
+    {
+        this.currentCommandHandler = this;
+        this.output = output;
+        setupContext();
+    }
+    /**
+     * Initialises the player, map, and time, then wires them together into a {@link GameData}.
+     */
+    private void setupContext() {
+        Player player = new Player("Student", INVENTORY_SIZE);
+        GameMap map  = new GameMap();
+        GameTime  time = new GameTime();
+        context = new GameData(player, map,time);
+    }
+
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>Parses {@code input} against the currently allowed commands and executes the
+     * matching {@link CommandBase}. Returns a failure result if the command is unknown
+     * or not allowed in the current room.</p>
+     */
+    @Override
+    public CommandResult handleCommand(String input, GameData context) {
+        CommandBase command = CommandManager.parseCommand(input, context.getAllowedCommands());
+        if (command == null) {
+            return CommandResult.failed("You can't do that here.");
+        }
+        return command.Execute(context);
+    }
+
+    /**
+     * Processes a single line of player input and returns the resulting {@link CommandResult}.
+     *
+     * <p>This is the primary method called by game wrappers. It handles:</p>
+     * <ul>
+     *   <li>Rejecting input after the game has ended.</li>
+     *   <li>The {@code quit} command (immediately ends the session).</li>
+     *   <li>Routing to the active {@link ICommandable} handler.</li>
+     *   <li>State transitions: room changes, handler switches, game-over/win checks.</li>
+     *   <li>Time-based deadline enforcement.</li>
+     *   <li>Stress-based game-over enforcement.</li>
+     *   <li>Sleep-deprivation warnings.</li>
+     * </ul>
+     *
+     * <p>All output is written to the {@link IOutputSink} provided at construction.</p>
+     *
+     * @param input the raw string typed by the player
+     * @return the final {@link CommandResult} after all post-processing
+     */
+    public CommandResult sendCommand(String input){
+        if (gameOver){
+            output.writeLine("GAME OVER - The game is already over.");
+            return CommandResult.gameOver("The game is already over");
+        }
+        if (input.equalsIgnoreCase("quit")) {
+            output.writeLine("You give up and drop out.");
+            notifyObservers(CommandState.GAME_END);
+            gameOver = true;
+            return CommandResult.gameOver("You give up and drop out.");
+        }
+
+        // Delegate to current handler if not Game itself
+        CommandResult result = currentCommandHandler.handleCommand(input, context);
+
+        // Handle handler switching
+        switch (result.getResultState()) {
+            case ACTION_PENDING:
+                currentCommandHandler = result.getNewCommandHandler();
+                break;
+
+            case ACTION_RESUMED:
+                currentCommandHandler = this;
+                if ( context.getMap().hasPendingRoomChange()) {
+                    context.getMap().commitRoomChange();
+                    String roomDesc = context.getMap().getCurrentRoom().describe();
+                    context.updateAllowedCommands();
+                    result =  CommandResult.success(
+                            result.getResultMessage() + "\n" +
+                                    roomDesc + "\n" +
+                                    "Time: " + context.getTime());
+                }
+                break;
+
+            case ROOM_CHANGED:
+                if (context.getMap().hasPendingRoomChange()) {
+                    context.getMap().commitRoomChange();
+                    String roomDesc = context.getMap().getCurrentRoom().describe();
+                    context.updateAllowedCommands();
+                    result =  CommandResult.roomChanged(
+                            result.getResultMessage() + "\n" +
+                                    roomDesc + "\n" +
+                                    "Time: " + context.getTime());
+                }
+                break;
+
+            case GAME_WIN:
+                notifyObservers(CommandState.GAME_END);
+                gameOver = true;
+                result =  CommandResult.gameWin(
+                        result.getResultMessage() + "\n" +
+                                "Good job! You have successfully survived finals week!\n" );
+                break;
+
+
+            case GAME_OVER:
+                notifyObservers(CommandState.GAME_END);
+                gameOver = true;
+                result =  CommandResult.gameOver(
+                        result.getResultMessage() + "\n" );
+                break;
+
+            case INVALID_PARAMS:
+                result =  CommandResult.failed(
+                        result.getResultMessage().isEmpty()
+                                ? "That command wasn't quite right. Type 'help' for guidance."
+                                : result.getResultMessage());
+                break;
+
+            default:
+                break;
+        }
+        printDeprivationWarning();
+        // check if time is over
+        if(this.context.getTime().isPastDeadline()){
+            output.writeLine("\nThe school bell rings.");
+            output.writeLine("You look down at your watch and realise it's too late.");
+            output.writeLine("\nGAME OVER - Didn't take exam in time.");
+            gameOver = true;
+            notifyObservers(CommandState.GAME_END);
+            result =  CommandResult.gameOver("Didn't take exam in time.");
+        }
+
+
+        // Stress game over check
+        if (context.getPlayer().getStress().getValue() >= 100) {
+            output.writeLine("\nThe pressure becomes too much.");
+            output.writeLine("You have a breakdown.");
+            output.writeLine("\nGAME OVER - Stress reached 100.");
+            notifyObservers(CommandState.GAME_END);
+            gameOver = true;
+            result =  CommandResult.gameOver("Stress reached 100.");
+        }
+        output.writeLine(result.getResultMessage());
+        this.output.flush();
+        return result;
+    }
+
+    /**
+     * Prints a warning to the output sink if the player is tired or severely deprived.
+     * Called automatically at the end of every {@link #sendCommand} cycle.
+     */
+    private void printDeprivationWarning() {
+        switch (context.getPlayer().getDeprivationState()) {
+            case TIRED:
+                output.writeLine("⚠  You're getting tired. Consider sleeping soon.");
+                break;
+            case DEPRIVED:
+                output.writeLine(String.format(
+                        "⚠  You're exhausted. Everything costs more. (deprivation multiplier: %.1fx)",
+                        context.getPlayer().getDeprivationMultiplier()));
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * Prints the opening title card and initial room description to the output sink.
+     * Called once by the game wrapper before the main loop begins.
+     */
+    public void printIntro() {
+        output.writeLine("""
+                ╔══════════════════════════════════════╗
+                ║    STUDENT ADVENTURE - Finals week   ║
+                ║      Can you survive exam week?      ║
+                ╚══════════════════════════════════════╝
+                
+                You wake up on Day 1. The exam is on Day 7 at 09:00.
+                You have 6 days to prepare. Good luck.
+                """);
+        output.writeLine(context.getMap().getCurrentRoom().describe());
+        output.writeLine("Time: " + context.getTime());
+        output.writeLine("Type 'help' for a list of commands.\n");
+        output.flush();
+    }
+    /**
+     * Prints a closing message after the game session has ended.
+     * Called once by the game wrapper after the main loop exits.
+     */
+    public void printOutro(){
+        output.writeLine("""
+               Thanks for playing STUDENT ADVENTURE - Finals week \n""");
+    }
+    /**
+     * Returns the current game context (player, map, time).
+     *
+     * @return the active {@link GameData}
+     */
+    public GameData getContext() {
+        return context;
+    }
+
+
+
+
+}

src/main/java/cz/davza/studentadventure/objects/GameData.java

@@ -0,0 +1,58 @@
+package cz.davza.studentadventure.objects;
+
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Immutable context object passed to every command during execution.
+ *
+ * <p>{@code GameData} is the single access point that commands use to read and
+ * modify the game state. It holds references to the {@link Player}, the
+ * {@link GameMap}, the {@link Game} instance (for things
+ * like room transitions and global commands), and the {@link GameTime} clock.</p>
+ *
+ * <p>The object itself is created once in {@link Game#setupContext()} and reused throughout
+ * the session.
+ */
+public class GameData {
+    private final Player player;
+    private final GameMap map;
+    private final GameTime time;
+    private final String computerPassword = "java123";
+    private static final List<String> GLOBAL_COMMANDS = List.of("inventory", "stats", "consume", "describe", "time","help","availablecommands");
+    private final List<String> allowedCommands = new ArrayList<>();
+    /**
+     * Constructs a new game context.
+     *
+     * @param player      the player character
+     * @param map         the world map
+     * @param time        the game clock
+     */
+    public GameData(Player player, GameMap map, GameTime time) {
+        this.player = player;
+        this.map = map;
+        this.time = time;
+        map.setupMap(this);
+        updateAllowedCommands();
+
+    }
+    /** @return the game clock */
+    public GameTime getTime() { return time; }
+    /** @return the player character */
+    public Player getPlayer() { return player; }
+    /** @return the Games Map with information about where the player is and can go */
+    public  GameMap getMap() { return map; }
+    /** @return the computer password*/
+    public String getComputerPassword() {
+        return computerPassword;
+    }
+    public void updateAllowedCommands(){
+        allowedCommands.clear();
+        allowedCommands.addAll(this.map.getCurrentRoom().getAllowedCommands());
+        allowedCommands.addAll(GLOBAL_COMMANDS);
+    }
+    public List<String> getAllowedCommands() {
+        return allowedCommands;
+    }
+}

src/main/java/cz/davza/studentadventure/objects/GameMap.java

@@ -0,0 +1,125 @@
+package cz.davza.studentadventure.objects;
+
+import cz.davza.studentadventure.base.ObservableBase;
+import cz.davza.studentadventure.base.RoomBase;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.rooms.*;
+
+import java.util.HashMap;
+import java.util.Map;
+/**
+ * Manages the world map — the set of rooms and transitions between them.
+ *
+ * <p>Extends {@link ObservableBase} so listeners can react to
+ * {@link CommandState#ROOM_CHANGED} events (e.g. a GUI updating its room display).</p>
+ *
+ * <h2>Room transitions</h2>
+ * <p>Room changes are two-phase to support entry conditions and sub-interactions:</p>
+ * <ol>
+ *   <li>{@link #setNextRoom(RoomBase)} — stages the destination (called by
+ *       {@link cz.davza.studentadventure.commands.WalkCommand}).</li>
+ *   <li>{@link #commitRoomChange()} — atomically swaps current → next and fires
+ *       the {@link CommandState#ROOM_CHANGED} notification (called by the game loop
+ *       in {@link Game#sendCommand(String)} once any entry checks have passed).</li>
+ * </ol>
+ *
+ * @see RoomBase
+ * @see Game
+ */
+public class GameMap extends ObservableBase {
+    private RoomBase currentRoom;
+    private RoomBase nextRoom;
+    private Map<String, RoomBase> rooms;
+
+    /**
+     * Constructs all rooms, wires up their exits, and sets the starting room.
+     * Called once from {@link GameData#GameData(Player, GameMap, GameTime)}.
+     *
+     * @param gameData the game context passed to each room constructor
+     *                 so rooms can access the computer password and other shared data
+     */
+    public void setupMap(GameData gameData) {
+        // initialize map
+        this.rooms  = new HashMap<>();
+        //        Base Rooms
+        RoomBase bedroom     = new BedroomRoom(gameData);
+        RoomBase hallway     = new HallwayRoom(gameData);
+        RoomBase studyRoom   = new StudyRoomRoom(gameData);
+        RoomBase computerLab = new ComputerLabRoom(gameData);
+        RoomBase classroom   = new ClassroomRoom(gameData);
+        RoomBase shop        = new ShopRoom(gameData);
+        RoomBase examRoom    = new ExamRoomRoom(gameData);
+
+        // wire up exits
+        bedroom.addExit(hallway);
+        hallway.addExit(bedroom);
+
+        hallway.addExit( studyRoom);
+        studyRoom.addExit( hallway);
+
+        studyRoom.addExit( computerLab);
+        computerLab.addExit( studyRoom);
+
+        computerLab.addExit(shop);
+        shop.addExit(computerLab);
+
+        hallway.addExit( classroom);
+        classroom.addExit( hallway);
+
+        classroom.addExit( examRoom);
+        examRoom.addExit( classroom);
+        // Add to list
+        rooms.put("bedroom", bedroom);
+        rooms.put("hallway", hallway);
+        rooms.put("studyroom", studyRoom);
+        rooms.put("computerlab", computerLab);
+        rooms.put("classroom", classroom);
+        rooms.put("shop", shop);
+        rooms.put("examroom", examRoom);
+
+        // Set starting room
+        this.currentRoom = bedroom;
+    }
+    /**
+     * Returns whether a room change is pending (i.e. {@link #setNextRoom} has been
+     * called but {@link #commitRoomChange} has not yet been called).
+     *
+     * @return {@code true} if a destination room is staged
+     */
+    public boolean hasPendingRoomChange() { return nextRoom != null; }
+    /**
+     * Stages the given room as the destination for the next room transition.
+     * Pass {@code null} to cancel a pending transition.
+     *
+     * @param room the destination room, or {@code null} to cancel
+     */
+    public void setNextRoom(RoomBase room) { this.nextRoom = room; }
+    /**
+     * Returns the staged destination room without committing the transition.
+     *
+     * @return the pending next room, or {@code null} if none is staged
+     */
+    public RoomBase getNextRoom()
+    {
+        return nextRoom;
+    }
+    /**
+     * Returns the room the player is currently in.
+     *
+     * @return the current {@link RoomBase}
+     */
+    public RoomBase getCurrentRoom() { return currentRoom; }
+    /**
+     * Commits the pending room transition: moves the player into the staged room,
+     * clears the pending destination, and notifies observers with
+     * {@link CommandState#ROOM_CHANGED}.
+     *
+     * <p>Should only be called when {@link #hasPendingRoomChange()} returns {@code true}.</p>
+     */
+    public void commitRoomChange() {
+        currentRoom = nextRoom;
+        nextRoom    = null;
+        notifyObservers(CommandState.ROOM_CHANGED);
+    }
+
+}

src/main/java/cz/davza/studentadventure/objects/GameTime.java

@@ -0,0 +1,71 @@
+package cz.davza.studentadventure.objects;
+/**
+ * Tracks in-game time as a day/hour pair.
+ *
+ * <p>Time starts at Day {@value #START_DAY}, {@value #START_HOUR}:00 and the exam
+ * deadline is Day {@value #DEADLINE_DAY} at {@value #DEADLINE_HOUR}:00. Hours roll
+ * over into the next day automatically. Once {@link #isPastDeadline()} returns
+ * {@code true} the game loop ends in defeat.</p>
+ */
+public class GameTime {
+    private int day;
+    private int hour;
+
+    private static final int START_DAY  = 1;
+    private static final int START_HOUR = 8;
+    private static final int DEADLINE_DAY  = 7;
+    private static final int DEADLINE_HOUR = 9;
+    private static final int HOURS_IN_DAY  = 24;
+    /**
+     * Initialises the clock to Day {@value #START_DAY}, {@value #START_HOUR}:00.
+     */
+    public GameTime() {
+        this.day  = START_DAY;
+        this.hour = START_HOUR;
+    }
+    /**
+     * Advances the clock by the given number of hours, rolling over into the next
+     * day as necessary.
+     *
+     * @param hours the number of hours to advance (must be positive)
+     */
+    public void advanceHours(int hours) {
+        this.hour += hours;
+        while (this.hour >= HOURS_IN_DAY) {
+            this.hour -= HOURS_IN_DAY;
+            this.day++;
+        }
+    }
+    /**
+     * Jumps the clock forward to {@value #START_HOUR}:00 on the next day.
+     * Used when the player sleeps in bed.
+     */
+    public void advanceToNextMorning() {
+        this.day++;
+        this.hour = START_HOUR;
+    }
+    /**
+     * Returns whether the exam deadline has passed.
+     *
+     * @return {@code true} if the current time is on or after Day {@value #DEADLINE_DAY}
+     *         at {@value #DEADLINE_HOUR}:00
+     */
+    public boolean isPastDeadline() {
+        if (day > DEADLINE_DAY) return true;
+        if (day == DEADLINE_DAY && hour >= DEADLINE_HOUR) return true;
+        return false;
+    }
+    /** @return the current in-game day number */
+    public int getDay()  { return day; }
+    /** @return the current in-game hour (0–23) */
+    public int getHour() { return hour; }
+    /**
+     * Returns a human-readable time string in the format {@code "Day D, HH:00"}.
+     *
+     * @return formatted time string
+     */
+    @Override
+    public String toString() {
+        return String.format("Day %d, %02d:00", day, hour);
+    }
+}

src/main/java/cz/davza/studentadventure/objects/ItemStack.java

@@ -0,0 +1,74 @@
+package cz.davza.studentadventure.objects;
+
+import cz.davza.studentadventure.interfaces.IItem;
+/**
+ * A counted slot holding one or more instances of the same {@link IItem}.
+ *
+ * <p>The maximum number of items that can be held in a single stack is determined
+ * by {@link IItem#getBulk()} on the contained item. The collection layer
+ * ({@link cz.davza.studentadventure.base.ItemCollectionBase}) is responsible for
+ * enforcing this limit; {@code ItemStack} itself does not clamp {@link #Add}.</p>
+ */
+public class ItemStack{
+    private final IItem item;
+    private int amount;
+    /**
+     * Creates a stack containing one instance of the given item.
+     *
+     * @param item the item type this stack holds
+     */
+    public ItemStack(IItem item){
+        this.item = item;
+        this.amount = 1;
+    }
+    /**
+     * Creates a stack containing the specified number of items.
+     *
+     * @param item   the item type this stack holds
+     * @param amount the initial quantity (must be ≥ 1)
+     * @throws IllegalArgumentException if {@code amount} is less than 1
+     */
+    public ItemStack(IItem item, int amount){
+        if (amount <= 0) throw new IllegalArgumentException("Cannot hold less than 1 item");
+        this.item = item;
+        this.amount = amount;
+
+    }
+    /**
+     * Increases the stack count by the given amount.
+     * @param amount the number of items to add
+     */
+    public void Add(int amount){
+        this.amount += amount;
+    }
+    /**
+     * Decreases the stack count by the given amount.
+     * No bounds checking is performed; callers should not reduce below zero.
+     *
+     * @param amount the number of items to remove
+     */
+    public void Remove(int amount){
+        this.amount -= amount;
+    }
+    /**
+     * Returns the item type held in this stack.
+     *
+     * @return the item
+     */
+    public IItem getItem(){
+        return this.item;
+    }
+    /**
+     * Returns the current quantity of items in this stack.
+     *
+     * @return the stack count
+     */
+    public int getAmount(){
+        return this.amount;
+    }
+
+    @Override
+    public String toString() {
+        return item.getCode() + " x " + amount;
+    }
+}

src/main/java/cz/davza/studentadventure/objects/Player.java

@@ -0,0 +1,127 @@
+package cz.davza.studentadventure.objects;
+
+import cz.davza.studentadventure.enums.DeprivationState;
+
+import java.util.Random;
+
+/**
+ * Represents the player character and their current state.
+ *
+ * <p>Holds all mutable stats ({@link #getIntelligence()}, {@link #getEnergy()},
+ * {@link #getStress()}), the player's money, their inventory, and sleep-deprivation
+ * tracking via {@link #hoursAwake}.</p>
+ *
+ * <p>The deprivation system multiplies the cost of actions like studying once
+ * the player has been awake too long. See {@link #getDeprivationMultiplier()}.</p>
+ */
+public class Player {
+    private final String name;
+    private final PlayerInventory inventory;
+    private final Wallet wallet;
+    private final String id;
+    private final PlayerStat intelligence;
+    private final PlayerStat energy;
+    private final PlayerStat stress;
+
+    private static final int    TIRED_THRESHOLD    = 14;
+    private static final int    DEPRIVED_THRESHOLD = 20;
+    private static final double MAX_MULTIPLIER     = 3.0;
+    private static final int STARTING_MONEY = 50;
+
+    private int hoursAwake = 0;
+    /**
+     * Creates a new player with default starting stats and an empty inventory.
+     *
+     * @param name          the player's display name
+     * @param inventorySize the number of inventory slots available to the player
+     */
+    public Player(String name, int inventorySize) {
+        this.name = name;
+        this.inventory = new PlayerInventory(inventorySize);
+        this.id = name + new Random().nextInt(100);
+        this.intelligence = new PlayerStat("Intelligence", 5);
+        this.energy = new PlayerStat("Energy", 100);
+        this.stress = new PlayerStat("Stress", 0);
+        this.wallet = new Wallet(STARTING_MONEY);
+    }
+
+    /** @return the player's inventory */
+    public PlayerInventory getInventory() { return inventory; }
+
+    /** @return the intelligence stat */
+    public PlayerStat getIntelligence() { return intelligence; }
+    /** @return the energy stat */
+    public PlayerStat getEnergy() { return energy; }
+    /** @return the player's wallet */
+    public Wallet getWallet() { return wallet; }
+    /**
+     * @return the stress stat
+     */
+    public PlayerStat getStress() { return stress; }
+    /** @return the player's display name */
+    public String getName() { return name; }
+    /**
+     * Prints a formatted summary of the player's stats to {@code System.out}.
+     */
+    public String printStats() {
+        return "=== " + name + " ===\n" +
+                intelligence + "\n" +
+                energy + "\n" +
+                stress + "\n" +
+                "Money: " + this.wallet.getMoney() + " coins\n";
+    }
+    /**
+     * Increments the consecutive hours-awake counter.
+     * Passing a negative value can be used to reduce it (e.g. after sleeping in class).
+     *
+     * @param hours the number of hours to add (may be negative)
+     */
+    public void addHoursAwake(int hours) {
+        hoursAwake += hours;
+    }
+    /**
+     * Resets the hours-awake counter to zero. Called after a full night's sleep.
+     */
+    public void resetHoursAwake() {
+        hoursAwake = 0;
+    }
+    /**
+     * Returns the player's current sleep-deprivation state based on
+     * how many consecutive hours they have been awake.
+     *
+     * @return {@link DeprivationState#NORMAL}, {@link DeprivationState#TIRED},
+     *         or {@link DeprivationState#DEPRIVED}
+     */
+    public DeprivationState getDeprivationState() {
+        if (hoursAwake >= DEPRIVED_THRESHOLD) return DeprivationState.DEPRIVED;
+        if (hoursAwake >= TIRED_THRESHOLD)    return DeprivationState.TIRED;
+        return DeprivationState.NORMAL;
+    }
+    /**
+     * Returns a cost multiplier applied to tiring actions (such as studying)
+     * based on the current deprivation state.
+     *
+     * <ul>
+     *   <li>{@link DeprivationState#NORMAL}   → {@code 1.0×}</li>
+     *   <li>{@link DeprivationState#TIRED}     → {@code 1.3×}</li>
+     *   <li>{@link DeprivationState#DEPRIVED}  → {@code 1.3×} + {@code 0.2×} per extra hour,
+     *       capped at {@value #MAX_MULTIPLIER}×</li>
+     * </ul>
+     *
+     * @return the deprivation cost multiplier (always ≥ 1.0)
+     */
+    public double getDeprivationMultiplier() {
+        switch (getDeprivationState()) {
+            case TIRED:
+                return 1.3;
+            case DEPRIVED:
+                int hoursDeprived = hoursAwake - DEPRIVED_THRESHOLD;
+                return Math.min(1.3 + (hoursDeprived * 0.2), MAX_MULTIPLIER);
+            default:
+                return 1.0;
+        }
+    }
+    public String getId() {
+        return id;
+    }
+}

src/main/java/cz/davza/studentadventure/objects/PlayerInventory.java

@@ -0,0 +1,82 @@
+package cz.davza.studentadventure.objects;
+
+import cz.davza.studentadventure.base.ItemCollectionBase;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.interfaces.IItem;
+import cz.davza.studentadventure.interfaces.IObservable;
+import cz.davza.studentadventure.interfaces.IObserver;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+/**
+ * The player's personal item inventory, with Observer support for change notifications.
+ *
+ * <p>Extends {@link ItemCollectionBase} with the full slot-based stacking logic,
+ * and additionally implements {@link IObservable} so that external listeners
+ * (such as a GUI panel) can react whenever the inventory contents change.</p>
+ *
+ * <p>Every call to {@link #Add} or {@link #Remove} automatically fires a
+ * {@link CommandState#INVENTORY_CHANGE} notification to all registered observers
+ * after delegating the operation to the superclass.</p>
+ *
+ * @see cz.davza.studentadventure.base.ItemCollectionBase
+ * @see IObservable
+ * @see IObserver
+ */
+public class PlayerInventory extends ItemCollectionBase<IItem> implements IObservable {
+    private final Map<CommandState, Set<IObserver>> observers = new HashMap<>();
+    /**
+     * Creates a new inventory with the given number of bulk-unit capacity.
+     *
+     * @param size the total bulk capacity of this inventory
+     */
+    public PlayerInventory(int size) {
+        super(size);
+    }
+    /**
+     * {@inheritDoc}
+     *
+     * <p>After the item is added (or partially added) by the superclass,
+     * all observers registered for {@link CommandState#INVENTORY_CHANGE} are notified.</p>
+     */
+    @Override
+    public int Add(IItem item, int count){
+        int result = super.Add(item, count);
+        notifyObservers(CommandState.INVENTORY_CHANGE);
+        return result;
+    }
+    /**
+     * {@inheritDoc}
+     *
+     * <p>After the item is removed by the superclass,
+     * all observers registered for {@link CommandState#INVENTORY_CHANGE} are notified.</p>
+     */
+    @Override
+    public void Remove(String itemCode, int count) {
+        super.Remove(itemCode, count);
+        notifyObservers(CommandState.INVENTORY_CHANGE);
+    }
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void addObserver(CommandState observedstate, IObserver o) {
+        if  (!observers.containsKey(observedstate)) observers.put(observedstate, new HashSet<>());
+        observers.get(observedstate).add(o);
+    }
+
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void notifyObservers(CommandState notifiedState) {
+        if   (!observers.containsKey(notifiedState)) return;
+
+        for (IObserver observer : observers.get(notifiedState)) {
+            observer.update();
+        }
+    }
+}

src/main/java/cz/davza/studentadventure/objects/PlayerStat.java

@@ -0,0 +1,67 @@
+package cz.davza.studentadventure.objects;
+/**
+ * A single bounded numeric stat for the player (e.g. energy, stress, intelligence).
+ *
+ * <p>Values are always clamped to the range [{@value #MIN}, {@value #MAX}].
+ * Use {@link #increase(int)} and {@link #decrease(int)} to modify the value;
+ * both internally call the same clamp so negative amounts are handled safely
+ * by whichever direction is semantically appropriate.</p>
+ */
+public class PlayerStat {
+    private final String name;
+    private int value;
+    private static final int MIN = 0;
+    private static final int MAX = 100;
+    /**
+     * Creates a new stat with the given name and initial value.
+     * The initial value is clamped to [{@value #MIN}, {@value #MAX}].
+     *
+     * @param name         the stat's display name (e.g. {@code "Energy"})
+     * @param initialValue the starting value
+     */
+    public PlayerStat(String name, int initialValue) {
+        this.name = name;
+        this.value = clamp(initialValue);
+    }
+    /**
+     * Increases the stat by {@code amount}, clamped at {@value #MAX}.
+     *
+     * @param amount the amount to add (should be positive)
+     */
+    public void increase(int amount) {
+        this.value = clamp(this.value + amount);
+    }
+    /**
+     * Decreases the stat by {@code amount}, clamped at {@value #MIN}.
+     *
+     * @param amount the amount to subtract (should be positive)
+     */
+    public void decrease(int amount) {
+        this.value = clamp(this.value - amount);
+    }
+    /**
+     * Returns the current value of this stat.
+     *
+     * @return a value in the range [{@value #MIN}, {@value #MAX}]
+     */
+    public int getValue() { return value; }
+    /**
+     * Returns the display name of this stat.
+     *
+     * @return the stat name
+     */
+    public String getName() { return name; }
+
+    private int clamp(int val) {
+        return Math.max(MIN, Math.min(MAX, val));
+    }
+    /**
+     * Returns a human-readable representation in the form {@code "Name: value/100"}.
+     *
+     * @return formatted stat string
+     */
+    @Override
+    public String toString() {
+        return name + ": " + value + "/100";
+    }
+}

src/main/java/cz/davza/studentadventure/objects/RoomItems.java

@@ -0,0 +1,24 @@
+package cz.davza.studentadventure.objects;
+
+import cz.davza.studentadventure.base.ItemCollectionBase;
+import cz.davza.studentadventure.interfaces.IItem;
+/**
+ * A fixed-size item collection representing the items present in a room.
+ *
+ * <p>Thin concrete subclass of {@link ItemCollectionBase} — all behaviour is
+ * inherited. The capacity passed to the constructor determines how many bulk
+ * units of items the room can hold at once.</p>
+ *
+ * @see ItemCollectionBase
+ * @see cz.davza.studentadventure.base.RoomBase
+ */
+public class RoomItems extends ItemCollectionBase<IItem> {
+    /**
+     * Creates a new room item collection with the given bulk capacity.
+     *
+     * @param size the total bulk capacity of this room's item storage
+     */
+    public RoomItems(int size) {
+        super(size);
+    }
+}

src/main/java/cz/davza/studentadventure/objects/Wallet.java

@@ -0,0 +1,56 @@
+package cz.davza.studentadventure.objects;
+/**
+ * Holds and manages the player's coin balance.
+ *
+ * <p>Provides simple earn/spend operations. {@link #spendMoney(int)} performs a
+ * balance check and returns {@code false} without modifying the balance if the
+ * player cannot afford the amount — callers should check the return value before
+ * assuming the transaction succeeded.</p>
+ *
+ * @see cz.davza.studentadventure.objects.Player
+ */
+public class Wallet {
+    private int money;
+    /**
+     * Creates a wallet with a zero starting balance.
+     */
+    public Wallet(){}
+    /**
+     * Creates a wallet with the given starting balance.
+     *
+     * @param startingAmount the initial coin balance (must be ≥ 0)
+     */
+    public Wallet(int startingAmount){
+        this.money = startingAmount;
+    }
+    /**
+     * Returns the current coin balance.
+     *
+     * @return the number of coins held
+     */
+    public int getMoney() {
+        return money;
+    }
+    /**
+     * Adds coins to the balance (e.g. from picking up money or stealing).
+     *
+     * @param amount the number of coins to add (must be ≥ 0)
+     */
+    public void earnMoney(int amount){
+        this.money += amount;
+    }
+    /**
+     * Deducts coins from the balance if the player can afford it.
+     *
+     * @param amount the number of coins to deduct
+     * @return {@code true} if the transaction succeeded; {@code false} if the
+     *         balance was insufficient (balance is unchanged in that case)
+     */
+    public boolean spendMoney(int amount){
+        if (amount > this.money){
+            return false;
+        }
+        this.money -= amount;
+        return true;
+    }
+}

src/main/java/cz/davza/studentadventure/outputsinks/TextOutputSink.java

@@ -0,0 +1,32 @@
+package cz.davza.studentadventure.outputsinks;
+
+import cz.davza.studentadventure.interfaces.IOutputSink;
+/**
+ * {@link IOutputSink} implementation that writes output to {@code System.out}.
+ *
+ * <p>Text is buffered internally and printed in a single {@link System#out} call
+ * on {@link #flush()}, keeping output atomic and avoiding interleaved partial lines.</p>
+ *
+ * @see IOutputSink
+ * @see GuiOutputSink
+ */
+public class TextOutputSink implements IOutputSink {
+    private final StringBuilder buffer = new StringBuilder();
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void buffer(String text) {
+        buffer.append(text);
+    }
+    /**
+     * {@inheritDoc}
+     * Prints the buffered content to {@code System.out} and clears the buffer.
+     */
+
+    @Override
+    public void flush() {
+        System.out.print(buffer.toString());
+        buffer.setLength(0);
+    }
+}

src/main/java/cz/davza/studentadventure/rooms/BedroomRoom.java

@@ -0,0 +1,33 @@
+package cz.davza.studentadventure.rooms;
+
+import cz.davza.studentadventure.Items.Bed;
+import cz.davza.studentadventure.Items.Money;
+import cz.davza.studentadventure.base.RoomBase;
+import cz.davza.studentadventure.objects.GameData;
+
+/**
+ * The player's student bedroom — the starting room of the game.
+ *
+ * <p>Contains the player's bed, a sticky note hinting at the computer lab password,
+ * and a small amount of random loose change on the floor. The {@code sleep} command
+ * is available here, fully restoring stats and advancing to the next morning.</p>
+ *
+ * @see cz.davza.studentadventure.commands.SleepCommand
+ */
+public class BedroomRoom extends RoomBase {
+    /**
+     * Constructs the bedroom, placing a sticky note, bed, and random money.
+     *
+     *
+     */
+    public BedroomRoom(GameData gameContext) {
+        super("Bedroom",
+                "bedroom",
+                "Your student bedroom. Clothes on the floor, a messy study desk and an inviting bed.",
+                20);
+        allowedCommands.add("sleep");
+        allowedCommands.add("study");
+        getItems().Add(new Bed(), 1);
+        getItems().Add(new Money(10, 30), 1); // Random loose change
+    }
+}

src/main/java/cz/davza/studentadventure/rooms/ClassroomRoom.java

@@ -0,0 +1,53 @@
+package cz.davza.studentadventure.rooms;
+
+import cz.davza.studentadventure.Items.StickyNote;
+import cz.davza.studentadventure.base.RoomBase;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.Player;
+/**
+ * A university lecture hall. Entry requires the player to be carrying a book.
+ *
+ * <p>If the player attempts to enter without a {@code book} in their inventory,
+ * the professor blocks them at the door and inflicts a stress penalty.
+ * Sleeping in class is allowed but carries a {@code 30%} chance of a game-over.</p>
+ *
+ * @see cz.davza.studentadventure.commands.SleepCommand
+ */
+public class ClassroomRoom extends RoomBase {
+    /** Creates the classroom room. */
+    public ClassroomRoom(GameData gameContext) {
+        super("Classroom",
+                "classroom",
+                "Rows of seats face a whiteboard. The professor drones on at the front. " +
+                        "Several students look just as tired as you.",
+                10);
+        getItems().Add(new StickyNote("Computer lab password: " + gameContext.getComputerPassword()), 1);
+        allowedCommands.add("sleep");
+    }
+    /**
+     * {@inheritDoc}
+     *
+     * <p>Checks the player's inventory for a {@code book}. If none is found,
+     * prints a refusal message, applies a stress penalty, and cancels the room
+     * change via {@code context.getMap().setNextRoom(null)}.</p>
+     *
+     * @return
+     */
+    @Override
+    public CommandResult onEnter(GameData context) {
+        Player player = context.getPlayer();
+        boolean hasBook = player.getInventory().GetByItemCode("book") != null;
+
+        if (!hasBook) {
+            player.getStress().increase(15);
+            context.getMap().setNextRoom(null);
+            return CommandResult.failed(
+                    "The professor stops you at the door.\n" +
+                            "\"No textbook? Get out of my classroom!\"\n" +
+                            "Stress +15. " + player.getStress());
+        }
+
+        return CommandResult.success("");
+    }
+}

src/main/java/cz/davza/studentadventure/rooms/ComputerLabRoom.java

@@ -0,0 +1,33 @@
+package cz.davza.studentadventure.rooms;
+
+import cz.davza.studentadventure.Items.Book;
+import cz.davza.studentadventure.base.RoomBase;
+import cz.davza.studentadventure.Items.Computer;
+import cz.davza.studentadventure.objects.GameData;
+
+/**
+ * A university computer lab containing password-protected workstations.
+ *
+ * <p>The {@code study} command is available here. Interacting with the
+ * {@link Computer} opens a sub-loop where the player can study using the
+ * machine after providing the correct password.</p>
+ *
+ * @see Computer
+ */
+public class ComputerLabRoom extends RoomBase {
+    /**
+     * Constructs the computer lab with a computer and a spare book.
+     *
+     * @param gameContext the game data for option extractions
+     */
+    public ComputerLabRoom(GameData gameContext) {
+        super("Computer Lab",
+                "computerlab",
+                "Rows of university computers hum quietly. " +
+                        "A sign on the wall reads: 'Authorised users only.'",
+                10);
+        allowedCommands.add("study");
+        getItems().Add(new Computer(gameContext.getComputerPassword()), 1);
+        getItems().Add(new Book(),1);
+    }
+}

src/main/java/cz/davza/studentadventure/rooms/ExamRoomRoom.java

@@ -0,0 +1,66 @@
+package cz.davza.studentadventure.rooms;
+
+import cz.davza.studentadventure.base.RoomBase;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.interfaces.ICommandable;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+
+import java.util.Scanner;
+
+/**
+ * The final exam hall — the endgame room of the adventure.
+ *
+ * <p>Only the {@code takeexam} command is available here. Walking in and
+ * using it triggers the win/lose evaluation based on the player's accumulated
+ * intelligence and current stress level.</p>
+ *
+ * @see cz.davza.studentadventure.commands.TakeExamCommand
+ */
+public class ExamRoomRoom extends RoomBase implements ICommandable {
+    /** Creates the exam room. */
+    public ExamRoomRoom(GameData gameContext) {
+        super("Exam Room",
+                "examroom",
+                "A silent hall filled with desks. This is it. " +
+                        "The exam paper sits face down in front of you.",
+                2);
+        allowedCommands.add("takeexam");
+    }
+    /**
+     * {@inheritDoc}
+     *
+     * <p>Checks the player's inventory for a {@code book}. If none is found,
+     * prints a refusal message, applies a stress penalty, and cancels the room
+     * change via {@code context.getMap().setNextRoom(null)}.</p>
+     *
+     * @return
+     */
+
+        @Override
+        public CommandResult onEnter(GameData context) {
+            return CommandResult.actionPending(this,
+                    "As you enter the exam room a teacher stops you.\n" +
+                            "'To take the test you must tell us your student ID'\n" +
+                            "Enter student ID (or 'leave' to walk away):");
+        }
+
+        @Override
+        public CommandResult handleCommand(String input, GameData context) {
+            String studentId = context.getPlayer().getId();
+
+            if (input.equalsIgnoreCase("leave")) {
+                context.getMap().setNextRoom(null);
+                return CommandResult.actionResumed(
+                        "Since you do not know your student ID you may not take the test.\n" +
+                                "You leave the exam room.");
+            }
+
+            if (input.equalsIgnoreCase(studentId)) {
+                return CommandResult.actionResumed("You confidently walk into the exam room.");
+            }
+
+            return CommandResult.failed("No I do not believe that is you.\nEnter student ID (or 'leave' to walk away):");
+        }
+
+}

src/main/java/cz/davza/studentadventure/rooms/HallwayRoom.java

@@ -0,0 +1,24 @@
+package cz.davza.studentadventure.rooms;
+
+import cz.davza.studentadventure.Items.Money;
+import cz.davza.studentadventure.Items.StickyNote;
+import cz.davza.studentadventure.base.RoomBase;
+import cz.davza.studentadventure.objects.GameData;
+
+/**
+ * The central hallway connecting most rooms in the building.
+ *
+ * <p>Contains a sticky note and a small amount of loose change on the floor.
+ * Acts as the main hub for navigation.</p>
+ */
+public class HallwayRoom extends RoomBase {
+    /** Creates the hallway with its default items. */
+    public HallwayRoom(GameData gameContext) {
+        super("Hallway",
+                "hallway",
+                "A busy university hallway. Students rush past you in every direction.",
+                5);
+        getItems().Add(new StickyNote("Dr. Doofenshmirts stinks"),1);
+        getItems().Add(new Money(5),1);
+    }
+}

src/main/java/cz/davza/studentadventure/rooms/ShopRoom.java

@@ -0,0 +1,23 @@
+package cz.davza.studentadventure.rooms;
+
+import cz.davza.studentadventure.base.RoomBase;
+import cz.davza.studentadventure.objects.GameData;
+
+/**
+ * The campus convenience shop.
+ *
+ * <p>The {@code buy} command is available here. Currently sells energy drinks.</p>
+ *
+ * @see cz.davza.studentadventure.commands.BuyCommand
+ */
+public class ShopRoom extends RoomBase {
+    /** Creates the shop room. */
+    public ShopRoom(GameData gameContext) {
+        super("Campus Shop",
+                "shop",
+                "A small convenience shop. A fridge hums in the corner, " +
+                        "stocked with energy drinks. The cashier looks bored.",
+                30);
+        allowedCommands.add("buy");
+    }
+}

src/main/java/cz/davza/studentadventure/rooms/StudyRoomRoom.java

@@ -0,0 +1,29 @@
+package cz.davza.studentadventure.rooms;
+
+import cz.davza.studentadventure.Items.Book;
+import cz.davza.studentadventure.Items.StickyNote;
+import cz.davza.studentadventure.base.RoomBase;
+import cz.davza.studentadventure.objects.GameData;
+
+/**
+ * A quiet study area where students work undisturbed — and leave their bags unattended.
+ *
+ * <p>The {@code study} and {@code steal} commands are available here.
+ * Contains two books and a sticky note.</p>
+ *
+ * @see cz.davza.studentadventure.commands.StealCommand
+ */
+public class StudyRoomRoom extends RoomBase {
+    /** Creates the study room with default items. */
+    public StudyRoomRoom(GameData gameContext) {
+        super("Study Room",
+                "studyroom",
+                "A quiet study room. A few students sit with their heads buried in books. " +
+                        "Someone left their bag unattended on the chair next to you.",
+                10);
+        allowedCommands.add("study");
+        allowedCommands.add("steal");
+        getItems().Add(new Book(), 2);
+        getItems().Add(new StickyNote("Amanda Likes Brad ❤️"),1);
+    }
+}

src/main/resources/cz/davza/studentadventure/main/help.html

@@ -0,0 +1,104 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" >
+    <title>Student Adventure — Help</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            background-color: #1a1a2e;
+            color: #e0e0e0;
+            margin: 0;
+            padding: 24px;
+        }
+        h1 {
+            color: #a0c4ff;
+            font-size: 22px;
+            border-bottom: 2px solid #a0c4ff;
+            padding-bottom: 8px;
+            margin-bottom: 20px;
+        }
+        h2 {
+            color: #bdb2ff;
+            font-size: 16px;
+            margin-top: 24px;
+            margin-bottom: 8px;
+        }
+        table {
+            width: 100%;
+            border-collapse: collapse;
+            margin-bottom: 16px;
+        }
+        td {
+            padding: 8px 12px;
+            border-bottom: 1px solid #2e2e4e;
+            font-size: 14px;
+            vertical-align: top;
+        }
+        td:first-child {
+            font-family: monospace;
+            color: #a0c4ff;
+            white-space: nowrap;
+            width: 220px;
+        }
+        tr:hover td {
+            background-color: #2e2e4e;
+        }
+        .note {
+            font-size: 12px;
+            color: #888;
+            margin-top: 24px;
+            border-top: 1px solid #2e2e4e;
+            padding-top: 12px;
+        }
+    </style>
+</head>
+<body>
+
+<h1>Student Adventure — Help</h1>
+<p>You have until <strong>Day 7 at 09:00</strong> to prepare for and pass your final exam. Manage your energy, stress, and intelligence wisely.</p>
+
+<h2>Movement</h2>
+<table>
+    <tr><td>walk &lt;exit&gt;</td><td>Move to a connected room in the given direction.</td></tr>
+</table>
+
+<h2>Inventory</h2>
+<table>
+    <tr><td>pickup &lt;item&gt; &lt;n&gt;</td><td>Pick up n of an item from the current room.</td></tr>
+    <tr><td>drop &lt;item&gt; [n]</td><td>Drop n of the named item from your inventory (default 1). Example: drop book 2</td></tr>
+    <tr><td>consume &lt;item&gt;</td><td>Consume one of the named item from your inventory. Example: consume energy_drink</td></tr>
+    <tr><td>inventory</td><td>Show your current inventory.</td></tr>
+</table>
+
+<h2>Actions</h2>
+<table>
+    <tr><td>interact &lt;item&gt;</td><td>Interact with an item in the current room.</td></tr>
+    <tr><td>study &lt;hours&gt;</td><td>Study for the given number of hours. Available in bedroom, study room, and computer lab.</td></tr>
+    <tr><td>sleep</td><td>Sleep to restore energy and reduce stress. Available in bedroom and classroom.</td></tr>
+    <tr><td>steal</td><td>Attempt to steal money. Study room only. Risky.</td></tr>
+    <tr><td>buy &lt;item&gt;</td><td>Buy an item from the shop.</td></tr>
+    <tr><td>takeexam</td><td>Take the final exam. Exam room only.</td></tr>
+</table>
+
+<h2>Information</h2>
+<table>
+    <tr><td>stats</td><td>Show your current stats — intelligence, energy, stress, and money.</td></tr>
+    <tr><td>time</td><td>Show the current in-game time and day.</td></tr>
+    <tr><td>describe</td><td>Describe the current room and its contents.</td></tr>
+    <tr><td>availablecommands</td><td>List commands available in your current location.</td></tr>
+    <tr><td>studentId</td><td>Display your student ID. Computer lab only.</td></tr>
+</table>
+
+<h2>Game</h2>
+<table>
+    <tr><td>quit</td><td>Give up and end the game.</td></tr>
+</table>
+
+<div class="note">
+    Tip: Keep an eye on your energy — studying while exhausted costs significantly more and increases stress faster. Sleep before you burn out.
+</div>
+
+</body>
+</html>

src/main/resources/simplelogger.properties

@@ -0,0 +1,11 @@
+# System-wide default log level (Options: trace, debug, info, warn, error, off)
+# Setting this to warn ensures you only see critical problems, not setup notices.
+org.slf4j.simpleLogger.defaultLogLevel=warn
+
+# Explicitly target and silence the reflections framework logs
+org.slf4j.simpleLogger.log.org.reflections=warn
+
+# Optional: Clear the logging layout so it doesn't print timestamps or thread names
+org.slf4j.simpleLogger.showDateTime=false
+org.slf4j.simpleLogger.showThreadName=false
+org.slf4j.simpleLogger.showLogName=false

test/cz/davza/studentadventure/TestHelpers.java

@@ -0,0 +1,52 @@
+package cz.davza.studentadventure;
+
+import cz.davza.studentadventure.base.CommandBase;
+import cz.davza.studentadventure.interfaces.IOutputSink;
+import cz.davza.studentadventure.managers.CommandManager;
+import cz.davza.studentadventure.objects.*;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Shared test utilities.
+ */
+public class TestHelpers {
+
+    /** Captures all writeLine calls for assertion. */
+    public static class CapturingOutputSink implements IOutputSink {
+        private final StringBuilder buffer = new StringBuilder();
+        @Override public void writeLine(String line) { buffer.append(line).append("\n"); }
+        @Override public void buffer(String text) {}
+        @Override public void flush() {}
+        public String getOutput()              { return buffer.toString(); }
+        public void clear()                    { buffer.setLength(0); }
+        public boolean contains(String text)   { return buffer.toString().contains(text); }
+    }
+
+    /** Creates a fully wired GameData starting in the bedroom. */
+    public static GameData buildGameData() {
+        Player   player = new Player("TestStudent", 20);
+        GameMap  map    = new GameMap();
+        GameTime time   = new GameTime();
+        return new GameData(player, map, time);
+    }
+
+    /**
+     * Parses and executes a command string against the given context,
+     * bypassing the allowed-commands check so commands can be tested
+     * in isolation regardless of which room the player is in.
+     */
+    public static CommandResult execute(String input, GameData context) {
+        // Build an unrestricted allowed list containing everything
+        List<String> allAllowed = List.of(
+            "study","sleep","walk","pickup","drop","consume","interact",
+            "steal","buy","takeexam","inventory","stats","time","describe",
+            "help","availablecommands","studentid"
+        );
+        CommandBase cmd = CommandManager.parseCommand(input, allAllowed);
+        if (cmd == null) throw new IllegalArgumentException("Unknown command: " + input);
+        return cmd.Execute(context);
+    }
+}

test/cz/davza/studentadventure/commands/BuyCommandTest.java

@@ -0,0 +1,85 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.Items.EnergyDrink;
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.Player;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static cz.davza.studentadventure.TestHelpers.execute;
+import static org.junit.jupiter.api.Assertions.*;
+
+class BuyCommandTest {
+
+    private GameData context;
+    private Player player;
+
+    @BeforeEach
+    void setUp() {
+        context = TestHelpers.buildGameData();
+        player  = context.getPlayer();
+    }
+
+    @Test
+    void buyEnergyDrinkDeductsCost() {
+        int before = player.getWallet().getMoney();
+        execute("buy energy_drink", context);
+        assertEquals(before - EnergyDrink.COST, player.getWallet().getMoney());
+    }
+
+    @Test
+    void buyEnergyDrinkAddsToInventory() {
+        execute("buy energy_drink", context);
+        assertNotNull(player.getInventory().GetByItemCode("energy_drink"));
+    }
+
+    @Test
+    void buyReturnsSuccessState() {
+        CommandResult result = execute("buy energy_drink", context);
+        assertEquals(CommandState.SUCCESS, result.getResultState());
+    }
+
+    @Test
+    void buyWithInsufficientFundsReturnsFailed() {
+        player.getWallet().spendMoney(player.getWallet().getMoney()); // drain wallet
+        CommandResult result = execute("buy energy_drink", context);
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+
+    @Test
+    void buyWithInsufficientFundsDoesNotAddItem() {
+        player.getWallet().spendMoney(player.getWallet().getMoney());
+        execute("buy energy_drink", context);
+        assertNull(player.getInventory().GetByItemCode("energy_drink"));
+    }
+
+    @Test
+    void buyUnknownItemReturnsFailed() {
+        CommandResult result = execute("buy sandwich", context);
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+
+    @Test
+    void buyWithNoParamsReturnsInvalidParams() {
+        CommandResult result = execute("buy", context);
+        assertEquals(CommandState.INVALID_PARAMS, result.getResultState());
+    }
+
+    @Test
+    void buyWhenInventoryFullReturnsInventoryFull() {
+        // Fill inventory: capacity 20, drink bulk 2 → 10 drinks = 20 bulk
+        player.getInventory().Add(new EnergyDrink(), 10);
+        CommandResult result = execute("buy energy_drink", context);
+        assertEquals(CommandState.INVENTORY_FULL, result.getResultState());
+    }
+
+    @Test
+    void buyDoesNotSpendMoneyWhenInventoryFull() {
+        player.getInventory().Add(new EnergyDrink(), 10);
+        int moneyBefore = player.getWallet().getMoney();
+        execute("buy energy_drink", context);
+        assertEquals(moneyBefore, player.getWallet().getMoney());
+    }
+}

test/cz/davza/studentadventure/commands/ConsumeCommandTest.java

@@ -0,0 +1,90 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.Items.Book;
+import cz.davza.studentadventure.Items.EnergyDrink;
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.Player;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static cz.davza.studentadventure.TestHelpers.execute;
+import static org.junit.jupiter.api.Assertions.*;
+
+class ConsumeCommandTest {
+
+    private GameData context;
+    private Player player;
+
+    @BeforeEach
+    void setUp() {
+        context = TestHelpers.buildGameData();
+        player  = context.getPlayer();
+        player.getInventory().Add(new EnergyDrink(), 2);
+    }
+
+    @Test
+    void consumeAppliesItemEffect() {
+        player.getEnergy().decrease(50);
+        int before = player.getEnergy().getValue();
+        execute("consume energy_drink", context);
+        assertEquals(before + EnergyDrink.ENERGY_RESTORE, player.getEnergy().getValue());
+    }
+
+    @Test
+    void consumeRemovesOneFromStack() {
+        execute("consume energy_drink", context);
+        assertEquals(1, player.getInventory().GetByItemCode("energy_drink").getAmount());
+    }
+
+    @Test
+    void consumeLastItemClearsInventoryEntry() {
+        player.getInventory().Add(new EnergyDrink(), 1);
+        // inventory has 2 from setUp + 1 = 3 total
+        execute("consume energy_drink", context);
+        execute("consume energy_drink", context);
+        execute("consume energy_drink", context);
+        assertNull(player.getInventory().GetByItemCode("energy_drink"));
+    }
+
+    @Test
+    void consumeRestoresInventoryCapacity() {
+        int before = player.getInventory().GetRemainingCapacity();
+        execute("consume energy_drink", context);
+        assertEquals(before + new EnergyDrink().getBulk(),
+                player.getInventory().GetRemainingCapacity());
+    }
+
+    @Test
+    void consumeReturnsSuccessState() {
+        CommandResult result = execute("consume energy_drink", context);
+        assertEquals(CommandState.SUCCESS, result.getResultState());
+    }
+
+    @Test
+    void consumeItemNotInInventoryReturnsItemNotFound() {
+        CommandResult result = execute("consume mouldy_cheese", context);
+        assertEquals(CommandState.ITEM_NOT_FOUND, result.getResultState());
+    }
+
+    @Test
+    void consumeNonConsumableReturnsFailed() {
+        player.getInventory().Add(new Book(), 1);
+        CommandResult result = execute("consume book", context);
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+
+    @Test
+    void consumeWithNoParamsReturnsInvalidParams() {
+        CommandResult result = execute("consume", context);
+        assertEquals(CommandState.INVALID_PARAMS, result.getResultState());
+    }
+
+    @Test
+    void consumeEnergyCappsAt100() {
+        // energy already at 100 — drink shouldn't push above 100
+        execute("consume energy_drink", context);
+        assertEquals(100, player.getEnergy().getValue());
+    }
+}

test/cz/davza/studentadventure/commands/DropCommandTest.java

@@ -0,0 +1,93 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.Items.Book;
+import cz.davza.studentadventure.Items.EnergyDrink;
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static cz.davza.studentadventure.TestHelpers.execute;
+import static org.junit.jupiter.api.Assertions.*;
+
+class DropCommandTest {
+
+    private GameData context;
+
+    @BeforeEach
+    void setUp() {
+        context = TestHelpers.buildGameData();
+        context.getPlayer().getInventory().Add(new Book(), 3);
+        context.getPlayer().getInventory().Add(new EnergyDrink(), 2);
+    }
+
+    @Test
+    void dropRemovesItemFromInventory() {
+        execute("drop book 1", context);
+        assertEquals(2, context.getPlayer().getInventory().GetByItemCode("book").getAmount());
+    }
+
+    @Test
+    void dropAddsItemToRoom() {
+        int before = context.getMap().getCurrentRoom().getItems().GetRemainingCapacity();
+        execute("drop book 1", context);
+        assertTrue(context.getMap().getCurrentRoom().getItems().GetRemainingCapacity() < before);
+    }
+
+    @Test
+    void dropEntireStackClearsInventoryEntry() {
+        execute("drop book 3", context);
+        assertNull(context.getPlayer().getInventory().GetByItemCode("book"));
+    }
+
+    @Test
+    void dropRestoresInventoryCapacity() {
+        int before = context.getPlayer().getInventory().GetRemainingCapacity();
+        execute("drop book 1", context);
+        assertEquals(before + new Book().getBulk(), context.getPlayer().getInventory().GetRemainingCapacity());
+    }
+
+    @Test
+    void dropReturnsSuccessState() {
+        CommandResult result = execute("drop book 1", context);
+        assertEquals(CommandState.SUCCESS, result.getResultState());
+    }
+
+    @Test
+    void dropItemNotInInventoryReturnsItemNotFound() {
+        CommandResult result = execute("drop mouldy_cheese 1", context);
+        assertEquals(CommandState.ITEM_NOT_FOUND, result.getResultState());
+    }
+
+    @Test
+    void dropWithNoParamsReturnsInvalidParams() {
+        CommandResult result = execute("drop", context);
+        assertEquals(CommandState.INVALID_PARAMS, result.getResultState());
+    }
+
+    @Test
+    void dropMoreThanStackDropsWholeStack() {
+        execute("drop book 100", context);
+        assertNull(context.getPlayer().getInventory().GetByItemCode("book"));
+    }
+
+    @Test
+    void dropWhenRoomFullDropsPartially() {
+        // Bedroom capacity is 20, already has Bed(1) and Money(1) = 2 used
+        // Fill the room to near capacity then try to drop more
+        context.getMap().getCurrentRoom().getItems().Add(new Book(), 5); // 5*3=15 + 2 existing = 17 used, 3 remaining
+        // room has 3 bulk left, book bulk=3 so exactly 1 more book fits
+        // drop 2 books — only 1 should go through
+        CommandResult result = execute("drop book 2", context);
+        assertEquals(CommandState.SUCCESS, result.getResultState());
+        assertTrue(result.getResultMessage().contains("cluttered"));
+    }
+
+    @Test
+    void dropWithNonNumberAmountDefaultsToOne() {
+        // "drop book abc" — second param parse fails → INVALID_PARAMS
+        CommandResult result = execute("drop book abc", context);
+        assertEquals(CommandState.INVALID_PARAMS, result.getResultState());
+    }
+}

test/cz/davza/studentadventure/commands/InteractCommandTest.java

@@ -0,0 +1,60 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.Items.Book;
+import cz.davza.studentadventure.Items.Computer;
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static cz.davza.studentadventure.TestHelpers.execute;
+import static org.junit.jupiter.api.Assertions.*;
+
+class InteractCommandTest {
+
+    private GameData context;
+
+    @BeforeEach
+    void setUp() {
+        context = TestHelpers.buildGameData();
+        // Walk to computer lab: bedroom → hallway → studyroom → computerlab
+        context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("hallway"));
+        context.getMap().commitRoomChange();
+        context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("studyroom"));
+        context.getMap().commitRoomChange();
+        context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("computerlab"));
+        context.getMap().commitRoomChange();
+    }
+
+    @Test
+    void interactWithComputerReturnsActionPending() {
+        CommandResult result = execute("interact computer", context);
+        assertEquals(CommandState.ACTION_PENDING, result.getResultState());
+    }
+
+    @Test
+    void interactWithComputerSetsNewHandler() {
+        CommandResult result = execute("interact computer", context);
+        assertNotNull(result.getNewCommandHandler());
+    }
+
+    @Test
+    void interactWithNonExistentItemReturnsNotInteractable() {
+        CommandResult result = execute("interact ghost", context);
+        assertEquals(CommandState.ITEM_NOT_INTERACTABLE, result.getResultState());
+    }
+
+    @Test
+    void interactWithCollectableReturnsNotInteractable() {
+        // Book is in computer lab and is collectable, not interactable
+        CommandResult result = execute("interact book", context);
+        assertEquals(CommandState.ITEM_NOT_INTERACTABLE, result.getResultState());
+    }
+
+    @Test
+    void interactWithNoParamsReturnsInvalidParams() {
+        CommandResult result = execute("interact", context);
+        assertEquals(CommandState.INVALID_PARAMS, result.getResultState());
+    }
+}

test/cz/davza/studentadventure/commands/PickupCommandTest.java

@@ -0,0 +1,90 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.Items.Book;
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static cz.davza.studentadventure.TestHelpers.execute;
+import static org.junit.jupiter.api.Assertions.*;
+
+class PickupCommandTest {
+
+    private GameData context;
+
+    @BeforeEach
+    void setUp() {
+        context = TestHelpers.buildGameData();
+        // Bedroom starts with a Bed and Money — add a Book for pickup tests
+        context.getMap().getCurrentRoom().getItems().Add(new Book(), 3);
+    }
+
+    @Test
+    void pickupItemAddsToInventory() {
+        execute("pickup book", context);
+        assertNotNull(context.getPlayer().getInventory().GetByItemCode("book"));
+    }
+
+    @Test
+    void pickupItemRemovesFromRoom() {
+        int before = context.getMap().getCurrentRoom().getItems().GetByItemCode("book").getAmount();
+        execute("pickup book", context);
+        int after = context.getMap().getCurrentRoom().getItems().GetByItemCode("book").getAmount();
+        assertEquals(before - 1, after);
+    }
+
+    @Test
+    void pickupSpecificAmountPicksCorrectNumber() {
+        execute("pickup book 2", context);
+        assertEquals(2, context.getPlayer().getInventory().GetByItemCode("book").getAmount());
+    }
+
+    @Test
+    void pickupReturnsSuccessState() {
+        CommandResult result = execute("pickup book", context);
+        assertEquals(CommandState.SUCCESS, result.getResultState());
+    }
+
+    @Test
+    void pickupNonExistentItemReturnsItemNotFound() {
+        CommandResult result = execute("pickup energy_drink", context);
+        assertEquals(CommandState.ITEM_NOT_FOUND, result.getResultState());
+    }
+
+    @Test
+    void pickupNonCollectableReturnsNotCollectable() {
+        // Bed is in bedroom and is not collectable
+        CommandResult result = execute("pickup bed", context);
+        assertEquals(CommandState.ITEM_NOT_COLLECTABLE, result.getResultState());
+    }
+
+    @Test
+    void pickupWithNoParamsReturnsInvalidParams() {
+        CommandResult result = execute("pickup", context);
+        assertEquals(CommandState.INVALID_PARAMS, result.getResultState());
+    }
+
+    @Test
+    void pickupWhenInventoryFullReturnsInventoryFull() {
+        // Fill inventory: capacity 20, book bulk 3 → 6 books fill 18, 7th won't all fit
+        context.getMap().getCurrentRoom().getItems().Add(new Book(), 10);
+        // Add 6 books to inventory (uses 18 capacity, 2 remaining — not enough for another book at bulk 3)
+        context.getPlayer().getInventory().Add(new Book(), 6);
+        CommandResult result = execute("pickup book 1", context);
+        assertEquals(CommandState.INVENTORY_FULL, result.getResultState());
+    }
+
+    @Test
+    void pickupWithNonNumberAmountReturnsInvalidParams() {
+        CommandResult result = execute("pickup book abc", context);
+        assertEquals(CommandState.INVALID_PARAMS, result.getResultState());
+    }
+
+    @Test
+    void pickupDefaultsToOneWhenNoAmountGiven() {
+        execute("pickup book", context);
+        assertEquals(1, context.getPlayer().getInventory().GetByItemCode("book").getAmount());
+    }
+}

test/cz/davza/studentadventure/commands/SleepCommandTest.java

@@ -0,0 +1,124 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.Player;
+import cz.davza.studentadventure.rooms.BedroomRoom;
+import cz.davza.studentadventure.rooms.ClassroomRoom;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import java.util.ArrayList;
+import java.util.List;
+import static cz.davza.studentadventure.TestHelpers.execute;
+import static org.junit.jupiter.api.Assertions.*;
+
+class SleepCommandTest {
+
+    private GameData context;
+    private Player player;
+
+    @BeforeEach
+    void setUp() {
+        context = TestHelpers.buildGameData();
+        player  = context.getPlayer();
+        // Starting room is Bedroom — sleep is valid here immediately
+    }
+
+    @Test
+    void sleepInBedroomReturnsSuccess() {
+        CommandResult result = execute("sleep", context);
+        assertEquals(CommandState.SUCCESS, result.getResultState());
+    }
+
+    @Test
+    void sleepInBedroomRestoresEnergy() {
+        player.getEnergy().decrease(50);
+        execute("sleep", context);
+        assertEquals(100, player.getEnergy().getValue());
+    }
+
+    @Test
+    void sleepInBedroomReducesStress() {
+        player.getStress().increase(60);
+        execute("sleep", context);
+        assertEquals(0, player.getStress().getValue());
+    }
+
+    @Test
+    void sleepInBedroomResetsHoursAwake() {
+        player.addHoursAwake(20);
+        execute("sleep", context);
+        assertEquals(cz.davza.studentadventure.enums.DeprivationState.NORMAL,
+                player.getDeprivationState());
+    }
+
+    @Test
+    void sleepInBedroomAdvancesToNextMorning() {
+        execute("sleep", context);
+        assertEquals(2, context.getTime().getDay());
+        assertEquals(8, context.getTime().getHour());
+    }
+
+    @Test
+    void sleepOutsideBedroomAndClassroomFails() {
+        // Walk to hallway first
+        context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("hallway"));
+        context.getMap().commitRoomChange();
+        CommandResult result = execute("sleep", context);
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+
+    @Test
+    void sleepInClassroomAdvancesTimeBy2Hours() {
+        // Move player to classroom — need book to enter
+        context.getPlayer().getInventory().Add(new cz.davza.studentadventure.Items.Book(), 1);
+        context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("hallway"));
+        context.getMap().commitRoomChange();
+        context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("classroom"));
+        context.getMap().commitRoomChange();
+
+        int hourBefore = context.getTime().getHour();
+        // Run many times to guarantee we hit the success path at least once
+        // (30% catch chance means ~99.9% chance of success in 20 attempts)
+        boolean succeeded = false;
+        for (int i = 0; i < 20; i++) {
+            context = TestHelpers.buildGameData();
+            player  = context.getPlayer();
+            player.getInventory().Add(new cz.davza.studentadventure.Items.Book(), 1);
+            context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("hallway"));
+            context.getMap().commitRoomChange();
+            context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("classroom"));
+            context.getMap().commitRoomChange();
+            int before = context.getTime().getHour();
+            CommandResult result = execute("sleep", context);
+            if (result.getResultState() == CommandState.SUCCESS) {
+                assertEquals(before + 2, context.getTime().getHour());
+                succeeded = true;
+                break;
+            }
+        }
+        assertTrue(succeeded, "Expected at least one successful classroom sleep in 20 attempts");
+    }
+
+    @Test
+    void sleepInClassroomCanReturnGameOver() {
+        // Run many times to guarantee we hit the caught path
+        boolean caughtOnce = false;
+        for (int i = 0; i < 50; i++) {
+            GameData ctx = TestHelpers.buildGameData();
+            ctx.getPlayer().getInventory().Add(new cz.davza.studentadventure.Items.Book(), 1);
+            ctx.getMap().setNextRoom(ctx.getMap().getCurrentRoom().getExit("hallway"));
+            ctx.getMap().commitRoomChange();
+            ctx.getMap().setNextRoom(ctx.getMap().getCurrentRoom().getExit("classroom"));
+            ctx.getMap().commitRoomChange();
+            CommandResult result = execute("sleep", ctx);
+            if (result.getResultState() == CommandState.GAME_OVER) {
+                caughtOnce = true;
+                break;
+            }
+        }
+        assertTrue(caughtOnce, "Expected to be caught sleeping at least once in 50 attempts");
+    }
+}

test/cz/davza/studentadventure/commands/StealCommandTest.java

@@ -0,0 +1,96 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.Player;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static cz.davza.studentadventure.TestHelpers.execute;
+import static org.junit.jupiter.api.Assertions.*;
+
+class StealCommandTest {
+
+    private GameData context;
+    private Player player;
+
+    @BeforeEach
+    void setUp() {
+        context = TestHelpers.buildGameData();
+        player  = context.getPlayer();
+    }
+
+    @Test
+    void stealCanSucceedAndAddMoney() {
+        boolean succeededOnce = false;
+        int startMoney = player.getWallet().getMoney();
+        for (int i = 0; i < 50; i++) {
+            context = TestHelpers.buildGameData();
+            player  = context.getPlayer();
+            CommandResult result = execute("steal", context);
+            if (result.getResultState() == CommandState.SUCCESS) {
+                assertTrue(player.getWallet().getMoney() > startMoney);
+                succeededOnce = true;
+                break;
+            }
+        }
+        assertTrue(succeededOnce, "Expected steal to succeed at least once in 50 attempts");
+    }
+
+    @Test
+    void stealCanReturnGameOver() {
+        boolean caughtOnce = false;
+        for (int i = 0; i < 50; i++) {
+            context = TestHelpers.buildGameData();
+            CommandResult result = execute("steal", context);
+            if (result.getResultState() == CommandState.GAME_OVER) {
+                caughtOnce = true;
+                break;
+            }
+        }
+        assertTrue(caughtOnce, "Expected to be caught stealing at least once in 50 attempts");
+    }
+
+    @Test
+    void stealInDesperateStateHasLowerCatchChance() {
+        // Desperate: stress > 70, energy < 30
+        // Run many attempts and count game overs vs successes in desperate vs normal
+        // Desperate should have fewer game overs (15% vs 40%)
+        int desperateGameOvers = 0;
+        int normalGameOvers = 0;
+        int trials = 200;
+
+        for (int i = 0; i < trials; i++) {
+            GameData ctx = TestHelpers.buildGameData();
+            ctx.getPlayer().getStress().increase(80);
+            ctx.getPlayer().getEnergy().decrease(80);
+            if (execute("steal", ctx).getResultState() == CommandState.GAME_OVER) desperateGameOvers++;
+        }
+        for (int i = 0; i < trials; i++) {
+            GameData ctx = TestHelpers.buildGameData();
+            if (execute("steal", ctx).getResultState() == CommandState.GAME_OVER) normalGameOvers++;
+        }
+
+        // With 200 trials, desperate (~15%) should have noticeably fewer than normal (~40%)
+        assertTrue(desperateGameOvers < normalGameOvers,
+                "Desperate steal should be caught less often. Desperate: " + desperateGameOvers
+                        + " Normal: " + normalGameOvers);
+    }
+
+    @Test
+    void stealMoneyAmountIsWithinExpectedRange() {
+        for (int i = 0; i < 50; i++) {
+            context = TestHelpers.buildGameData();
+            player  = context.getPlayer();
+            int before = player.getWallet().getMoney();
+            CommandResult result = execute("steal", context);
+            if (result.getResultState() == CommandState.SUCCESS) {
+                int gained = player.getWallet().getMoney() - before;
+                assertTrue(gained >= 10 && gained <= 40,
+                        "Expected stolen amount 10-40, got " + gained);
+                return;
+            }
+        }
+    }
+}

test/cz/davza/studentadventure/commands/StudyCommandTest.java

@@ -0,0 +1,133 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.enums.DeprivationState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.Player;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static cz.davza.studentadventure.TestHelpers.execute;
+import static org.junit.jupiter.api.Assertions.*;
+
+class StudyCommandTest {
+
+    private GameData context;
+    private Player player;
+
+    @BeforeEach
+    void setUp() {
+        context = TestHelpers.buildGameData();
+        player  = context.getPlayer();
+    }
+
+    @Test
+    void studyOneHourIncreasesIntelligenceBy5() {
+        execute("study 1", context);
+        assertEquals(10, player.getIntelligence().getValue());
+    }
+
+    @Test
+    void studyOneHourCostsEnergy() {
+        int before = player.getEnergy().getValue();
+        execute("study 1", context);
+        assertTrue(player.getEnergy().getValue() < before);
+    }
+
+    @Test
+    void studyOneHourIncreasesStress() {
+        execute("study 1", context);
+        assertTrue(player.getStress().getValue() > 0);
+    }
+
+    @Test
+    void studyOneHourAdvancesTimeByOneHour() {
+        int before = context.getTime().getHour();
+        execute("study 1", context);
+        assertEquals(before + 1, context.getTime().getHour());
+    }
+
+    @Test
+    void studyMultipleHoursStacksGains() {
+        execute("study 3", context);
+        assertEquals(5 + 15, player.getIntelligence().getValue());
+    }
+
+    @Test
+    void studyMultipleHoursAdvancesTimeByThatMany() {
+        int before = context.getTime().getHour();
+        execute("study 3", context);
+        assertEquals(before + 3, context.getTime().getHour());
+    }
+
+    @Test
+    void studyWithNoParamsReturnsInvalidParams() {
+        CommandResult result = execute("study", context);
+        assertEquals(CommandState.INVALID_PARAMS, result.getResultState());
+    }
+
+    @Test
+    void studyWithZeroHoursReturnsInvalidParams() {
+        CommandResult result = execute("study 0", context);
+        assertEquals(CommandState.INVALID_PARAMS, result.getResultState());
+    }
+
+    @Test
+    void studyWithNegativeHoursReturnsInvalidParams() {
+        CommandResult result = execute("study -1", context);
+        assertEquals(CommandState.INVALID_PARAMS, result.getResultState());
+    }
+
+    @Test
+    void studyWithNonNumberReturnsInvalidParams() {
+        CommandResult result = execute("study abc", context);
+        assertEquals(CommandState.INVALID_PARAMS, result.getResultState());
+    }
+
+    @Test
+    void studyWhenEnergyZeroReturnsFailed() {
+        player.getEnergy().decrease(100);
+        CommandResult result = execute("study 1", context);
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+
+    @Test
+    void studyStopsEarlyWhenEnergyRunsOut() {
+        player.getEnergy().decrease(85); // 15 energy left, first hour costs ~10, second ~13 → stops at 1
+        CommandResult result = execute("study 2", context);
+        assertEquals(CommandState.SUCCESS, result.getResultState());
+        assertTrue(result.getResultMessage().contains("run out of energy"));
+    }
+
+    @Test
+    void studyAddsToHoursAwakeCounter() {
+        execute("study 3", context);
+        // 3 hours awake is still NORMAL (threshold is 14)
+        assertEquals(DeprivationState.NORMAL, player.getDeprivationState());
+    }
+
+    @Test
+    void studyReturnsSuccessState() {
+        CommandResult result = execute("study 1", context);
+        assertEquals(CommandState.SUCCESS, result.getResultState());
+    }
+
+    @Test
+    void studyCostsMoreEnergyWithDeprivation() {
+        // Push player to deprived state
+        player.addHoursAwake(25);
+        int energyBefore = player.getEnergy().getValue();
+        execute("study 1", context);
+        int energyCostDeprived = energyBefore - player.getEnergy().getValue();
+
+        // Reset and do the same at normal state
+        context = TestHelpers.buildGameData();
+        player  = context.getPlayer();
+        int energyBefore2 = player.getEnergy().getValue();
+        execute("study 1", context);
+        int energyCostNormal = energyBefore2 - player.getEnergy().getValue();
+
+        assertTrue(energyCostDeprived > energyCostNormal);
+    }
+}

test/cz/davza/studentadventure/commands/TakeExamCommandTest.java

@@ -0,0 +1,98 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import cz.davza.studentadventure.objects.Player;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static cz.davza.studentadventure.TestHelpers.execute;
+import static org.junit.jupiter.api.Assertions.*;
+
+class TakeExamCommandTest {
+
+    private GameData context;
+    private Player player;
+
+    @BeforeEach
+    void setUp() {
+        context = TestHelpers.buildGameData();
+        player  = context.getPlayer();
+    }
+
+    @Test
+    void examPassesWhenIntelligenceHighEnough() {
+        // Need effectiveScore >= 50. intelligence - stress/10 >= 50
+        // Set intelligence to 50, stress to 0 → score = 50
+        player.getIntelligence().increase(100); // clamps to 100
+        CommandResult result = execute("takeexam", context);
+        assertEquals(CommandState.GAME_WIN, result.getResultState());
+    }
+
+    @Test
+    void examFailsWhenIntelligenceTooLow() {
+        // Default intelligence = 5, stress = 0 → score = 5, need 50 → fail
+        CommandResult result = execute("takeexam", context);
+        assertEquals(CommandState.GAME_OVER, result.getResultState());
+    }
+
+    @Test
+    void examStressPenaltyReducesScore() {
+        // intelligence 60, stress 100 → penalty 10 → score 50 → just passes
+        player.getIntelligence().increase(100); // 100
+        player.getStress().increase(100);       // 100 → penalty 10
+        // effectiveScore = 100 - 10 = 90 → passes
+        CommandResult result = execute("takeexam", context);
+        assertEquals(CommandState.GAME_WIN, result.getResultState());
+    }
+
+    @Test
+    void examFailsWhenStressPenaltyPullsScoreBelow50() {
+        // intelligence = 55, stress = 100 → penalty 10 → score 45 → fail
+        player.getIntelligence().increase(50); // starts at 5, becomes 55
+        player.getStress().increase(100);
+        CommandResult result = execute("takeexam", context);
+        assertEquals(CommandState.GAME_OVER, result.getResultState());
+    }
+
+    @Test
+    void examPassMessageContainsDistinctionWhenScoreAbove80() {
+        player.getIntelligence().increase(100); // 100
+        // stress = 0 → score = 100 → distinction
+        CommandResult result = execute("takeexam", context);
+        assertTrue(result.getResultMessage().contains("DISTINCTION"));
+    }
+
+    @Test
+    void examPassMessageContainsMeritWhenScoreBetween65And80() {
+        // Need score 65-79: intelligence 70, stress 0 → score 70
+        player.getIntelligence().increase(65); // 5 + 65 = 70
+        CommandResult result = execute("takeexam", context);
+        assertTrue(result.getResultMessage().contains("MERIT"));
+    }
+
+    @Test
+    void examPassMessageContainsPassWhenScoreBetween50And64() {
+        // Need score 50-64: intelligence 55, stress 0 → score 55
+        player.getIntelligence().increase(50); // 5 + 50 = 55
+        CommandResult result = execute("takeexam", context);
+        assertTrue(result.getResultMessage().contains("RESULT: PASS\n"));
+    }
+
+    @Test
+    void examScoreExactlyAtThresholdPasses() {
+        // intelligence = 50, stress 0 → score exactly 50 → pass
+        player.getIntelligence().increase(45); // 5 + 45 = 50
+        CommandResult result = execute("takeexam", context);
+        assertEquals(CommandState.GAME_WIN, result.getResultState());
+    }
+
+    @Test
+    void examScoreOneBelowThresholdFails() {
+        // intelligence = 49, stress 0 → score 49 → fail
+        player.getIntelligence().increase(44); // 5 + 44 = 49
+        CommandResult result = execute("takeexam", context);
+        assertEquals(CommandState.GAME_OVER, result.getResultState());
+    }
+}

test/cz/davza/studentadventure/commands/WalkCommandTest.java

@@ -0,0 +1,100 @@
+package cz.davza.studentadventure.commands;
+
+import cz.davza.studentadventure.Items.Book;
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static cz.davza.studentadventure.TestHelpers.execute;
+import static org.junit.jupiter.api.Assertions.*;
+
+class WalkCommandTest {
+
+    private GameData context;
+
+    @BeforeEach
+    void setUp() {
+        context = TestHelpers.buildGameData();
+        // starts in Bedroom
+    }
+
+    @Test
+    void walkToValidExitSetsNextRoom() {
+        execute("walk hallway", context);
+        assertTrue(context.getMap().hasPendingRoomChange());
+    }
+
+    @Test
+    void walkToValidExitReturnsRoomChanged() {
+        CommandResult result = execute("walk hallway", context);
+        assertEquals(CommandState.ROOM_CHANGED, result.getResultState());
+    }
+
+    @Test
+    void walkAdvancesTimeByTwoHours() {
+        int before = context.getTime().getHour();
+        execute("walk hallway", context);
+        assertEquals(before + 2, context.getTime().getHour());
+    }
+
+    @Test
+    void walkAdvancesHoursAwake() {
+        execute("walk hallway", context);
+        // 1 hour awake — still NORMAL
+        assertEquals(cz.davza.studentadventure.enums.DeprivationState.NORMAL,
+                context.getPlayer().getDeprivationState());
+    }
+
+    @Test
+    void walkToInvalidExitReturnsFailed() {
+        CommandResult result = execute("walk narnia", context);
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+
+    @Test
+    void walkWithNoParamsReturnsInvalidParams() {
+        CommandResult result = execute("walk", context);
+        assertEquals(CommandState.INVALID_PARAMS, result.getResultState());
+    }
+
+    @Test
+    void walkToClassroomWithoutBookReturnsFailed() {
+        // Bedroom → hallway (commit) → classroom (no book)
+        execute("walk hallway", context);
+        context.getMap().commitRoomChange();
+        CommandResult result = execute("walk classroom", context);
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+
+    @Test
+    void walkToClassroomWithoutBookAppliesStressPenalty() {
+        execute("walk hallway", context);
+        context.getMap().commitRoomChange();
+        int stressBefore = context.getPlayer().getStress().getValue();
+        execute("walk classroom", context);
+        assertTrue(context.getPlayer().getStress().getValue() > stressBefore);
+    }
+
+    @Test
+    void walkToClassroomWithBookReturnsRoomChanged() {
+        context.getPlayer().getInventory().Add(new Book(), 1);
+        execute("walk hallway", context);
+        context.getMap().commitRoomChange();
+        CommandResult result = execute("walk classroom", context);
+        assertEquals(CommandState.ROOM_CHANGED, result.getResultState());
+    }
+
+    @Test
+    void walkToExamRoomReturnsActionPending() {
+        // Bedroom → hallway → classroom (with book) → examroom
+        context.getPlayer().getInventory().Add(new Book(), 1);
+        execute("walk hallway", context);
+        context.getMap().commitRoomChange();
+        execute("walk classroom", context);
+        context.getMap().commitRoomChange();
+        CommandResult result = execute("walk examroom", context);
+        assertEquals(CommandState.ACTION_PENDING, result.getResultState());
+    }
+}

test/cz/davza/studentadventure/integration/GameIntegrationTest.java

@@ -0,0 +1,147 @@
+package cz.davza.studentadventure.integration;
+
+import cz.davza.studentadventure.Items.Book;
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.TestHelpers.CapturingOutputSink;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.Game;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class GameIntegrationTest {
+
+    private Game game;
+    private CapturingOutputSink sink;
+
+    @BeforeEach
+    void setUp() {
+        sink = new CapturingOutputSink();
+        game = new Game(sink);
+    }
+
+    @Test
+    void quitReturnsGameOver() {
+        CommandResult result = game.sendCommand("quit");
+        assertEquals(CommandState.GAME_OVER, result.getResultState());
+    }
+
+    @Test
+    void commandAfterQuitIsRejected() {
+        game.sendCommand("quit");
+        CommandResult result = game.sendCommand("study 1");
+        assertEquals(CommandState.GAME_OVER, result.getResultState());
+    }
+
+    @Test
+    void unknownCommandReturnsFailed() {
+        CommandResult result = game.sendCommand("fly");
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+
+    @Test
+    void walkToHallwayChangesRoom() {
+        CommandResult result = game.sendCommand("walk hallway");
+        assertEquals(CommandState.ROOM_CHANGED, result.getResultState());
+        assertEquals("hallway", game.getContext().getMap().getCurrentRoom().getExitCode());
+    }
+
+    @Test
+    void walkToInvalidRoomFails() {
+        CommandResult result = game.sendCommand("walk narnia");
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+
+    @Test
+    void studyInBedroomWorks() {
+        int intBefore = game.getContext().getPlayer().getIntelligence().getValue();
+        game.sendCommand("study 1");
+        assertEquals(intBefore + 5, game.getContext().getPlayer().getIntelligence().getValue());
+    }
+
+    @Test
+    void deadlinePassedCausesGameOver() {
+        // Advance time past day 7, 09:00
+        for (int i = 0; i < 7; i++) game.getContext().getTime().advanceToNextMorning();
+        game.getContext().getTime().advanceHours(2);
+        // Any command should trigger the deadline check
+        CommandResult result = game.sendCommand("stats");
+        assertEquals(CommandState.GAME_OVER, result.getResultState());
+    }
+
+    @Test
+    void stressAt100CausesGameOver() {
+        game.getContext().getPlayer().getStress().increase(100);
+        CommandResult result = game.sendCommand("stats");
+        assertEquals(CommandState.GAME_OVER, result.getResultState());
+    }
+
+    @Test
+    void fullWalkSequenceBedroomToHallway() {
+        game.sendCommand("walk hallway");
+        assertEquals("hallway", game.getContext().getMap().getCurrentRoom().getExitCode());
+    }
+
+    @Test
+    void enteringClassroomWithoutBookFails() {
+        game.sendCommand("walk hallway");
+        CommandResult result = game.sendCommand("walk classroom");
+        assertEquals(CommandState.FAILED, result.getResultState());
+        // should still be in hallway
+        assertEquals("hallway", game.getContext().getMap().getCurrentRoom().getExitCode());
+    }
+
+    @Test
+    void fullPathToExamAndPass() {
+        // Max out intelligence, walk to exam room, enter with correct ID, take exam
+        game.getContext().getPlayer().getIntelligence().increase(100);
+        game.getContext().getPlayer().getInventory().Add(new Book(), 1);
+
+        game.sendCommand("walk hallway");
+        game.sendCommand("walk classroom");
+        game.sendCommand("walk examroom"); // triggers ID prompt
+
+        String studentId = game.getContext().getPlayer().getId();
+        game.sendCommand(studentId); // enter exam room
+
+        CommandResult result = game.sendCommand("takeexam");
+        assertEquals(CommandState.GAME_WIN, result.getResultState());
+    }
+
+    @Test
+    void buyAndConsumeEnergyDrinkFlow() {
+        // Walk to shop: hallway → studyroom → computerlab → shop
+        game.sendCommand("walk hallway");
+        game.sendCommand("walk studyroom");
+        game.sendCommand("walk computerlab");
+        game.sendCommand("walk shop");
+
+        game.getContext().getPlayer().getEnergy().decrease(50);
+        int energyBefore = game.getContext().getPlayer().getEnergy().getValue();
+
+        game.sendCommand("buy energy_drink");
+        game.sendCommand("consume energy_drink");
+
+        assertTrue(game.getContext().getPlayer().getEnergy().getValue() > energyBefore);
+    }
+
+    @Test
+    void computerInteractionFullFlow() {
+        game.sendCommand("walk hallway");
+        game.sendCommand("walk studyroom");
+        game.sendCommand("walk computerlab");
+
+        game.sendCommand("interact computer");       // → asks for password
+        game.sendCommand("wrongpassword");           // → wrong
+        game.sendCommand("java123");                 // → correct, now active
+
+        int intBefore = game.getContext().getPlayer().getIntelligence().getValue();
+        game.sendCommand("study 1");                 // study while at computer
+        assertEquals(intBefore + 5,
+                game.getContext().getPlayer().getIntelligence().getValue());
+
+        CommandResult result = game.sendCommand("exit"); // leave computer
+        assertEquals(CommandState.ACTION_RESUMED, result.getResultState());
+    }
+}

test/cz/davza/studentadventure/items/ComputerTest.java

@@ -0,0 +1,103 @@
+package cz.davza.studentadventure.items;
+
+import cz.davza.studentadventure.Items.Computer;
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class ComputerTest {
+
+    private Computer computer;
+    private GameData context;
+    private static final String PASSWORD = "java123";
+
+    @BeforeEach
+    void setUp() {
+        context  = TestHelpers.buildGameData();
+        computer = new Computer(PASSWORD);
+        // Navigate to computer lab where study is allowed
+        context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("hallway"));
+        context.getMap().commitRoomChange();
+        context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("studyroom"));
+        context.getMap().commitRoomChange();
+        context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("computerlab"));
+        context.getMap().commitRoomChange();
+    }
+
+    @Test
+    void interactWhileLockedRequestsPassword() {
+        CommandResult result = computer.Interact(context);
+        assertEquals(CommandState.ACTION_PENDING, result.getResultState());
+        assertTrue(result.getResultMessage().contains("locked"));
+    }
+
+    @Test
+    void exitWhileAtPasswordPromptResumesGame() {
+        computer.Interact(context);
+        CommandResult result = computer.handleCommand("exit", context);
+        assertEquals(CommandState.ACTION_RESUMED, result.getResultState());
+    }
+
+    @Test
+    void wrongPasswordReturnsFailed() {
+        computer.Interact(context);
+        CommandResult result = computer.handleCommand("wrongpass", context);
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+
+    @Test
+    void wrongPasswordKeepsComputerLocked() {
+        computer.Interact(context);
+        computer.handleCommand("wrongpass", context);
+        // Should still be locked — interacting again should ask for password
+        CommandResult result = computer.Interact(context);
+        assertTrue(result.getResultMessage().contains("locked"));
+    }
+
+    @Test
+    void correctPasswordUnlocksComputer() {
+        computer.Interact(context);
+        CommandResult result = computer.handleCommand(PASSWORD, context);
+        // Should return success (handler already on computer)
+        assertEquals(CommandState.SUCCESS, result.getResultState());
+    }
+
+    @Test
+    void afterUnlockInteractGoesActiveNotPassword() {
+        computer.Interact(context);
+        computer.handleCommand(PASSWORD, context);
+        // Next interact should go straight to active state
+        CommandResult result = computer.Interact(context);
+        assertEquals(CommandState.ACTION_PENDING, result.getResultState());
+        assertFalse(result.getResultMessage().contains("locked"));
+    }
+
+    @Test
+    void exitWhileActiveResumesGame() {
+        computer.Interact(context);
+        computer.handleCommand(PASSWORD, context);
+        CommandResult result = computer.handleCommand("exit", context);
+        assertEquals(CommandState.ACTION_RESUMED, result.getResultState());
+    }
+
+    @Test
+    void studyCommandWorksWhileActiveOnComputer() {
+        computer.Interact(context);
+        computer.handleCommand(PASSWORD, context);
+        int intBefore = context.getPlayer().getIntelligence().getValue();
+        computer.handleCommand("study 1", context);
+        assertEquals(intBefore + 5, context.getPlayer().getIntelligence().getValue());
+    }
+
+    @Test
+    void unknownCommandWhileActiveReturnsFailed() {
+        computer.Interact(context);
+        computer.handleCommand(PASSWORD, context);
+        CommandResult result = computer.handleCommand("sleep", context);
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+}

test/cz/davza/studentadventure/objects/GameTimeTest.java

@@ -0,0 +1,84 @@
+package cz.davza.studentadventure.objects;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class GameTimeTest {
+
+    @Test
+    void startsOnDay1At8() {
+        GameTime time = new GameTime();
+        assertEquals(1, time.getDay());
+        assertEquals(8, time.getHour());
+    }
+
+    @Test
+    void advanceHoursWithinSameDay() {
+        GameTime time = new GameTime();
+        time.advanceHours(3);
+        assertEquals(1, time.getDay());
+        assertEquals(11, time.getHour());
+    }
+
+    @Test
+    void advanceHoursRollsOverToNextDay() {
+        GameTime time = new GameTime();
+        time.advanceHours(20); // 8 + 20 = 28 → day 2, hour 4
+        assertEquals(2, time.getDay());
+        assertEquals(4, time.getHour());
+    }
+
+    @Test
+    void advanceHoursRollsOverMultipleDays() {
+        GameTime time = new GameTime();
+        time.advanceHours(48); // 8 + 48 = 56 → day 3, hour 8
+        assertEquals(3, time.getDay());
+        assertEquals(8, time.getHour());
+    }
+
+    @Test
+    void advanceToNextMorningSetsDay2Hour8() {
+        GameTime time = new GameTime();
+        time.advanceHours(5); // move to hour 13
+        time.advanceToNextMorning();
+        assertEquals(2, time.getDay());
+        assertEquals(8, time.getHour());
+    }
+
+    @Test
+    void notPastDeadlineAtStart() {
+        GameTime time = new GameTime();
+        assertFalse(time.isPastDeadline());
+    }
+
+    @Test
+    void notPastDeadlineJustBeforeExam() {
+        GameTime time = new GameTime();
+        // advance to day 7, hour 8 — one hour before deadline
+        for (int i = 0; i < 6; i++) time.advanceToNextMorning();
+        assertEquals(7, time.getDay());
+        assertEquals(8, time.getHour());
+        assertFalse(time.isPastDeadline());
+    }
+
+    @Test
+    void pastDeadlineAtExactDeadline() {
+        GameTime time = new GameTime();
+        for (int i = 0; i < 6; i++) time.advanceToNextMorning();
+        time.advanceHours(1); // day 7, hour 9
+        assertTrue(time.isPastDeadline());
+    }
+
+    @Test
+    void pastDeadlineAfterDay7() {
+        GameTime time = new GameTime();
+        for (int i = 0; i < 7; i++) time.advanceToNextMorning();
+        assertTrue(time.isPastDeadline());
+    }
+
+    @Test
+    void toStringFormat() {
+        GameTime time = new GameTime();
+        assertEquals("Day 1, 08:00", time.toString());
+    }
+}

test/cz/davza/studentadventure/objects/ItemCollectionBaseTest.java

@@ -0,0 +1,170 @@
+package cz.davza.studentadventure.objects;
+
+import cz.davza.studentadventure.Items.Book;
+import cz.davza.studentadventure.Items.EnergyDrink;
+import cz.davza.studentadventure.Items.StickyNote;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests ItemCollectionBase behaviour through PlayerInventory.
+ * Inventory capacity = 20 bulk units.
+ * Book bulk = 3, EnergyDrink bulk = 2, StickyNote bulk = 1.
+ */
+class ItemCollectionBaseTest {
+
+    private PlayerInventory inventory;
+
+    @BeforeEach
+    void setUp() {
+        inventory = new PlayerInventory(20);
+    }
+
+    // ── Add ──────────────────────────────────────────────────────────────────
+
+    @Test
+    void addItemIncreasesUsedCapacity() {
+        inventory.Add(new Book(), 1);
+        assertEquals(20 - 3, inventory.GetRemainingCapacity());
+    }
+
+    @Test
+    void addMultipleItemsStackUnderSameKey() {
+        inventory.Add(new Book(), 2);
+        ItemStack stack = inventory.GetByItemCode("book");
+        assertNotNull(stack);
+        assertEquals(2, stack.getAmount());
+    }
+
+    @Test
+    void addReturnsZeroWhenAllFit() {
+        int leftOver = inventory.Add(new Book(), 2); // costs 6 bulk, capacity 20
+        assertEquals(0, leftOver);
+    }
+
+    @Test
+    void addReturnsLeftoverWhenCapacityExceeded() {
+        // capacity 20, book bulk 3 → can fit 6 books (18 bulk), 7th won't fit
+        int leftOver = inventory.Add(new Book(), 7);
+        assertEquals(1, leftOver);
+    }
+
+    @Test
+    void addToExistingStackMergesCorrectly() {
+        inventory.Add(new Book(), 2);
+        inventory.Add(new Book(), 1);
+        ItemStack stack = inventory.GetByItemCode("book");
+        assertEquals(3, stack.getAmount());
+    }
+
+    @Test
+    void addZeroBulkItemAlwaysFits() {
+        // StickyNote has bulk 1 actually — test with a full inventory of high-bulk items
+        // fill to 18 bulk (6 books), then add sticky note (bulk 1) — still 2 bulk remaining
+        inventory.Add(new Book(), 6);
+        int leftOver = inventory.Add(new StickyNote("test"), 1);
+        assertEquals(0, leftOver);
+    }
+
+    // ── Remove ───────────────────────────────────────────────────────────────
+
+    @Test
+    void removeDecreasesStackAmount() {
+        inventory.Add(new Book(), 3);
+        inventory.Remove("book", 1);
+        assertEquals(2, inventory.GetByItemCode("book").getAmount());
+    }
+
+    @Test
+    void removeDecrementsUsedCapacity() {
+        inventory.Add(new Book(), 2); // 6 bulk used
+        inventory.Remove("book", 1); // 3 bulk freed
+        assertEquals(20 - 3, inventory.GetRemainingCapacity());
+    }
+
+    @Test
+    void removeEntireStackClearsEntry() {
+        inventory.Add(new Book(), 2);
+        inventory.Remove("book", 2);
+        assertNull(inventory.GetByItemCode("book"));
+    }
+
+    @Test
+    void removeMoreThanStackSizeClearsEntry() {
+        inventory.Add(new Book(), 1);
+        inventory.Remove("book", 99);
+        assertNull(inventory.GetByItemCode("book"));
+    }
+
+    @Test
+    void removeNonExistentCodeDoesNotThrow() {
+        assertDoesNotThrow(() -> inventory.Remove("nonexistent", 1));
+    }
+
+    @Test
+    void removeRestoresCapacityCorrectly() {
+        inventory.Add(new EnergyDrink(), 3); // 6 bulk used
+        inventory.Remove("energy_drink", 3); // all removed
+        assertEquals(20, inventory.GetRemainingCapacity());
+    }
+
+    // ── GetByItemCode ────────────────────────────────────────────────────────
+
+    @Test
+    void getByItemCodeReturnsNullWhenNotPresent() {
+        assertNull(inventory.GetByItemCode("book"));
+    }
+
+    @Test
+    void getByItemCodeReturnsCorrectStack() {
+        inventory.Add(new Book(), 2);
+        ItemStack stack = inventory.GetByItemCode("book");
+        assertNotNull(stack);
+        assertEquals("book", stack.getItem().getCode());
+    }
+
+    // ── Capacity ─────────────────────────────────────────────────────────────
+
+    @Test
+    void remainingCapacityStartsAtFullCapacity() {
+        assertEquals(20, inventory.GetRemainingCapacity());
+    }
+
+    @Test
+    void capacityReturnsConfiguredMax() {
+        assertEquals(20, inventory.GetCapacity());
+    }
+
+    // ── Empty ────────────────────────────────────────────────────────────────
+
+    @Test
+    void emptyClearsAllItems() {
+        inventory.Add(new Book(), 2);
+        inventory.Add(new EnergyDrink(), 1);
+        inventory.Empty();
+        assertNull(inventory.GetByItemCode("book"));
+        assertNull(inventory.GetByItemCode("energy_drink"));
+    }
+
+    @Test
+    void emptyResetsUsedCapacity() {
+        inventory.Add(new Book(), 3);
+        inventory.Empty();
+        assertEquals(20, inventory.GetRemainingCapacity());
+    }
+
+    // ── GetItems ─────────────────────────────────────────────────────────────
+
+    @Test
+    void getItemsReturnsOnlyOccupiedEntries() {
+        inventory.Add(new Book(), 1);
+        inventory.Add(new EnergyDrink(), 1);
+        assertEquals(2, inventory.GetItems().size());
+    }
+
+    @Test
+    void getItemsIsEmptyWhenInventoryEmpty() {
+        assertTrue(inventory.GetItems().isEmpty());
+    }
+}

test/cz/davza/studentadventure/objects/ItemCollectionTest.java

@@ -0,0 +1,157 @@
+package cz.davza.studentadventure.objects;
+
+import cz.davza.studentadventure.Items.Book;
+import cz.davza.studentadventure.Items.EnergyDrink;
+import cz.davza.studentadventure.interfaces.IItem;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class ItemCollectionTest {
+
+    private PlayerInventory inventory;
+    private IItem book;
+    private IItem drink;
+
+    @BeforeEach
+    void setUp() {
+        inventory = new PlayerInventory(20); // capacity of 20 bulk
+        book  = new Book();       // bulk = 3
+        drink = new EnergyDrink();// bulk = 2
+    }
+
+    // ── Add ──────────────────────────────────────────────────────────
+
+    @Test
+    void addItemStoresIt() {
+        inventory.Add(book, 1);
+        assertNotNull(inventory.GetByItemCode("book"));
+    }
+
+    @Test
+    void addItemReturnsZeroLeftoverWhenFits() {
+        int leftOver = inventory.Add(book, 1);
+        assertEquals(0, leftOver);
+    }
+
+    @Test
+    void addItemDecreasesRemainingCapacity() {
+        inventory.Add(book, 1); // bulk 3
+        assertEquals(17, inventory.GetRemainingCapacity());
+    }
+
+    @Test
+    void addMultipleOfSameItemStacksTogether() {
+        inventory.Add(book, 2);
+        assertEquals(2, inventory.GetByItemCode("book").getAmount());
+    }
+
+    @Test
+    void addReturnsLeftoverWhenCapacityExceeded() {
+        // capacity 20, book bulk 3 → fits 6 (uses 18), 7th overflows
+        int leftOver = inventory.Add(book, 7);
+        assertEquals(1, leftOver);
+    }
+
+    @Test
+    void addDifferentItemsTrackSeparately() {
+        inventory.Add(book, 1);
+        inventory.Add(drink, 1);
+        assertNotNull(inventory.GetByItemCode("book"));
+        assertNotNull(inventory.GetByItemCode("energy_drink"));
+    }
+
+    @Test
+    void addZeroItemsDoesNothing() {
+        // capacity / bulk = 20/3 = 6, asking for 0 → canInsert = min(0, 6) = 0
+        inventory.Add(book, 0);
+        assertNull(inventory.GetByItemCode("book"));
+        assertEquals(20, inventory.GetRemainingCapacity());
+    }
+
+    // ── Remove ───────────────────────────────────────────────────────
+
+    @Test
+    void removeReducesStackAmount() {
+        inventory.Add(book, 3);
+        inventory.Remove("book", 1);
+        assertEquals(2, inventory.GetByItemCode("book").getAmount());
+    }
+
+    @Test
+    void removeRestoresCapacity() {
+        inventory.Add(book, 2); // uses 6
+        inventory.Remove("book", 1); // frees 3
+        assertEquals(17, inventory.GetRemainingCapacity());
+    }
+
+    @Test
+    void removeEntireStackCleansUpEntry() {
+        inventory.Add(book, 1);
+        inventory.Remove("book", 1);
+        assertNull(inventory.GetByItemCode("book"));
+    }
+
+    @Test
+    void removeMoreThanStackRemovesAll() {
+        inventory.Add(book, 2);
+        inventory.Remove("book", 10);
+        assertNull(inventory.GetByItemCode("book"));
+    }
+
+    @Test
+    void removeMissingCodeIsNoOp() {
+        assertDoesNotThrow(() -> inventory.Remove("nonexistent", 1));
+    }
+
+    @Test
+    void removeFullyRestoresCapacityToInitial() {
+        inventory.Add(book, 2);
+        inventory.Remove("book", 2);
+        assertEquals(20, inventory.GetRemainingCapacity());
+    }
+
+    // ── GetByItemCode ─────────────────────────────────────────────────
+
+    @Test
+    void getByItemCodeReturnsNullForMissingItem() {
+        assertNull(inventory.GetByItemCode("book"));
+    }
+
+    @Test
+    void getByItemCodeReturnsCorrectStack() {
+        inventory.Add(drink, 3);
+        ItemStack stack = inventory.GetByItemCode("energy_drink");
+        assertNotNull(stack);
+        assertEquals(3, stack.getAmount());
+    }
+
+    // ── Capacity ──────────────────────────────────────────────────────
+
+    @Test
+    void getRemainingCapacityStartsAtMax() {
+        assertEquals(20, inventory.GetRemainingCapacity());
+    }
+
+    @Test
+    void getCapacityReturnsInitialSize() {
+        assertEquals(20, inventory.GetCapacity());
+    }
+
+    // ── Empty ─────────────────────────────────────────────────────────
+
+    @Test
+    void emptyRemovesAllItems() {
+        inventory.Add(book, 2);
+        inventory.Add(drink, 1);
+        inventory.Empty();
+        assertTrue(inventory.GetItems().isEmpty());
+    }
+
+    @Test
+    void emptyResetsUsedCapacity() {
+        inventory.Add(book, 2);
+        inventory.Empty();
+        assertEquals(20, inventory.GetRemainingCapacity());
+    }
+}

test/cz/davza/studentadventure/objects/PlayerStatTest.java

@@ -0,0 +1,66 @@
+package cz.davza.studentadventure.objects;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class PlayerStatTest {
+
+    @Test
+    void initialValueIsSet() {
+        PlayerStat stat = new PlayerStat("Energy", 50);
+        assertEquals(50, stat.getValue());
+    }
+
+    @Test
+    void initialValueClampsAbove100() {
+        PlayerStat stat = new PlayerStat("Energy", 150);
+        assertEquals(100, stat.getValue());
+    }
+
+    @Test
+    void initialValueClampsBelow0() {
+        PlayerStat stat = new PlayerStat("Energy", -10);
+        assertEquals(0, stat.getValue());
+    }
+
+    @Test
+    void increaseAddsValue() {
+        PlayerStat stat = new PlayerStat("Energy", 50);
+        stat.increase(20);
+        assertEquals(70, stat.getValue());
+    }
+
+    @Test
+    void increaseClampAt100() {
+        PlayerStat stat = new PlayerStat("Energy", 90);
+        stat.increase(50);
+        assertEquals(100, stat.getValue());
+    }
+
+    @Test
+    void decreaseSubtractsValue() {
+        PlayerStat stat = new PlayerStat("Energy", 50);
+        stat.decrease(20);
+        assertEquals(30, stat.getValue());
+    }
+
+    @Test
+    void decreaseClampAt0() {
+        PlayerStat stat = new PlayerStat("Energy", 10);
+        stat.decrease(50);
+        assertEquals(0, stat.getValue());
+    }
+
+    @Test
+    void increaseByZeroChangesNothing() {
+        PlayerStat stat = new PlayerStat("Energy", 50);
+        stat.increase(0);
+        assertEquals(50, stat.getValue());
+    }
+
+    @Test
+    void toStringFormat() {
+        PlayerStat stat = new PlayerStat("Energy", 75);
+        assertEquals("Energy: 75/100", stat.toString());
+    }
+}

test/cz/davza/studentadventure/objects/PlayerTest.java

@@ -0,0 +1,101 @@
+package cz.davza.studentadventure.objects;
+
+import cz.davza.studentadventure.enums.DeprivationState;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class PlayerTest {
+
+    private Player player;
+
+    @BeforeEach
+    void setUp() {
+        player = new Player("Dave", 20);
+    }
+
+    @Test
+    void startsWithDefaultStats() {
+        assertEquals(5,   player.getIntelligence().getValue());
+        assertEquals(100, player.getEnergy().getValue());
+        assertEquals(0,   player.getStress().getValue());
+    }
+
+    @Test
+    void startsWithStartingMoney() {
+        assertEquals(50, player.getWallet().getMoney());
+    }
+
+    @Test
+    void nameIsSet() {
+        assertEquals("Dave", player.getName());
+    }
+
+    @Test
+    void idIsNotNull() {
+        assertNotNull(player.getId());
+    }
+
+    @Test
+    void addHoursAwakeAccumulates() {
+        player.addHoursAwake(5);
+        player.addHoursAwake(5);
+        assertEquals(DeprivationState.NORMAL, player.getDeprivationState()); // 10 < tired threshold 14
+    }
+
+    @Test
+    void deprivationStateTiredAt14Hours() {
+        player.addHoursAwake(14);
+        assertEquals(DeprivationState.TIRED, player.getDeprivationState());
+    }
+
+    @Test
+    void deprivationStateDeprivedAt20Hours() {
+        player.addHoursAwake(20);
+        assertEquals(DeprivationState.DEPRIVED, player.getDeprivationState());
+    }
+
+    @Test
+    void resetHoursAwakeSetsToNormal() {
+        player.addHoursAwake(25);
+        player.resetHoursAwake();
+        assertEquals(DeprivationState.NORMAL, player.getDeprivationState());
+    }
+
+    @Test
+    void multiplierIs1WhenNormal() {
+        assertEquals(1.0, player.getDeprivationMultiplier(), 0.001);
+    }
+
+    @Test
+    void multiplierIs1point3WhenTired() {
+        player.addHoursAwake(14);
+        assertEquals(1.3, player.getDeprivationMultiplier(), 0.001);
+    }
+
+    @Test
+    void multiplierIncreasesWhenDeprived() {
+        player.addHoursAwake(21); // 1 hour past deprived threshold
+        assertTrue(player.getDeprivationMultiplier() > 1.3);
+    }
+
+    @Test
+    void multiplierCapsAt3() {
+        player.addHoursAwake(100);
+        assertEquals(3.0, player.getDeprivationMultiplier(), 0.001);
+    }
+
+    @Test
+    void printStatsContainsMoneyFromWallet() {
+        String stats = player.printStats();
+        assertTrue(stats.contains("50 coins"));
+    }
+
+    @Test
+    void printStatsContainsAllStatNames() {
+        String stats = player.printStats();
+        assertTrue(stats.contains("Intelligence"));
+        assertTrue(stats.contains("Energy"));
+        assertTrue(stats.contains("Stress"));
+    }
+}

test/cz/davza/studentadventure/objects/WalletTest.java

@@ -0,0 +1,55 @@
+package cz.davza.studentadventure.objects;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class WalletTest {
+
+    @Test
+    void startsWithGivenAmount() {
+        Wallet wallet = new Wallet(50);
+        assertEquals(50, wallet.getMoney());
+    }
+
+    @Test
+    void earnMoneyIncreasesBalance() {
+        Wallet wallet = new Wallet(10);
+        wallet.earnMoney(20);
+        assertEquals(30, wallet.getMoney());
+    }
+
+    @Test
+    void spendMoneyReducesBalance() {
+        Wallet wallet = new Wallet(50);
+        boolean result = wallet.spendMoney(20);
+        assertTrue(result);
+        assertEquals(30, wallet.getMoney());
+    }
+
+    @Test
+    void spendMoneyReturnsFalseWhenInsufficient() {
+        Wallet wallet = new Wallet(10);
+        boolean result = wallet.spendMoney(20);
+        assertFalse(result);
+    }
+
+    @Test
+    void balanceUnchangedAfterFailedSpend() {
+        Wallet wallet = new Wallet(10);
+        wallet.spendMoney(20);
+        assertEquals(10, wallet.getMoney());
+    }
+
+    @Test
+    void spendExactBalanceSucceeds() {
+        Wallet wallet = new Wallet(20);
+        assertTrue(wallet.spendMoney(20));
+        assertEquals(0, wallet.getMoney());
+    }
+
+    @Test
+    void defaultConstructorStartsAtZero() {
+        Wallet wallet = new Wallet();
+        assertEquals(0, wallet.getMoney());
+    }
+}

test/cz/davza/studentadventure/rooms/ClassroomRoomTest.java

@@ -0,0 +1,71 @@
+package cz.davza.studentadventure.rooms;
+
+import cz.davza.studentadventure.Items.Book;
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class ClassroomRoomTest {
+
+    private GameData context;
+
+    @BeforeEach
+    void setUp() {
+        context = TestHelpers.buildGameData();
+        // Bedroom → Hallway
+        context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("hallway"));
+        context.getMap().commitRoomChange();
+    }
+
+    private ClassroomRoom getClassroomRoom() {
+        return (ClassroomRoom) context.getMap().getCurrentRoom().getExit("classroom");
+    }
+
+    @Test
+    void enterWithoutBookReturnsFailed() {
+        CommandResult result = getClassroomRoom().onEnter(context);
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+
+    @Test
+    void enterWithoutBookAppliesStressPenalty() {
+        int stressBefore = context.getPlayer().getStress().getValue();
+        getClassroomRoom().onEnter(context);
+        assertEquals(stressBefore + 15, context.getPlayer().getStress().getValue());
+    }
+
+    @Test
+    void enterWithoutBookCancelsRoomChange() {
+        getClassroomRoom().onEnter(context);
+        assertFalse(context.getMap().hasPendingRoomChange());
+    }
+
+    @Test
+    void enterWithBookReturnsSuccess() {
+        context.getPlayer().getInventory().Add(new Book(), 1);
+        CommandResult result = getClassroomRoom().onEnter(context);
+        assertEquals(CommandState.SUCCESS, result.getResultState());
+    }
+
+    @Test
+    void enterWithBookDoesNotAddStress() {
+        context.getPlayer().getInventory().Add(new Book(), 1);
+        int stressBefore = context.getPlayer().getStress().getValue();
+        getClassroomRoom().onEnter(context);
+        assertEquals(stressBefore, context.getPlayer().getStress().getValue());
+    }
+
+    @Test
+    void classroomHasSleepCommand() {
+        assertTrue(getClassroomRoom().getAllowedCommands().contains("sleep"));
+    }
+
+    @Test
+    void classroomHasStickyNote() {
+        assertNotNull(getClassroomRoom().getItems().GetByItemCode("sticky_note"));
+    }
+}

test/cz/davza/studentadventure/rooms/ExamRoomRoomTest.java

@@ -0,0 +1,95 @@
+package cz.davza.studentadventure.rooms;
+
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ExamRoomRoomTest {
+
+    private GameData context;
+    private ExamRoomRoom examRoom;
+
+    @BeforeEach
+    void setUp() {
+        context  = TestHelpers.buildGameData();
+        examRoom = new ExamRoomRoom(context);
+    }
+
+    // ── onEnter ───────────────────────────────────────────────────────────────
+
+    @Test
+    void onEnterReturnsActionPending() {
+        assertEquals(CommandState.ACTION_PENDING, examRoom.onEnter(context).getResultState());
+    }
+
+    @Test
+    void onEnterSetsHandlerToExamRoom() {
+        CommandResult result = examRoom.onEnter(context);
+        assertEquals(examRoom, result.getNewCommandHandler());
+    }
+
+    // ── handleCommand — correct ID ────────────────────────────────────────────
+
+    @Test
+    void correctStudentIdResumesAction() {
+        String id = context.getPlayer().getId();
+        CommandResult result = examRoom.handleCommand(id, context);
+        assertEquals(CommandState.ACTION_RESUMED, result.getResultState());
+    }
+
+    @Test
+    void correctStudentIdIsCaseSensitive() {
+        // ID is generated as name+random — verify exact match is required
+        String id = context.getPlayer().getId();
+        CommandResult correct = examRoom.handleCommand(id, context);
+        assertEquals(CommandState.ACTION_RESUMED, correct.getResultState());
+    }
+
+    // ── handleCommand — wrong ID ─────────────────────────────────────────────
+
+    @Test
+    void wrongStudentIdReturnsFailed() {
+        CommandResult result = examRoom.handleCommand("wrongid123", context);
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+
+    @Test
+    void wrongIdKeepsPlayerOutOfRoom() {
+        examRoom.handleCommand("wrongid", context);
+        // map should have no pending room change set by exam room
+        // (ExamRoomRoom doesn't set nextRoom on wrong ID — that's correct behaviour)
+        assertFalse(context.getMap().hasPendingRoomChange());
+    }
+
+    // ── handleCommand — leave ────────────────────────────────────────────────
+
+    @Test
+    void leaveResumesAction() {
+        CommandResult result = examRoom.handleCommand("leave", context);
+        assertEquals(CommandState.ACTION_RESUMED, result.getResultState());
+    }
+
+    @Test
+    void leaveIsCaseInsensitive() {
+        assertEquals(CommandState.ACTION_RESUMED,
+                examRoom.handleCommand("LEAVE", context).getResultState());
+    }
+
+    @Test
+    void leaveClearsNextRoom() {
+        context.getMap().setNextRoom(examRoom); // simulate pending entry
+        examRoom.handleCommand("leave", context);
+        assertFalse(context.getMap().hasPendingRoomChange());
+    }
+
+    // ── Room contents ─────────────────────────────────────────────────────────
+
+    @Test
+    void examRoomAllowsTakeExamCommand() {
+        assertTrue(examRoom.getAllowedCommands().contains("takeexam"));
+    }
+}

test/cz/davza/studentadventure/rooms/ExamRoomTest.java

@@ -0,0 +1,83 @@
+package cz.davza.studentadventure.rooms;
+
+import cz.davza.studentadventure.Items.Book;
+import cz.davza.studentadventure.TestHelpers;
+import cz.davza.studentadventure.enums.CommandState;
+import cz.davza.studentadventure.objects.CommandResult;
+import cz.davza.studentadventure.objects.GameData;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class ExamRoomTest {
+
+    private GameData context;
+    private ExamRoomRoom examRoom;
+
+    @BeforeEach
+    void setUp() {
+        context = TestHelpers.buildGameData();
+        // Navigate to exam room entrance: bedroom → hallway → classroom → examroom
+        context.getPlayer().getInventory().Add(new Book(), 1);
+        context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("hallway"));
+        context.getMap().commitRoomChange();
+        context.getMap().setNextRoom(context.getMap().getCurrentRoom().getExit("classroom"));
+        context.getMap().commitRoomChange();
+        examRoom = (ExamRoomRoom) context.getMap().getCurrentRoom().getExit("examroom");
+    }
+
+    @Test
+    void onEnterReturnsActionPending() {
+        CommandResult result = examRoom.onEnter(context);
+        assertEquals(CommandState.ACTION_PENDING, result.getResultState());
+    }
+
+    @Test
+    void onEnterSetsExamRoomAsHandler() {
+        CommandResult result = examRoom.onEnter(context);
+        assertEquals(examRoom, result.getNewCommandHandler());
+    }
+
+    @Test
+    void correctIdAllowsEntry() {
+        examRoom.onEnter(context);
+        String correctId = context.getPlayer().getId();
+        CommandResult result = examRoom.handleCommand(correctId, context);
+        assertEquals(CommandState.ACTION_RESUMED, result.getResultState());
+    }
+
+    @Test
+    void wrongIdReturnsFailed() {
+        examRoom.onEnter(context);
+        CommandResult result = examRoom.handleCommand("wrongid999", context);
+        assertEquals(CommandState.FAILED, result.getResultState());
+    }
+
+    @Test
+    void leaveCommandCancelsEntry() {
+        examRoom.onEnter(context);
+        CommandResult result = examRoom.handleCommand("leave", context);
+        assertEquals(CommandState.ACTION_RESUMED, result.getResultState());
+    }
+
+    @Test
+    void leaveCommandCancelsRoomChange() {
+        context.getMap().setNextRoom(examRoom);
+        examRoom.onEnter(context);
+        examRoom.handleCommand("leave", context);
+        assertNull(context.getMap().getNextRoom());
+    }
+
+    @Test
+    void idCheckIsCaseInsensitive() {
+        examRoom.onEnter(context);
+        String id = context.getPlayer().getId();
+        CommandResult result = examRoom.handleCommand(id.toUpperCase(), context);
+        assertEquals(CommandState.ACTION_RESUMED, result.getResultState());
+    }
+
+    @Test
+    void examRoomHasTakeExamCommand() {
+        assertTrue(examRoom.getAllowedCommands().contains("takeexam"));
+    }
+}