Projektdateien hinzufügen.

Asteroids.sln

@@ -0,0 +1,28 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.22823.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Asteroids", "Asteroids\Asteroids.vcxproj", "{E2BFB1FB-F888-490A-8159-D0F01D9C734A}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E2BFB1FB-F888-490A-8159-D0F01D9C734A}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E2BFB1FB-F888-490A-8159-D0F01D9C734A}.Debug|Win32.Build.0 = Debug|Win32
+		{E2BFB1FB-F888-490A-8159-D0F01D9C734A}.Debug|x64.ActiveCfg = Debug|x64
+		{E2BFB1FB-F888-490A-8159-D0F01D9C734A}.Debug|x64.Build.0 = Debug|x64
+		{E2BFB1FB-F888-490A-8159-D0F01D9C734A}.Release|Win32.ActiveCfg = Release|Win32
+		{E2BFB1FB-F888-490A-8159-D0F01D9C734A}.Release|Win32.Build.0 = Release|Win32
+		{E2BFB1FB-F888-490A-8159-D0F01D9C734A}.Release|x64.ActiveCfg = Release|x64
+		{E2BFB1FB-F888-490A-8159-D0F01D9C734A}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Asteroids/Asteroids.vcxproj

@@ -0,0 +1,233 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{E2BFB1FB-F888-490A-8159-D0F01D9C734A}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>Asteroids</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\..\..\Allgemein\Framework;..\..\..\..\Klient\Include;..\..\..\..\..\Allgemein\Network\Network;..\..\..\..\..\Allgemein\GSL\GSL\Include;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\..\..\Allgemein\Framework;..\..\..\..\Klient\Include;..\..\..\..\..\Allgemein\Network\Network;..\..\..\..\..\Allgemein\GSL\GSL\Include;$(IncludePath)</IncludePath>
+    <LibraryPath>..\..\..\..\..\Allgemein\Framework\x64\Debug;..\..\..\..\..\Allgemein\Network\x64\Debug;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>..\..\..\..\..\Allgemein\Framework;..\..\..\..\Klient\Include;..\..\..\..\..\Allgemein\Network\Network;..\..\..\..\..\Allgemein\GSL\GSL\Include;$(IncludePath)</IncludePath>
+    <LibraryPath>..\..\..\..\..\Allgemein\Framework\Release;..\..\..\..\..\Allgemein\Network\Release;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>..\..\..\..\..\Allgemein\Framework;..\..\..\..\Klient\Include;..\..\..\..\..\Allgemein\Network\Network;..\..\..\..\..\Allgemein\GSL\GSL\Include;$(IncludePath)</IncludePath>
+    <LibraryPath>..\..\..\..\..\Allgemein\Framework\x64\Release;..\..\..\..\..\Allgemein\Network\x64\Release;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;ASTEROIDS_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;ASTEROIDS_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>Framework.lib;Network.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <CustomBuildStep>
+      <Command>copy "..\x64\Debug\Asteroids.dll" "..\..\..\..\Klient\Fertig\Debug\Spiele\x64\Asteroids\bin\Asteroids.dll";%(Outputs)</Command>
+    </CustomBuildStep>
+    <CustomBuildStep>
+      <Outputs>kopierem;%(Outputs)</Outputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;ASTEROIDS_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>Framework.lib;Network.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <CustomBuildStep>
+      <Command>copy "..\Release\Asteroids.dll" "..\..\..\..\Klient\Fertig\Spiele\x32\Asteroids\bin\Asteroids.dll"</Command>
+    </CustomBuildStep>
+    <CustomBuildStep>
+      <Outputs>kopieren...;%(Outputs)</Outputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;ASTEROIDS_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>Framework.lib;Network.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <CustomBuildStep>
+      <Command>copy "..\x64\Release\Asteroids.dll" "..\..\..\..\Klient\Fertig\Spiele\x64\Asteroids\bin\Asteroids.dll"</Command>
+    </CustomBuildStep>
+    <CustomBuildStep>
+      <Outputs>kopieren...;%(Outputs)</Outputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="Aufzeichnung\Aufzeichnung.h" />
+    <ClInclude Include="Editor\Editor.h" />
+    <ClInclude Include="Editor\Interface\Dialogs\Dialog.h" />
+    <ClInclude Include="Editor\Interface\Dialogs\Nachricht.h" />
+    <ClInclude Include="Editor\Interface\Dialogs\Frage.h" />
+    <ClInclude Include="Editor\Interface\Interface.h" />
+    <ClInclude Include="Editor\Netzwerk\EditorKlient.h" />
+    <ClInclude Include="Editor\Prozess.h" />
+    <ClInclude Include="HistorieStatistik\HistorieStatistik.h" />
+    <ClInclude Include="Initialisierung\Initialisierung.h" />
+    <ClInclude Include="SpielStatistik\Chat\StatistikChat.h" />
+    <ClInclude Include="SpielStatistik\SpielStatistik.h" />
+    <ClInclude Include="SpielStatistik\SpielStatistikDaten.h" />
+    <ClInclude Include="SpielStatistik\Tabelle\StatistikTabelle.h" />
+    <ClInclude Include="Netzwerk\STKNachricht.h" />
+    <ClInclude Include="Spiel\Bestenliste\Bestenliste.h" />
+    <ClInclude Include="Spiel\Chat\Chat.h" />
+    <ClInclude Include="Spiel\Define.h" />
+    <ClInclude Include="Spiel\Ende\Ende.h" />
+    <ClInclude Include="Spiel\Kamera\Kamera.h" />
+    <ClInclude Include="Spiel\Karte\Karte.h" />
+    <ClInclude Include="Spiel\Karte\Strukturen.h" />
+    <ClInclude Include="Spiel\Objekt\SpielObjekt.h" />
+    <ClInclude Include="Spiel\Schuss\Laser.h" />
+    <ClInclude Include="Spiel\Ship\Ship.h" />
+    <ClInclude Include="Spiel\Spieler\Spieler.h" />
+    <ClInclude Include="Spiel\SpielKlasse.h" />
+    <ClInclude Include="Spiel\Team\Team.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Aufzeichnung\Aufzeichnung.cpp" />
+    <ClCompile Include="Editor\Editor.cpp" />
+    <ClCompile Include="Editor\Interface\Dialogs\Dialog.cpp" />
+    <ClCompile Include="Editor\Interface\Dialogs\Frage.cpp" />
+    <ClCompile Include="Editor\Interface\Dialogs\Nachricht.cpp" />
+    <ClCompile Include="Editor\Interface\Interface.cpp" />
+    <ClCompile Include="Editor\Netzwerk\EditorKlient.cpp" />
+    <ClCompile Include="Editor\Prozess.cpp" />
+    <ClCompile Include="HistorieStatistik\HistorieStatistik.cpp" />
+    <ClCompile Include="Initialisierung\Initialisierung.cpp" />
+    <ClCompile Include="SpielStatistik\Chat\StatistikChat.cpp" />
+    <ClCompile Include="SpielStatistik\SpielStatistik.cpp" />
+    <ClCompile Include="SpielStatistik\Tabelle\StatistikTabelle.cpp" />
+    <ClCompile Include="Spiel\Bestenliste\Bestenliste.cpp" />
+    <ClCompile Include="Spiel\Chat\Chat.cpp" />
+    <ClCompile Include="Spiel\Ende\Ende.cpp" />
+    <ClCompile Include="Spiel\Kamera\Kamera.cpp" />
+    <ClCompile Include="Spiel\Karte\Karte.cpp" />
+    <ClCompile Include="Spiel\Karte\Strukturen.cpp" />
+    <ClCompile Include="Spiel\Objekt\SpielObjekt.cpp" />
+    <ClCompile Include="Spiel\Schuss\Laser.cpp" />
+    <ClCompile Include="Spiel\Ship\Ship.cpp" />
+    <ClCompile Include="Spiel\Spieler\Spieler.cpp" />
+    <ClCompile Include="Spiel\SpielKlasse.cpp" />
+    <ClCompile Include="Spiel\Team\Team.cpp" />
+    <ClCompile Include="Start\DLLStart.cpp" />
+    <ClCompile Include="Netzwerk\STKNachricht.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

Asteroids/Asteroids.vcxproj.filters

@@ -0,0 +1,186 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Quelldateien">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Headerdateien">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Ressourcendateien">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="Initialisierung\Initialisierung.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="SpielStatistik\SpielStatistik.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="SpielStatistik\SpielStatistikDaten.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="SpielStatistik\Chat\StatistikChat.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="SpielStatistik\Tabelle\StatistikTabelle.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Netzwerk\STKNachricht.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="HistorieStatistik\HistorieStatistik.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\SpielKlasse.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\Bestenliste\Bestenliste.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\Spieler\Spieler.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\Kamera\Kamera.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\Karte\Karte.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\Team\Team.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\Schuss\Laser.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\Chat\Chat.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\Ship\Ship.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\Ende\Ende.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\Karte\Strukturen.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\Objekt\SpielObjekt.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\Define.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor\Editor.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Aufzeichnung\Aufzeichnung.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor\Prozess.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor\Interface\Interface.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor\Netzwerk\EditorKlient.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor\Interface\Dialogs\Dialog.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor\Interface\Dialogs\Frage.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor\Interface\Dialogs\Nachricht.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Initialisierung\Initialisierung.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Start\DLLStart.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="SpielStatistik\Chat\StatistikChat.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="SpielStatistik\Tabelle\StatistikTabelle.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="SpielStatistik\SpielStatistik.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Netzwerk\STKNachricht.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="HistorieStatistik\HistorieStatistik.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel\SpielKlasse.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel\Bestenliste\Bestenliste.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel\Karte\Karte.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel\Team\Team.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel\Schuss\Laser.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel\Chat\Chat.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel\Ship\Ship.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel\Spieler\Spieler.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel\Ende\Ende.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel\Kamera\Kamera.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel\Karte\Strukturen.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel\Objekt\SpielObjekt.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Editor\Editor.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Aufzeichnung\Aufzeichnung.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Editor\Prozess.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Editor\Interface\Interface.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Editor\Netzwerk\EditorKlient.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Editor\Interface\Dialogs\Dialog.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Editor\Interface\Dialogs\Nachricht.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Editor\Interface\Dialogs\Frage.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

Asteroids/Editor/Editor.cpp

@@ -0,0 +1,120 @@
+#include "Editor.h"
+#include <iostream>
+
+// Inhalt der Editor Klasse aus Editor.h
+// Konstruktor
+Editor::Editor()
+{
+    schrift = 0;
+    klient = 0;
+    laden = 0;
+    i = 0;
+    alpha = 0;
+    verlassen = 0;
+    dialogs = new Array< Dialog* >();
+    rend = 1;
+    ref = 1;
+}
+
+// Destruktor
+Editor::~Editor()
+{
+    if( schrift )
+        schrift->release();
+    if( klient )
+        klient->release();
+    if( laden )
+        laden->release();
+    if( i )
+        i->release();
+}
+
+// nicht constant
+void Editor::setSchrift( Schrift *schrift )
+{
+    if( this->schrift )
+        this->schrift->release();
+    this->schrift = schrift;
+    if( !i )
+        i = new Interface( schrift );
+}
+
+void Editor::setKlient( EditorKlientV *ekv )
+{
+    if( klient )
+        klient->release();
+    klient = new EditorKlient( ekv );
+}
+
+void Editor::setLadeAnimation( Animation2D *la )
+{
+    if( laden )
+        laden->release();
+    laden = la;
+}
+
+void Editor::setSichtbar()
+{
+    verlassen = 0;
+    rend = 1;
+}
+
+void Editor::doMausEreignis( MausEreignis &me )
+{
+    for( auto i = dialogs->getArray(); i.set && i.var; i++ )
+        i.var->doMausEreignis( me );
+    i->doMausEreignis( me );
+    verlassen = i->hatVerlassen();
+}
+
+void Editor::doTastaturEreignis( TastaturEreignis &te )
+{
+    for( auto i = dialogs->getArray(); i.set && i.var; i++ )
+        i.var->doTastaturEreignis( te );
+    i->doTastaturEreignis( te );
+}
+
+bool Editor::tick( double z )
+{
+    rend |= i->tick( z );
+    for( auto i = dialogs->getArray(); i.set && i.var; i++ )
+        rend |= i.var->tick( z );
+    bool tmp = rend;
+    rend = 0;
+    return tmp;
+}
+
+void Editor::render( Bild &zRObj )
+{
+    i->render( zRObj );
+    for( int i = dialogs->getEintragAnzahl() - 1; i >= 0; i-- )
+    {
+        dialogs->get( i )->render( zRObj );
+        if( dialogs->get( i )->hatVerlassen() )
+        {
+            delete dialogs->get( i );
+            dialogs->remove( i );
+        }
+    }
+}
+
+// constant
+bool Editor::hatVerlassen( bool jetzt ) const
+{
+    return verlassen;
+}
+
+// Reference Counting
+EditorV *Editor::getThis()
+{
+    ref++;
+    return this;
+}
+
+EditorV *Editor::release()
+{
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
+}

Asteroids/Editor/Editor.h

@@ -0,0 +1,43 @@
+#ifndef Editor_H
+#define Editor_H
+
+#include "../../../../../Klient/Include/EditorV.h"
+#include "Interface\Interface.h"
+#include "Netzwerk\EditorKlient.h"
+#include "Interface\Dialogs\Dialog.h"
+
+class Editor : public EditorV
+{
+private:
+	Schrift *schrift;
+    EditorKlient *klient;
+    Animation2D *laden;
+    Interface *i;
+    Array< Dialog* > *dialogs;
+	unsigned char alpha;
+    bool verlassen;
+    bool rend;
+	int ref;
+
+public:
+	// Konstruktor
+	Editor();
+	// Destruktor
+	~Editor();
+	// nicht constant
+	void setSchrift( Schrift *schrift ) override;
+	void setKlient( EditorKlientV *ekv ) override;
+    void setLadeAnimation( Animation2D *la ) override;
+	void setSichtbar() override;
+	void doMausEreignis( MausEreignis &me ) override;
+	void doTastaturEreignis( TastaturEreignis &te ) override;
+	bool tick( double z ) override;
+	void render( Bild &zRObj ) override;
+	// constant
+	bool hatVerlassen( bool jetzt ) const override;
+	// Reference Counting
+	EditorV *getThis() override;
+	EditorV *release() override;
+};
+
+#endif

Asteroids/Editor/Interface/Dialogs/Dialog.cpp

@@ -0,0 +1,38 @@
+#include "Dialog.h"
+#include <TextFeld.h>
+#include <MausEreignis.h>
+#include <TastaturEreignis.h>
+#include <Schrift.h>
+
+// Inhalt der Dialog Klasse aus Dialog.h
+// Konstruktor
+//  zS: Die zu verwendende Schrift
+Dialog::Dialog( Schrift *zS )
+    : Fenster()
+{
+    setStyle( Fenster::Style::normal | Fenster::Style::Sichtbar | Fenster::Style::BodyHAlpha | Fenster::Style::BodyHintergrund |
+              Fenster::Style::TitelHintergrund | Fenster::Style::TitelHAlpha );
+    setMausEreignis( _ret1ME );
+    setTastaturEreignis( _ret1TE );
+    setRBreite( 1 );
+    setRFarbe( 0xFFFFFFFF );
+    setTitel( "Fehler" );
+    setTSchriftZ( zS->getThis() );
+    setTSFarbe( 0xFFFFFFFF );
+    zTTextFeld()->setSize( 0, 20 );
+    zTTextFeld()->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Rahmen );
+    setTRFarbe( 0xFF00FF00 );
+    setTRBreite( 1 );
+    setTAfFarbe( 0x1000FF00 );
+    setTAfStrength( -15 );
+    setSKAfFarbe( 0xFF00FF00 );
+    setSKAfStrength( 30 );
+
+    verlassen = 0;
+}
+
+// Gibt zurück ob das Fenster verlassen wurde
+bool Dialog::hatVerlassen() const
+{
+    return verlassen;
+}

Asteroids/Editor/Interface/Dialogs/Dialog.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <Fenster.h>
+
+using namespace Framework;
+
+class Dialog : public Fenster
+{
+protected:
+    bool verlassen;
+
+public:
+    // Konstruktor
+    //  zS: Die zu verwendende Schrift
+    Dialog( Schrift *zS );
+    // Gibt zurück ob das Fenster verlassen wurde
+    bool hatVerlassen() const;
+};

Asteroids/Editor/Interface/Dialogs/Frage.cpp

@@ -0,0 +1,72 @@
+#include "Frage.h"
+#include <Schrift.h>
+#include <Text.h>
+#include "../../../Initialisierung/Initialisierung.h"
+
+// Konstructor
+//  zS: Ein Zeiger auf die zu verwendende Schrift
+//  frage: Die Frage die an den Benutzer gestellt werden soll
+//  left: Die linke Antwort
+//  right: Die rechte Antwort
+//  leftAk: Ein Zeiger auf eine Funktion die beim wählen der Linken Antwort aufgerufen wird
+//  rightAk: Ein Zeiger auf eine Funktion die beim wählen der Rechten Antwort aufgerufen wird
+//  abbruchAk: Ein Zeiger auf eine Funktion die beim Schließen des Fensters aufgerufen wird
+//  maxSize: Die Bildschirmgröße in Pixeln
+Frage::Frage( Schrift *zS, char *frage, char *left, char *right, std::function< void() > leftAk, std::function< void() > rightAk, std::function< void() > abbruchAk, Punkt maxSize )
+    : Dialog( zS )
+{
+    Text *tmp = new Text( frage );
+    zS->lock();
+    zS->setSchriftSize( 12 );
+    zS->textFormatieren( tmp, 300, 12 );
+    int br = zS->getTextBreite( tmp );
+    int hö = zS->getTextHeight( tmp );
+    zS->unlock();
+    setSize( br + 12, hö + 58 );
+    setPosition( maxSize / 2 - getSize() / 2 );
+    
+    this->text = initTextFeld( 5, 5, br, hö, zS, TextFeld::Style::Text, tmp->getText() );
+    tmp->release();
+    this->right = initKnopf( br - 94, hö + 22, 100, 20, zS, Knopf::Style::Normal, right );
+    this->left = initKnopf( br - 199, hö + 22, 100, 20, zS, Knopf::Style::Normal, left );
+
+    bool *verl = &verlassen;
+
+    this->right->setMausEreignis( [ verl, rightAk ]( void *param, void *obj, MausEreignis me ) -> bool
+    {
+        if( me.id == ME_RLinks && !me.verarbeitet && !*verl )
+        {
+            *verl = 1;
+            if( rightAk )
+                rightAk();
+        }
+        return 1;
+    } );
+    this->left->setMausEreignis( [ verl, leftAk ]( void *param, void *obj, MausEreignis me ) -> bool
+    {
+        if( me.id == ME_RLinks && !me.verarbeitet && !*verl )
+        {
+            *verl = 1;
+            if( leftAk )
+                leftAk();
+        }
+        return 1;
+    } );
+    setClosingMe( [ verl, abbruchAk ]( void *param, void *obj, MausEreignis me ) -> bool
+    {
+        if( me.id == ME_RLinks && !me.verarbeitet && !*verl )
+        {
+            *verl = 1;
+            if( abbruchAk )
+                abbruchAk();
+        }
+        return 1;
+    } );
+}
+
+Frage::~Frage()
+{
+    text->release();
+    left->release();
+    right->release();
+}

Asteroids/Editor/Interface/Dialogs/Frage.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Dialog.h"
+#include <Knopf.h>
+
+class Frage : public Dialog
+{
+private:
+    TextFeld *text;
+    Knopf *right;
+    Knopf *left;
+
+public:
+    // Konstructor
+    //  zS: Ein Zeiger auf die zu verwendende Schrift
+    //  frage: Die Frage die an den Benutzer gestellt werden soll
+    //  left: Die linke Antwort
+    //  right: Die rechte Antwort
+    //  leftAk: Ein Zeiger auf eine Funktion die beim wählen der Linken Antwort aufgerufen wird
+    //  rightAk: Ein Zeiger auf eine Funktion die beim wählen der Rechten Antwort aufgerufen wird
+    //  abbruchAk: Ein Zeiger auf eine Funktion die beim Schließen des Fensters aufgerufen wird
+    //  maxSize: Die Bildschirmgröße in Pixeln
+    Frage( Schrift *zS, char *frage, char *left, char *right, std::function< void() > leftAk, std::function< void() > rightAk, std::function< void() > abbruchAk, Punkt maxSize );
+    // Destruktor
+    ~Frage();
+};

Asteroids/Editor/Interface/Dialogs/Nachricht.cpp

@@ -0,0 +1,50 @@
+#include "Nachricht.h"
+#include <Schrift.h>
+#include <Text.h>
+#include <MausEreignis.h>
+#include <TastaturEreignis.h>
+#include <TextFeld.h>
+#include "../../../Initialisierung/Initialisierung.h"
+
+// Inhalt der Fehler Klasse aus Fehler.h
+
+// Konstruktor
+//  zS: Die zu verwendende Schrift
+//  nachricht: Der Fehler, der angezeigt werden soll
+//  maxSize: Die Bildschirmgröße in Pixeln
+Nachricht::Nachricht( Schrift *zS, char *nachricht, Punkt maxSize )
+    : Dialog( zS )
+{
+    Text *tmp = new Text( nachricht );
+    zS->lock();
+    zS->setSchriftSize( 12 );
+    zS->textFormatieren( tmp, 300, 12 );
+    int br = zS->getTextBreite( tmp );
+    int hö = zS->getTextHeight( tmp );
+    zS->unlock();
+    setSize( br + 12, hö + 58 );
+    setPosition( maxSize / 2 - getSize() / 2 );
+
+    this->text = initTextFeld( 5, 5, br, hö, zS, TextFeld::Style::Text, tmp->getText() );
+    tmp->release();
+    ok = initKnopf( br - 94, hö + 22, 100, 20, zS, Knopf::Style::Normal, "Ok" );
+
+    bool *verl = &verlassen;
+
+    auto me = [ verl ]( void *param, void *obj, MausEreignis me ) -> bool
+    {
+        if( me.id == ME_RLinks && !me.verarbeitet )
+            *verl = 1;
+        return 1;
+    };
+
+    ok->setMausEreignis( me );
+    setClosingMe( me );
+}
+
+// Destruktor
+Nachricht::~Nachricht()
+{
+    text->release();
+    ok->release();
+}

Asteroids/Editor/Interface/Dialogs/Nachricht.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "Dialog.h"
+#include <Knopf.h>
+
+using namespace Framework;
+
+class Nachricht : public Dialog
+{
+private:
+    Knopf *ok;
+    TextFeld *text;
+
+public:
+    // Konstruktor
+    //  zS: Die zu verwendende Schrift
+    //  nachricht: Der Fehler, der angezeigt werden soll
+    //  maxSize: Die Bildschirmgröße in Pixeln
+    Nachricht( Schrift *zS, char *nachricht, Punkt maxSize );
+    // Destruktor
+    ~Nachricht();
+};

Asteroids/Editor/Interface/Interface.cpp

@@ -0,0 +1,67 @@
+#include "Interface.h"
+#include "../../Initialisierung/Initialisierung.h"
+#include <MausEreignis.h>
+
+// Inhalt der Interface Klasse aus Interface.h
+// Konstruktor
+//  zS: Ein Zeiger auf die zu verwendende Schrift
+Interface::Interface( Schrift *zS )
+{
+    beenden = initKnopf( 10, 10, 100, 20, zS, Knopf::Style::Normal, "beenden" );
+    verlassen = 0;
+    ref = 1;
+}
+
+// Destruktor
+Interface::~Interface()
+{
+    beenden->release();
+}
+
+// Verarbeitet eine Mausnachricht
+//  me: Die Nachricht die verarbeitet werden soll
+void Interface::doMausEreignis( MausEreignis &me )
+{
+    bool vera = me.verarbeitet;
+    beenden->doMausEreignis( me );
+    if( me.verarbeitet && !vera && me.id == ME_RLinks )
+    {
+        verlassen = 1;
+    }
+}
+
+// Zeichnet das Interface nach uRObj
+//  zRObj: Das Bild in das gezeichnet werden soll
+void Interface::render( Bild &zRObj )
+{
+    beenden->render( zRObj );
+}
+
+// Setzt das Interface in den Initialisierungszustand zurück
+void Interface::reset()
+{
+    verlassen = 0;
+}
+
+// Gibt zurück, ob der Benutzer den Editor verlassen möchte
+bool Interface::hatVerlassen() const
+{
+    return verlassen;
+}
+
+// erhöht den Reference Counter
+//  return: this
+Interface *Interface::getThis()
+{
+    ref++;
+    return this;
+}
+
+// verringert den Reference Counter und löscht das Objekt wenn es nicht mehr gebraucht wird.
+//  return: 0
+Interface *Interface::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

Asteroids/Editor/Interface/Interface.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <Fenster.h>
+#include <Knopf.h>
+
+using namespace Framework;
+
+class Interface : public ZeichnungHintergrund
+{
+private:
+    Knopf *beenden;
+    bool verlassen;
+    int ref;
+
+public:
+    // Konstruktor
+    //  zS: Ein Zeiger auf die zu verwendende Schrift
+    Interface( Schrift *zS );
+    // Destruktor
+    ~Interface();
+    // Verarbeitet eine Mausnachricht
+    //  me: Die Nachricht die verarbeitet werden soll
+    void doMausEreignis( MausEreignis &me ) override;
+    // Zeichnet das Interface nach uRObj
+    //  zRObj: Das Bild in das gezeichnet werden soll
+    void render( Bild &zRObj ) override;
+    // Setzt das Interface in den Initialisierungszustand zurück
+    void reset();
+    // Gibt zurück, ob der Benutzer den Editor verlassen möchte
+    bool hatVerlassen() const;
+    // erhöht den Reference Counter
+    //  return: this
+    Interface *getThis();
+    // verringert den Reference Counter und löscht das Objekt wenn es nicht mehr gebraucht wird.
+    //  return: 0
+    Interface *release();
+};

Asteroids/Editor/Netzwerk/EditorKlient.cpp

@@ -0,0 +1,73 @@
+#include "EditorKlient.h"
+
+// Inhalt der EditorKlient Klasse aus EditorKlient.h
+// Konstruktor
+//  k: Der zu verwendende Klient
+EditorKlient::EditorKlient( EditorKlientV *k )
+{
+    klient = k;
+    ref = 1;
+}
+
+// Destruktor
+EditorKlient::~EditorKlient()
+{
+    klient->release();
+}
+
+// Initialisiert den Server
+//  return: 1, falls erfolgreich
+//          2, falls bereits eine Sitzung existiert
+//          0, sonnst
+int EditorKlient::init()
+{
+    klient->lock();
+    error = "";
+    Klient *k = klient->zKlient();
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xF", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x0", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+        }
+    }
+    if( ret == 3 )
+    {
+        char l = 0;
+        k->getNachrichtEncrypted( &l, 1 );
+        char *err = new char[ l + 1 ];
+        err[ l ] = 0;
+        k->getNachrichtEncrypted( err, l );
+        error = err;
+        delete[] err;
+        ret = 0;
+    }
+    klient->unlock();
+    return ret;
+}
+
+// Gibt den Letzten Fehler zurück
+char *EditorKlient::getLastError() const
+{
+    return error;
+}
+
+// Reference Counting
+EditorKlient *EditorKlient::getThis()
+{
+    ref++;
+    return this;
+}
+
+EditorKlient *EditorKlient::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

Asteroids/Editor/Netzwerk/EditorKlient.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "../../../../../../Klient/Include/KSGKlientV.h"
+
+class EditorKlient
+{
+private:
+    EditorKlientV *klient;
+    Text error;
+    int ref;
+
+public:
+    // Konstruktor
+    //  k: Der zu verwendende Klient
+    EditorKlient( EditorKlientV *k );
+    // Destruktor
+    ~EditorKlient();
+    // Initialisiert den Server
+    //  return: 1, falls erfolgreich
+    //          2, falls bereits eine Sitzung existiert
+    //          0, sonnst
+    int init();
+    // Gibt den Letzten Fehler zurück
+    char *getLastError() const;
+    // Reference Counting
+    EditorKlient *getThis();
+    EditorKlient *release();
+};

Asteroids/Editor/Prozess.cpp

@@ -0,0 +1,99 @@
+#include "Prozess.h"
+
+// Inhalt der Klasse Prozess aus Prozess.h
+// Konstruktor
+Prozess::Prozess( EditorKlientV *klient, int aktion, Array< void* > *args, ProzessReturn *r )
+    : Thread()
+{
+    this->k = klient;
+    ak = aktion;
+    this->args = args;
+    ret = r;
+    ref = 1;
+    start();
+}
+
+// Destruktor
+Prozess::~Prozess()
+{
+    args->release();
+    k->release();
+}
+
+// nicht constant
+void Prozess::thread()
+{
+    k->lock();
+    Klient *c = k->zKlient();
+    c->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    c->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        c->sendeEncrypted( "\xF", 1 );
+        char ret = 0;
+        c->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            switch( ak )
+            {
+            case 0:
+                init();
+                break;
+            case 1:
+                sitzungWiederherstellen();
+                break;
+            case 2:
+                sitzungVerwerfen();
+                break;
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        c->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        c->getNachrichtEncrypted( f, byte );
+        Text fehler = f;
+        delete[] f;
+        Array< void* > args;
+        args.add( (void*)&fehler );
+        if( this->ret )
+            this->ret->prozessEnd( ak, 0, args );
+    }
+    k->unlock();
+    run = 0;
+}
+
+// Reference Counting
+Prozess *Prozess::getThis()
+{
+    ref++;
+    return this;
+}
+
+Prozess *Prozess::release()
+{
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
+}
+
+// privat
+void Prozess::init() // aktion = 0
+{
+
+}
+
+void Prozess::sitzungWiederherstellen() // aktion = 1
+{
+
+}
+
+void Prozess::sitzungVerwerfen() // aktion = 2
+{
+
+}

Asteroids/Editor/Prozess.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "../../../../../Klient/Include/KSGKlientV.h"
+#include <Thread.h>
+
+using namespace Framework;
+
+class ProzessReturn
+{
+public:
+    virtual void prozessEnd( int aktion, bool erfolg, Array< void* > &args ) = 0;
+};
+
+class Prozess : public Thread
+{
+private:
+    EditorKlientV *k;
+    int ak;
+    Array< void* > *args;
+    ProzessReturn *ret;
+    int ref;
+
+public:
+    // Konstruktor
+    Prozess( EditorKlientV *klient, int aktion, Array< void* > *args, ProzessReturn *r );
+    // Destruktor
+    ~Prozess();
+    // nicht constant
+    void thread() override;
+    // Reference Counting
+    Prozess *getThis();
+    Prozess *release();
+
+private:
+    void init(); // aktion = 0
+    void sitzungWiederherstellen(); // aktion = 1
+    void sitzungVerwerfen(); // aktion = 3
+
+};

Asteroids/HistorieStatistik/HistorieStatistik.cpp

@@ -0,0 +1,181 @@
+#include "HistorieStatistik.h"
+#include <Knopf.h>
+#include <MausEreignis.h>
+#include <Bildschirm.h>
+#include "../Initialisierung/Initialisierung.h"
+#include <InitDatei.h>
+#include <DateiSystem.h>
+//#include "StatistikLeser.h"
+
+// Inhalt der HistorieStatistik Klasse aus HistorieStatistik.h
+// Konstruktor
+HistorieStatistik::HistorieStatistik()
+{
+	schrift = 0;
+	screen = 0;
+	gss = new Array< SSDSpieler* >();
+	gts = new Array< SSDTeam* >();
+	tabelle = 0;
+	fertig = 0;
+	geladen = 0;
+	geschlossen = 0;
+	alpha = 0;
+	sichtbar = 0;
+	tickVal = 0;
+	rend = 0;
+	ref = 1;
+}
+
+// Destruktor
+HistorieStatistik::~HistorieStatistik()
+{
+	if( schrift )
+		schrift->release();
+	if( screen )
+		screen->release();
+	if( !geladen )
+	{
+		gss->release();
+		gts->release();
+	}
+	else
+	{
+		int anz = gss->getEintragAnzahl();
+		for( int i = 0; i < anz; i++ )
+		{
+			if( gss->hat( i ) )
+				delete gss->get( i );
+		}
+		gss->release();
+		anz = gts->getEintragAnzahl();
+		for( int i = 0; i < anz; i++ )
+		{
+			if( gts->hat( i ) )
+				delete gts->get( i );
+		}
+		gts->release();
+	}
+	if( tabelle )
+		tabelle->release();
+	if( fertig )
+		fertig->release();
+}
+
+// nicht constant
+void HistorieStatistik::setSchrift( Schrift *schrift )
+{
+	if( this->schrift )
+		this->schrift->release();
+	this->schrift = schrift;
+}
+
+void HistorieStatistik::setBildschirm( Bildschirm *screen )
+{
+	if( this->screen )
+		this->screen->release();
+	this->screen = screen;
+}
+
+void HistorieStatistik::ladeDaten( int spielId )
+{
+	if( geladen )
+		return;
+	//StatistikLeser *reader = new StatistikLeser( spielId );
+	//for( int i = 0; i < reader->getSpielerAnzahl(); i++ )
+	//	gss->set( reader->getSSDGS( i ), i );
+	//for( int i = 0; i < reader->getTeamAnzahl(); i++ )
+	//	gts->set( reader->getSSDGT( i ), i );
+	//reader->release();
+	tabelle = new StatistikTabelle( gss->getThis(), gts->getThis(), schrift, screen, 1 );
+	fertig = initKnopf( 600, 390, 100, 20, schrift, Knopf::Style::Sichtbar, "Zurück" );
+	geladen = 1;
+}
+
+void HistorieStatistik::setSichtbar( bool sichtbar )
+{
+	this->sichtbar = sichtbar;
+}
+
+void HistorieStatistik::doMausEreignis( MausEreignis &me )
+{
+	if( !geladen )
+		return;
+	tabelle->doMausEreignis( me );
+	bool vera = me.verarbeitet;
+	fertig->doMausEreignis( me );
+	if( !vera && me.verarbeitet && me.id == ME_RLinks )
+		geschlossen = 1;
+}
+
+void HistorieStatistik::doTastaturEreignis( TastaturEreignis &te )
+{
+}
+
+bool HistorieStatistik::tick( double tickVal )
+{
+	if( !geladen )
+		return 0;
+	rend |= tabelle->tick( tickVal );
+	rend |= fertig->tick( tickVal );
+	this->tickVal += tickVal * 150;
+	int val = ( int )this->tickVal;
+	this->tickVal -= val;
+	if( val )
+	{
+		if( sichtbar && alpha != 255 )
+		{
+			if( alpha + val > 255 )
+				alpha = 255;
+			else
+				alpha += val;
+			rend = 1;
+		}
+		if( !sichtbar && alpha )
+		{
+			if( alpha - val < 0 )
+				alpha = 0;
+			else
+				alpha -= val;
+			rend = 1;
+		}
+	}
+	bool ret = rend;
+	rend = 0;
+	return ret;
+}
+
+void HistorieStatistik::render( Bild &zRObj )
+{
+	if( !geladen )
+		return;
+	zRObj.setAlpha( alpha );
+	tabelle->render( zRObj );
+	fertig->render( zRObj );
+	zRObj.releaseAlpha();
+}
+
+// constant
+bool HistorieStatistik::istNochSichtbar() const
+{
+	return alpha != 0 || sichtbar;
+}
+
+bool HistorieStatistik::wurdeGeschlossen() const
+{
+	return geschlossen;
+}
+
+// Reference Counting
+AccountHistorieStatistikV *HistorieStatistik::getThis()
+{
+	ref++;
+	return this;
+}
+
+AccountHistorieStatistikV *HistorieStatistik::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/HistorieStatistik/HistorieStatistik.h

@@ -0,0 +1,47 @@
+#ifndef HistorieStatistik_H
+#define HistorieStatistik_H
+
+#include <AccountHistorieStatistikV.h>
+#include "../SpielStatistik/SpielStatistikDaten.h"
+#include "../SpielStatistik/Tabelle/StatistikTabelle.h"
+
+class HistorieStatistik : public AccountHistorieStatistikV
+{
+private:
+	Schrift *schrift;
+	Bildschirm *screen;
+	Array< SSDSpieler* > *gss;
+	Array< SSDTeam* > *gts;
+	StatistikTabelle *tabelle;
+	Knopf *fertig;
+	bool geladen;
+	bool geschlossen;
+	unsigned char alpha;
+	bool sichtbar;
+	double tickVal;
+	bool rend;
+	int ref;
+
+public:
+	// Konstruktor
+	HistorieStatistik();
+	// Destruktor
+	~HistorieStatistik();
+	// nicht constant
+	virtual void setSchrift( Schrift *schrift );
+	virtual void setBildschirm( Bildschirm *schrift );
+	virtual void ladeDaten( int spielId );
+	virtual void setSichtbar( bool sichtbar );
+	virtual void doMausEreignis( MausEreignis &me );
+	virtual void doTastaturEreignis( TastaturEreignis &te );
+	virtual bool tick( double tickVal );
+	virtual void render( Bild &zRObj );
+	// constant
+	virtual bool istNochSichtbar() const;
+	virtual bool wurdeGeschlossen() const;
+	// Reference Counting
+	virtual AccountHistorieStatistikV *getThis();
+	virtual AccountHistorieStatistikV *release();
+};
+
+#endif

Asteroids/Initialisierung/Initialisierung.cpp

@@ -0,0 +1,218 @@
+#include "Initialisierung.h"
+#include <ToolTip.h>
+#include <Bildschirm.h>
+#include <MausEreignis.h>
+
+Knopf *initKnopf( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *titel )
+{
+	Knopf *ret = new Knopf();
+	ret->addStyle( style );
+	ret->setPosition( x, y );
+	ret->setSize( br, hö );
+	if( zSchrift )
+		ret->setSchriftZ( zSchrift->getThis() );
+	if( titel )
+		ret->setText( titel );
+	return ret;
+}
+
+KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *txt )
+{
+	KontrollKnopf *ret = new KontrollKnopf();
+	ret->setStyle( style );
+	if( zSchrift )
+		ret->setSchriftZ( zSchrift->getThis() );
+	if( txt )
+	{
+		ret->setText( txt );
+		ret->setSText( txt );
+	}
+	ret->setSFarbe( 0xFFFFFFFF );
+	ret->setSSize( 12 );
+	if( ret->hatStyle( TextFeld::Style::Buffered ) )
+	{
+		ret->setAlphaFeldFarbe( 0x5500FF00 );
+		ret->setAlphaFeldStrength( -5 );
+	}
+	if( ret->hatStyle( TextFeld::Style::Rahmen ) )
+	{
+		ret->setLinienRahmenBreite( 1 );
+		ret->setLinienRahmenFarbe( 0xFF00FF00 );
+	}
+	ret->setPosition( x, y );
+	ret->setSize( br, hö );
+	ret->loadData( "data/bilder/system.ltdb" );
+	return ret;
+}
+
+Fenster *initFenster( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *titel )
+{
+	Fenster *ret = new Fenster();
+	ret->setStyle( style );
+	ret->setPosition( x, y );
+	ret->setSize( br, hö );
+	if( ret->hatStyle( Fenster::Style::Rahmen ) )
+	{
+		ret->setRBreite( 1 );
+		ret->setRFarbe( 0xFFFFFFFF );
+	}
+	if( ret->hatStyle( Fenster::Style::Titel ) )
+	{
+		if( titel )
+			ret->setTitel( titel );
+		if( zSchrift )
+			ret->setTSchriftZ( zSchrift->getThis() );
+		ret->setTSFarbe( 0xFFFFFFFF );
+		ret->zTTextFeld()->setSize( 0, 20 );
+		ret->zTTextFeld()->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Rahmen );
+		ret->setTRFarbe( 0xFF00FF00 );
+		ret->setTRBreite( 1 );
+		if( ret->hatStyle( Fenster::Style::TitelBuffered ) )
+		{
+			ret->setTAfFarbe( 0x1000FF00 );
+			ret->setTAfStrength( -15 );
+		}
+	}
+	return ret;
+}
+
+TextFeld *initTextFeld( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *txt )
+{
+	TextFeld *ret = new TextFeld();
+	ret->setStyle( style );
+	if( zSchrift )
+		ret->setSchriftZ( zSchrift->getThis() );
+	if( txt )
+		ret->setText( txt );
+	ret->setSchriftFarbe( 0xFFFFFFFF );
+	ret->setSchriftSize( 12 );
+	if( ret->hatStyle( TextFeld::Style::Buffered ) )
+	{
+		ret->setAlphaFeldFarbe( 0x5500FF00 );
+		ret->setAlphaFeldStrength( -5 );
+	}
+	if( ret->hatStyle( TextFeld::Style::Rahmen ) )
+	{
+		ret->setLinienRahmenBreite( 1 );
+		ret->setLinienRahmenFarbe( 0xFF00FF00 );
+	}
+	ret->setPosition( x, y );
+	ret->setSize( br, hö );
+	return ret;
+}
+
+BildZ *initBildZ( int x, int y, int br, int hö, int style, Bild *b )
+{
+	BildZ *ret = new BildZ();
+	ret->setStyle( style );
+	ret->setPosition( x, y );
+	ret->setSize( br, hö );
+	if( b )
+		ret->setBildZ( b );
+	if( ( style | BildZ::Style::Rahmen ) == style )
+	{
+		ret->setLinienRahmenBreite( 1 );
+		ret->setLinienRahmenFarbe( 0xFFFFFFFF );
+	}
+	return ret;
+}
+
+AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, Schrift *zSchrift, int style, std::initializer_list< char * > values )
+{
+	AuswahlBox *ret = new AuswahlBox();
+	ret->setStyle( style );
+	ret->setPosition( x, y );
+	ret->setSize( br, hö );
+	if( ( style | AuswahlBox::Style::Hintergrund ) == style )
+		ret->setHintergrundFarbe( 0xFF000000 );
+	if( ( style | AuswahlBox::Style::Erlaubt ) == style )
+		ret->setMausEreignis( _ret1ME );
+	if( zSchrift )
+		ret->setSchriftZ( zSchrift->getThis() );
+	if( ( style | AuswahlBox::Style::Rahmen ) == style )
+	{
+		ret->setLinienRahmenBreite( 1 );
+		ret->setLinienRahmenFarbe( 0xFFFFFFFF );
+	}
+	if( ( style | AuswahlBox::Style::MaxHeight ) == style )
+		ret->setMaxAuskappHeight( 100 );
+	if( ( style | AuswahlBox::Style::MausRahmen ) == style )
+	{
+		ret->setMausRahmenBreite( 1 );
+		ret->setMausRahmenFarbe( 0xFF005500 );
+	}
+	if( ( style | AuswahlBox::Style::MausBuffer ) == style )
+	{
+		ret->setMausAlphaFeldFarbe( 0x00008700 );
+		ret->setMausAlphaFeldStrength( -8 );
+	}
+	if( ( style | AuswahlBox::Style::AuswahlRahmen ) == style )
+	{
+		ret->setAuswRahmenBreite( 1 );
+		ret->setAuswRahmenFarbe( 0xFF00FF00 );
+	}
+	if( ( style | AuswahlBox::Style::AuswahlBuffer ) == style )
+	{
+		ret->setAuswAlphaFeldFarbe( 0x0000FF00 );
+		ret->setAuswAlphaFeldStrength( -8 );
+	}
+	for( auto i = values.begin(); i != values.end(); i++ )
+	{
+		ret->addEintrag( *i );
+	}
+	return ret;
+}
+
+ObjTabelle *initObjTabelle( int x, int y, int br, int hö, Schrift *zSchrift, int style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe )
+{
+	ObjTabelle *ret = new ObjTabelle();
+	ret->setStyle( style );
+	ret->setPosition( x, y );
+	ret->setSize( br, hö );
+	if( ( style | ObjTabelle::Style::Erlaubt ) == style )
+		ret->setMausEreignis( _ret1ME );
+	if( ( style | ObjTabelle::Style::Rahmen ) == style )
+	{
+		ret->setLinienRahmenBreite( 1 );
+		ret->setLinienRahmenFarbe( 0xFFFFFFFF );
+	}
+	if( ( style | ObjTabelle::Style::Raster ) == style )
+	{
+		ret->setRasterBreite( 1 );
+		ret->setRasterFarbe( 0xFFFFFFFF );
+	}
+	if( ( style | ObjTabelle::Style::VScroll ) == style )
+		ret->setVertikalKlickScroll( 5 );
+	if( ( style | ObjTabelle::Style::HScroll ) == style )
+		ret->setHorizontalKlickScroll( 5 );
+	for( auto i = spalten.begin(); i != spalten.end(); i++ )
+	{
+		ret->addSpalte( i->name );
+		ret->setSpaltenBreite( i->name, i->breite );
+		if( ( style | ObjTabelle::Style::SpaltenBreiteMin ) == style )
+			ret->setMinSpaltenBreite( i->name, i->minBreite );
+		if( ( style | ObjTabelle::Style::SpaltenBreiteMax ) == style )
+			ret->setMaxSpaltenBreite( i->name, i->maxBreite );
+		if( überschriftHöhe )
+		{
+			if( ret->getZeilenNummer( "Überschrift" ) < 0 )
+			{
+				ret->addZeile( 0, "Überschrift" );
+				ret->setZeilenHeight( 0, 20 );
+			}
+			ret->setZeichnungZ( i->name, "Überschrift", initTextFeld( 0, 0, i->breite, 20, zSchrift, TextFeld::Style::Text, i->name ) );
+		}
+	}
+	return ret;
+}
+
+void initToolTip( Zeichnung *obj, const char *txt, Schrift *schrift, Bildschirm *zBs )
+{
+	obj->setToolTipText( txt, zBs );
+	if( schrift )
+		obj->zToolTip()->setSchriftZ( schrift );
+	obj->zToolTip()->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha | TextFeld::Style::Mehrzeilig );
+	obj->zToolTip()->setHintergrundFarbe( 0xA0000000 );
+	obj->zToolTip()->setLinienRahmenFarbe( 0xFFFFFFFF );
+	obj->zToolTip()->setSchriftFarbe( 0xFFFFFFFF );
+}

Asteroids/Initialisierung/Initialisierung.h

@@ -0,0 +1,32 @@
+#ifndef Initialisierung_H
+#define Initialisierung_H
+
+#include <Knopf.h>
+#include <Fenster.h>
+#include <TextFeld.h>
+#include <Schrift.h>
+#include <Bild.h>
+#include <AuswahlBox.h>
+#include <Tabelle.h>
+#include <initializer_list>
+
+using namespace Framework;
+
+struct OBJTabelleSpalteIni
+{
+	char *name;
+	int breite;
+	int minBreite;
+	int maxBreite;
+};
+
+Knopf *initKnopf( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *titel );
+KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *txt );
+Fenster *initFenster( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *titel );
+TextFeld *initTextFeld( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *txt );
+BildZ *initBildZ( int x, int y, int br, int hö, int style, Bild *b );
+AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, Schrift *zSchrift, int style, std::initializer_list< char * > values );
+ObjTabelle *initObjTabelle( int x, int y, int br, int hö, Schrift *zSchrift, int style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe );
+void initToolTip( Zeichnung *obj, const char *txt, Schrift *schrift, Bildschirm *zBs );
+
+#endif

Asteroids/Netzwerk/STKNachricht.cpp

@@ -0,0 +1,62 @@
+#include "STKNachricht.h"
+
+// Inhalt der STKNachricht Klasse aus STKNachricht.h
+// Konstruktor
+STKNachricht::STKNachricht( int län, char *nachricht )
+{
+	verarbeitet = 0;
+	spielZeit = *(int*)nachricht;
+	this->län = län - 4;
+	this->nachricht = new char[ this->län ];
+	for( int i = 0; i < this->län; i++ )
+		this->nachricht[ i ] = nachricht[ i + 4 ];
+	ref = 1;
+}
+
+// Destruktor
+STKNachricht::~STKNachricht()
+{
+	delete[] nachricht;
+}
+
+// nicht constant
+void STKNachricht::setVerarbeitet()
+{
+	verarbeitet = 1;
+}
+
+// constant
+bool STKNachricht::istVerarbeitet() const
+{
+	return verarbeitet;
+}
+
+int STKNachricht::getSpielZeit() const
+{
+	return spielZeit;
+}
+
+int STKNachricht::getLength() const
+{
+	return län;
+}
+
+char *STKNachricht::getNachricht() const
+{
+	return nachricht;
+}
+
+// Reference Counting
+STKNachricht *STKNachricht::getThis()
+{
+	ref++;
+	return this;
+}
+
+STKNachricht *STKNachricht::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Netzwerk/STKNachricht.h

@@ -0,0 +1,30 @@
+#ifndef STKNachricht_H
+#define STKNachricht_H
+
+class STKNachricht
+{
+private:
+	int spielZeit;
+	int län;
+	char *nachricht;
+	bool verarbeitet;
+	int ref;
+
+public:
+	// Konstruktor
+	STKNachricht( int län, char *nachricht );
+	// Destruktor
+	~STKNachricht();
+	// nicht constant
+	void setVerarbeitet();
+	// constant
+	bool istVerarbeitet() const;
+	int getSpielZeit() const;
+	int getLength() const;
+	char *getNachricht() const;
+	// Reference Counting
+	STKNachricht *getThis();
+	STKNachricht *release();
+};
+
+#endif

Asteroids/Spiel/Bestenliste/Bestenliste.cpp

@@ -0,0 +1,489 @@
+#include "Bestenliste.h"
+#include <Rahmen.h>
+#include <Schrift.h>
+#include <Punkt.h>
+#include <Scroll.h>
+#include <TastaturEreignis.h>
+#include "../../Initialisierung/Initialisierung.h"
+#include "..\Spieler\Spieler.h"
+
+int getStellen( double d );
+
+// Inhalt der BLSpieler Klasse aus Bestenliste.h
+// Konstruktor
+BLSpieler::BLSpieler( int sNum, Schrift *zS )
+{
+	this->sNum = sNum;
+
+	rahmen = new LRahmen();
+	rahmen->setRamenBreite( 1 );
+	rahmen->setSize( 420, 20 );
+	name = initTextFeld( 0, 0, 100, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+	punkte = initTextFeld( 100, 0, 50, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+	kills = initTextFeld( 150, 0, 40, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+	tode = initTextFeld( 190, 0, 40, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+	schadenGemacht = initTextFeld( 230, 0, 60, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+	schadenGenommen = initTextFeld( 290, 0, 60, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+	präzision = initTextFeld( 350, 0, 70, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+
+	ref = 1;
+}
+
+// Destruktor
+BLSpieler::~BLSpieler()
+{
+	rahmen->release();
+	name->release();
+	punkte->release();
+	kills->release();
+	tode->release();
+	schadenGemacht->release();
+	schadenGenommen->release();
+	präzision->release();
+}
+
+// nicht constant
+bool BLSpieler::update( Spieler *zSpieler )
+{
+	if( sNum != zSpieler->getSpielerNummer() )
+		return 0;
+	rahmen->setFarbe( zSpieler->getSpielerFarbe() );
+	name->setText( zSpieler->zName()->getText() );
+	name->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+	punkte->setText( Text() += zSpieler->getPunkte() );
+	punkte->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+	kills->setText( Text() += zSpieler->getKills() );
+	kills->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+	tode->setText( Text() += zSpieler->getTode() );
+	tode->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+	schadenGemacht->setText( Text() += zSpieler->getSchadenGemacht() );
+	schadenGemacht->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+	schadenGenommen->setText( Text() += zSpieler->getSchadenBekommen() );
+	schadenGenommen->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+	Text txt;
+	double d = 100 * ( (double)zSpieler->getTreffer() / zSpieler->getSchüsse() );
+	if( !zSpieler->getSchüsse() )
+		d = 0;
+	txt.setPrecision( getStellen( d ) + 2 );
+	txt += d;
+	präzision->setText( txt );
+	präzision->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+	return 1;
+}
+
+void BLSpieler::render( int y, Bild &zRObj )
+{
+	if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
+		return;
+	rahmen->render( zRObj );
+	name->render( zRObj );
+	punkte->render( zRObj );
+	kills->render( zRObj );
+	tode->render( zRObj );
+	schadenGemacht->render( zRObj );
+	schadenGenommen->render( zRObj );
+	präzision->render( zRObj );
+	zRObj.releaseDrawOptions();
+}
+
+// constant
+int BLSpieler::getSpielerNummer() const
+{
+	return sNum;
+}
+
+int BLSpieler::getPunkte() const
+{
+	return *punkte->zText();
+}
+
+// Reference Counting
+BLSpieler *BLSpieler::getThis()
+{
+	ref++;
+	return this;
+}
+
+BLSpieler *BLSpieler::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}
+
+// Inhalt der BLTeam Klasse aus Bestenliste.h
+// Konstruktor
+BLTeam::BLTeam( int id, Schrift *s )
+{
+	teamId = id;
+	spielerAnzahl = 0;
+	schrift = s;
+	spieler = new RCArray< BLSpieler >();
+
+	rahmen = new LRahmen();
+	rahmen->setRamenBreite( 1 );
+	name = initTextFeld( 0, 0, 100, 20, s, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+	punkte = initTextFeld( 100, 0, 50, 20, s, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+
+	ref = 1;
+}
+
+// Destruktor
+BLTeam::~BLTeam()
+{
+	schrift->release();
+	rahmen->release();
+	spieler->release();
+	name->release();
+	punkte->release();
+}
+
+// nicht constant
+bool BLTeam::addSpieler( Spieler *zSpieler )
+{
+	bool gefunden = 0;
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
+		{
+			gefunden = 1;
+			break;
+		}
+	}
+	if( gefunden )
+		return 0;
+	BLSpieler *tmp = new BLSpieler( zSpieler->getSpielerNummer(), schrift );
+	tmp->update( zSpieler );
+	spieler->set( tmp, spielerAnzahl );
+	spielerAnzahl++;
+	return 1;
+}
+
+bool BLTeam::updateSpieler( Spieler *zSpieler )
+{
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
+		{
+			spieler->z( i )->update( zSpieler );
+			return 1;
+		}
+	}
+	return 0;
+}
+
+void BLTeam::update( Team *zTeam )
+{
+	rahmen->setFarbe( zTeam->farbe );
+	name->setSchriftFarbe( zTeam->farbe );
+	name->setText( zTeam->name );
+	punkte->setSchriftFarbe( zTeam->farbe );
+	Text pt;
+	pt += zTeam->punkte;
+	pt += "/";
+	pt += zTeam->maxPunkte;
+	punkte->setText( pt );
+}
+
+void BLTeam::render( int y, Bild &zRObj )
+{
+	rahmen->setSize( 422, 21 + 20 * spielerAnzahl );
+	if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
+		return;
+	rahmen->render( zRObj );
+	name->render( zRObj );
+	punkte->render( zRObj );
+	Array< bool > *gemahlt = new Array< bool >();
+	for( int i = 0; i < spielerAnzahl; i++ )
+		gemahlt->set( 0, i );
+	int min = -1;
+	int tmp = -1;
+	for( int h = 0; h < spielerAnzahl; h++ )
+	{
+		min = 0x80000000;
+		tmp = 0x80000000;
+		for( int i = 0; i < spielerAnzahl; i++ )
+		{
+			if( !spieler->z( i ) )
+				continue;
+			if( gemahlt->hat( i ) && gemahlt->get( i ) )
+				continue;
+			int p = spieler->z( i )->getPunkte();
+			if( p > min )
+			{
+				min = p;
+				tmp = i;
+			}
+		}
+		if( tmp != 0x80000000 )
+		{
+			gemahlt->set( 1, tmp );
+			spieler->z( tmp )->render( 20 + 20 * h, zRObj );
+		}
+		else
+			break;
+	}
+	gemahlt->release();
+	zRObj.releaseDrawOptions();
+}
+
+// constant
+int BLTeam::getSpielerAnzahl() const
+{
+	return spielerAnzahl;
+}
+
+int BLTeam::getPunkte() const
+{
+	Text *tmp = punkte->zText()->getTeilText( 0, punkte->zText()->positionVon( '/' ) );
+	int ret = *tmp;
+	tmp->release();
+	return ret;
+}
+
+int BLTeam::getHeight() const
+{
+	return 21 + spielerAnzahl * 20;
+}
+
+// Reference Counting
+BLTeam *BLTeam::getThis()
+{
+	ref++;
+	return this;
+}
+
+BLTeam *BLTeam::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}
+
+// Inhalt der Bestenliste Klasse aus Bestenliste.h
+// Konstruktor
+Bestenliste::Bestenliste( Schrift *s )
+{
+	rahmen = new LRahmen();
+	rahmen->setRamenBreite( 1 );
+	rahmen->setFarbe( 0xFFFFFFFF );
+	rahmen->setSize( 440, 200 );
+
+	teams = new RCArray< BLTeam >();
+
+	name = new TextFeld();
+	name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+	name->setSchriftZ( s->getThis() );
+	name->setSchriftFarbe( 0xFFFFFFFF );
+	name->setSchriftSize( 12 );
+	name->setText( "Name" );
+	name->setSize( 100, 30 );
+	name->setPosition( 0, 0 );
+
+	punkte = new TextFeld();
+	punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+	punkte->setSchriftZ( s->getThis() );
+	punkte->setSchriftFarbe( 0xFFFFFFFF );
+	punkte->setSchriftSize( 12 );
+	punkte->setText( "Punkte" );
+	punkte->setSize( 50, 30 );
+	punkte->setPosition( 100, 0 );
+
+	kills = new TextFeld();
+	kills->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+	kills->setSchriftZ( s->getThis() );
+	kills->setSchriftFarbe( 0xFFFFFFFF );
+	kills->setSchriftSize( 12 );
+	kills->setText( "Kills" );
+	kills->setSize( 40, 30 );
+	kills->setPosition( 150, 0 );
+
+	tode = new TextFeld();
+	tode->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+	tode->setSchriftZ( s->getThis() );
+	tode->setSchriftFarbe( 0xFFFFFFFF );
+	tode->setSchriftSize( 12 );
+	tode->setText( "Tode" );
+	tode->setSize( 40, 30 );
+	tode->setPosition( 190, 0 );
+
+	schadenGemacht = new TextFeld();
+	schadenGemacht->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig );
+	schadenGemacht->setSchriftZ( s->getThis() );
+	schadenGemacht->setSchriftFarbe( 0xFFFFFFFF );
+	schadenGemacht->setSchriftSize( 12 );
+	schadenGemacht->setText( "Schaden\ngemacht" );
+	schadenGemacht->setSize( 60, 30 );
+	schadenGemacht->setPosition( 230, 0 );
+
+	schadenGenommen = new TextFeld();
+	schadenGenommen->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig );
+	schadenGenommen->setSchriftZ( s->getThis() );
+	schadenGenommen->setSchriftFarbe( 0xFFFFFFFF );
+	schadenGenommen->setSchriftSize( 12 );
+	schadenGenommen->setText( "Schaden\ngenommen" );
+	schadenGenommen->setSize( 60, 30 );
+	schadenGenommen->setPosition( 290, 0 );
+
+	präzision = new TextFeld();
+	präzision->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig );
+	präzision->setSchriftZ( s->getThis() );
+	präzision->setSchriftFarbe( 0xFFFFFFFF );
+	präzision->setSchriftSize( 12 );
+	präzision->setText( "präzision" );
+	präzision->setSize( 70, 30 );
+	präzision->setPosition( 350, 0 );
+
+	scroll = new VScrollBar();
+	scroll->setKlickScroll( 7 );
+
+	sichtbar = 0;
+	schrift = s;
+	teamAnzahl = 0;
+	ref = 1;
+}
+
+// Destruktor
+Bestenliste::~Bestenliste()
+{
+	rahmen->release();
+	teams->release();
+	name->release();
+	punkte->release();
+	kills->release();
+	tode->release();
+	schadenGemacht->release();
+	schadenGenommen->release();
+	präzision->release();
+	scroll->release();
+	schrift->release();
+}
+
+// nicht constant
+void Bestenliste::setTeamAnzahl( int anz )
+{
+	teamAnzahl = anz;
+}
+
+void Bestenliste::addSpieler( Spieler *zSpieler )
+{
+	int team = zSpieler->zTeam()->id;
+	if( team < 0 )
+		return;
+	if( !teams->z( team ) )
+		teams->set( new BLTeam( team, schrift->getThis() ), team );
+	teams->z( team )->addSpieler( zSpieler );
+}
+
+void Bestenliste::updateSpieler( Spieler *zSpieler )
+{
+	if( teams->z( zSpieler->zTeam()->id ) )
+		teams->z( zSpieler->zTeam()->id )->updateSpieler( zSpieler );
+}
+
+void Bestenliste::updateTeam( Team *zTeam )
+{
+	if( teams->z( zTeam->id ) )
+		teams->z( zTeam->id )->update( zTeam );
+}
+
+void Bestenliste::doTastaturEreignis( TastaturEreignis &te )
+{
+	if( te.id == TE_Press && te.taste == T_Tab )
+		sichtbar = !sichtbar;
+}
+
+void Bestenliste::doMausEreignis( MausEreignis &me )
+{
+	if( !sichtbar )
+		return;
+	scroll->doMausMessage( rahmen->getBreite() - 15, 1, 15, rahmen->getHeight() - 2, me );
+}
+
+void Bestenliste::render( Bild &zRObj )
+{
+	if( !sichtbar )
+		return;
+	if( !zRObj.setDrawOptions( 0, 0, rahmen->getBreite(), rahmen->getHeight() ) )
+		return;
+	rahmen->render( zRObj );
+	zRObj.alphaRegion( 1, 1, rahmen->getBreite() - 2, rahmen->getHeight() - 2, 0xA0000000 );
+	zRObj.addScrollOffset( 0, scroll->getScroll() );
+	name->render( zRObj );
+	punkte->render( zRObj );
+	kills->render( zRObj );
+	tode->render( zRObj );
+	schadenGemacht->render( zRObj );
+	schadenGenommen->render( zRObj );
+	präzision->render( zRObj );
+	int yOff = 30;
+	Array< bool > *gemahlt = new Array< bool >();
+	for( int i = 1; i <= teamAnzahl; i++ )
+		gemahlt->set( 0, i );
+	int min = -1;
+	int tmp = -1;
+	for( int h = 0; h < teamAnzahl; h++ )
+	{
+		min = -1;
+		tmp = -1;
+		for( int i = 0; i < teamAnzahl; i++ )
+		{
+			if( !teams->z( i + 1 ) )
+				continue;
+			if( gemahlt->hat( i + 1 ) && gemahlt->get( i + 1 ) )
+				continue;
+			int p = teams->z( i + 1 )->getPunkte();
+			if( p > min )
+			{
+				min = p;
+				tmp = i + 1;
+			}
+		}
+		if( tmp >= 0 )
+		{
+			gemahlt->set( 1, tmp );
+			teams->z( tmp )->render( yOff, zRObj );
+			yOff += teams->z( tmp )->getHeight();
+		}
+		else
+			break;
+	}
+	gemahlt->release();
+	zRObj.addScrollOffset( 0, -scroll->getScroll() );
+	scroll->update( yOff, rahmen->getHeight() - 2 );
+	scroll->render( rahmen->getBreite() - 16, 1, 15, rahmen->getHeight() - 2, zRObj );
+	zRObj.releaseDrawOptions();
+}
+
+// constant
+int Bestenliste::getTeamAnzahl() const
+{
+	return teamAnzahl;
+}
+
+bool Bestenliste::teamExistiert( int team ) const
+{
+	return teams->z( team ) != 0;
+}
+
+int Bestenliste::getTeamPunkte( int team ) const
+{
+	return teams->z( team ) ? teams->z( team )->getPunkte() : 0;
+}
+
+// Reference Counting
+Bestenliste *Bestenliste::getThis()
+{
+	ref++;
+	return this;
+}
+
+Bestenliste *Bestenliste::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Spiel/Bestenliste/Bestenliste.h

@@ -0,0 +1,113 @@
+#ifndef Bestenliste_H
+#define Bestenliste_H
+
+#include <TextFeld.h>
+#include <Array.h>
+
+using namespace Framework;
+
+class Spieler; // Spieler.h
+class Team; // Team.h
+
+class BLSpieler
+{
+private:
+	int sNum;
+	LRahmen *rahmen;
+	TextFeld *name;
+	TextFeld *punkte;
+	TextFeld *kills;
+	TextFeld *tode;
+	TextFeld *schadenGemacht;
+	TextFeld *schadenGenommen;
+	TextFeld *präzision;
+	int ref;
+
+public:
+	// Konstruktor
+	BLSpieler( int sNum, Schrift *zS );
+	// Destruktor
+	~BLSpieler();
+	// nicht constant
+	bool update( Spieler *zSpieler );
+	void render( int y, Bild &zRObj );
+	// constant
+	int getSpielerNummer() const;
+	int getPunkte() const;
+	// Reference Counting
+	BLSpieler *getThis();
+	BLSpieler *release();
+};
+
+class BLTeam
+{
+private:
+	int teamId;
+	int spielerAnzahl;
+	Schrift *schrift;
+	LRahmen *rahmen;
+	RCArray< BLSpieler > *spieler;
+	TextFeld *name;
+	TextFeld *punkte;
+	int ref;
+
+public:
+	// Konstruktor
+	BLTeam( int id, Schrift *s );
+	// Destruktor
+	~BLTeam();
+	// nicht constant
+	bool addSpieler( Spieler *zSpieler );
+	void update( Team *zTeam );
+	bool updateSpieler( Spieler *zSpieler );
+	void render( int y, Bild &zRObj );
+	// constant
+	int getSpielerAnzahl() const;
+	int getPunkte() const;
+	int getHeight() const;
+	// Reference Counting
+	BLTeam *getThis();
+	BLTeam *release();
+};
+
+class Bestenliste
+{
+private:
+	LRahmen *rahmen;
+	RCArray< BLTeam > *teams;
+	TextFeld *name;
+	TextFeld *punkte;
+	TextFeld *kills;
+	TextFeld *tode;
+	TextFeld *schadenGemacht;
+	TextFeld *schadenGenommen;
+	TextFeld *präzision;
+	VScrollBar *scroll;
+	Schrift *schrift;
+	bool sichtbar;
+	int teamAnzahl;
+	int ref;
+
+public:
+	// Konstruktor
+	Bestenliste( Schrift *s );
+	// Destruktor
+	~Bestenliste();
+	// nicht constant
+	void setTeamAnzahl( int anz );
+	void addSpieler( Spieler *zSpieler );
+	void updateSpieler( Spieler *zSpieler );
+	void updateTeam( Team *zTeam );
+	void doTastaturEreignis( TastaturEreignis &te );
+	void doMausEreignis( MausEreignis &me );
+	void render( Bild &zRObj );
+	// constant
+	int getTeamAnzahl() const;
+	bool teamExistiert( int team ) const;
+	int getTeamPunkte( int team ) const;
+	// Reference Counting
+	Bestenliste *getThis();
+	Bestenliste *release();
+};
+
+#endif

Asteroids/Spiel/Chat/Chat.cpp

@@ -0,0 +1,167 @@
+#include "Chat.h"
+#include <Rahmen.h>
+#include <MausEreignis.h>
+#include <TastaturEreignis.h>
+#include <Text.h>
+#include <Schrift.h>
+#include <Punkt.h>
+#include <Bild.h>
+
+// Inhalt der SpielChat Klasse aus Chat.h
+// Konstruktor
+SpielChat::SpielChat()
+{
+	rahmen = new LRahmen();
+	rahmen->setFarbe( 0xFF909090 );
+	rahmen->setRamenBreite( 1 );
+	rahmen->setSize( 450, 200 );
+	rahmen->setPosition( 10, BildschirmGröße().y - 210 );
+	verlauf = new TextFeld();
+	verlauf->setStyle( TextFeld::Style::TextGebiet & ~( TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen ) );
+	verlauf->setText( "" );
+	verlauf->setSchriftFarbe( 0xFFFFFFFF );
+	verlauf->setSchriftSize( 12 );
+	verlauf->setPosition( rahmen->getX() + 2, rahmen->getY() + 2 );
+	verlauf->setSize( 446, 174 );
+	nachricht = new TextFeld();
+	nachricht->setStyle( TextFeld::Style::TextFeld & ~TextFeld::Style::Buffered );
+	nachricht->setText( "Drücke TAB um die Bestenliste anzuzeigen.\n" );
+	nachricht->setSchriftFarbe( 0xFF909090 );
+	nachricht->setSchriftSize( 12 );
+	nachricht->setLinienRahmenBreite( 1 );
+	nachricht->setLinienRahmenFarbe( 0xFF909090 );
+	nachricht->setPosition( rahmen->getX() + 2, rahmen->getY() + 178 );
+	nachricht->setSize( 446, 20 );
+	ref = 1;
+}
+
+// Destruktor
+SpielChat::~SpielChat()
+{
+	rahmen->release();
+	verlauf->release();
+	nachricht->release();
+}
+
+// nicht constant
+void SpielChat::setSchrift( Schrift *zSchrift )
+{
+	verlauf->setSchriftZ( zSchrift->getThis() );
+	nachricht->setSchriftZ( zSchrift->getThis() );
+}
+
+void SpielChat::addNachricht( char *nachricht )
+{
+	verlauf->addZeile( nachricht );
+	verlauf->updateVScroll();
+}
+
+void SpielChat::addNachricht( char *nachricht, int farbe )
+{
+	verlauf->zText()->appendColor( farbe );
+	verlauf->addZeile( nachricht );
+	verlauf->zText()->appendColor( 0xFFFFFFFF );
+	verlauf->updateVScroll();
+}
+
+void SpielChat::doMausEreignis( MausEreignis &me )
+{
+	bool vera = me.verarbeitet;
+	verlauf->doMausEreignis( me );
+	nachricht->doMausEreignis( me );
+	if( !vera && me.verarbeitet )
+	{
+		nachricht->setLinienRahmenFarbe( 0xFFFFFFFF );
+		nachricht->setSchriftFarbe( 0xFFFFFFFF );
+		verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
+		rahmen->setFarbe( 0xFFFFFFFF );
+	}
+	else
+	{
+		nachricht->setLinienRahmenFarbe( 0xFF909090 );
+		nachricht->setSchriftFarbe( 0xFF909090 );
+		verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
+		rahmen->setFarbe( 0xFF909090 );
+	}
+}
+
+void SpielChat::doTastaturEreignis( TastaturEreignis &te, SpielKlientV *zKlient )
+{
+	if( te.taste == T_Esc )
+		nachricht->removeStyle( TextFeld::Style::Fokus );
+	if( te.id == TE_Release && te.taste == T_Enter && !te.verarbeitet )
+	{
+		if( nachricht->hatStyle( TextFeld::Style::Fokus ) )
+		{
+			if( nachricht->zText()->getLength() )
+			{
+				short län = 1 + nachricht->zText()->getLength();
+				char *bytes = new char[ län + 1 ];
+				*bytes = 8;
+				for( int i = 1; i <= län; i++ )
+					bytes[ i ] = nachricht->zText()->getText()[ i - 1 ];
+				nachricht->setText( "" );
+				nachricht->setAuswahl( 0, 0 );
+				nachricht->removeStyle( TextFeld::Style::Fokus );
+				zKlient->spielNachricht( län, bytes );
+				delete[] bytes;
+				te.verarbeitet = 1;
+			}
+		}
+		else
+		{
+			nachricht->addStyle( TextFeld::Style::Fokus );
+			nachricht->setAuswahl( 0, nachricht->zText()->getLength() );
+			te.verarbeitet = 1;
+		}
+	}
+	if( !te.verarbeitet )
+		nachricht->doTastaturEreignis( te );
+	if( nachricht->hatStyle( TextFeld::Style::Fokus ) )
+	{
+		nachricht->setLinienRahmenFarbe( 0xFFFFFFFF );
+		nachricht->setSchriftFarbe( 0xFFFFFFFF );
+		verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
+		rahmen->setFarbe( 0xFFFFFFFF );
+	}
+	else
+	{
+		nachricht->setLinienRahmenFarbe( 0xFF909090 );
+		nachricht->setSchriftFarbe( 0xFF909090 );
+		verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
+		rahmen->setFarbe( 0xFF909090 );
+	}
+}
+
+void SpielChat::tick( double z )
+{
+	nachricht->tick( z );
+}
+
+void SpielChat::render( Bild &zRObj )
+{
+	rahmen->render( zRObj );
+	verlauf->render( zRObj );
+	nachricht->render( zRObj );
+}
+
+// constant
+bool SpielChat::istAktiv() const
+{
+	return nachricht->hatStyle( TextFeld::Style::Fokus );
+}
+
+// Reference Counting
+SpielChat *SpielChat::getThis()
+{
+	ref++;
+	return this;
+}
+
+SpielChat *SpielChat::relese()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Spiel/Chat/Chat.h

@@ -0,0 +1,37 @@
+#ifndef Chat_H
+#define Chat_H
+
+#include <KSGKlientV.h>
+#include <TextFeld.h>
+
+using namespace Framework;
+
+class SpielChat
+{
+private:
+	LRahmen *rahmen = 0;
+	TextFeld *verlauf;
+	TextFeld *nachricht;
+	int ref;
+
+public:
+	// Konstruktor
+	SpielChat();
+	// Destruktor
+	~SpielChat();
+	// nicht constant
+	void setSchrift( Schrift *zSchrift );
+	void addNachricht( char *nachricht );
+	void addNachricht( char *nachricht, int farbe );
+	void doMausEreignis( MausEreignis &me );
+	void doTastaturEreignis( TastaturEreignis &te, SpielKlientV *zKlient );
+	void tick( double z );
+	void render( Bild &zRObj );
+	// constant
+	bool istAktiv() const;
+	// Reference Counting
+	SpielChat *getThis();
+	SpielChat *relese();
+};
+
+#endif

Asteroids/Spiel/Define.h

@@ -0,0 +1,3 @@
+#ifndef TICK
+#define TICK 0.03333333
+#endif

Asteroids/Spiel/Ende/Ende.cpp

@@ -0,0 +1,111 @@
+#include "Ende.h"
+#include <TextFeld.h>
+#include <Bild.h>
+#include <MausEreignis.h>
+#include <Rahmen.h>
+#include <Schrift.h>
+
+// Inhalt der Ende Klasse aus Ende.h
+// Konstruktor
+Ende::Ende( Schrift *zSchrift )
+{
+	rahmen = new LRahmen();
+	rahmen->setSize( 200, 100 );
+	rahmen->setRamenBreite( 2 );
+	rahmen->setFarbe( 0xFFFFFFFF );
+	text = new TextFeld();
+	text->setStyle( TextFeld::Style::Text | TextFeld::Style::Center );
+	text->setSchriftZ( zSchrift->getThis() );
+	text->setText( "" );
+	text->setSchriftFarbe( 0xFFFFFFFF );
+	text->setSize( 200, 50 );
+	warten = new TextFeld();
+	warten->setStyle( ( TextFeld::Style::Text | TextFeld::Style::Center ) & ~TextFeld::Style::Sichtbar );
+	warten->setSchriftZ( zSchrift->getThis() );
+	warten->setText( "Bitte warten..." );
+	warten->setSchriftFarbe( 0xFFFFFFFF );
+	warten->setSize( 200, 50 );
+	ok = new Knopf();
+	ok->setStyle( Knopf::Style::Normal );
+	ok->setSize( 100, 20 );
+	ok->setText( "Weiter" );
+	ok->setSchriftZ( zSchrift->getThis() );
+	weiter = 0;
+	ref = 1;
+}
+
+// Destruktor
+Ende::~Ende()
+{
+	rahmen->release();
+	text->release();
+	warten->release();
+	ok->release();
+}
+
+// nicht constant
+void Ende::setGewonnen( char gewonnen )
+{
+	if( gewonnen == 1 )
+	{
+		text->setText( "Du hast gewonnen." );
+		text->setSchriftFarbe( 0xFF00FF00 );
+	}
+	else if( !gewonnen )
+	{
+		text->setText( "Du hast verloren." );
+		text->setSchriftFarbe( 0xFFFF0000 );
+	}
+	else
+	{
+		text->setText( "Unentschieden." );
+		text->setSchriftFarbe( 0xFFFFFFFF );
+	}
+}
+
+void Ende::doMausEreignis( MausEreignis &me )
+{
+	bool vera = me.verarbeitet;
+	ok->doMausEreignis( me );
+	if( !vera && me.verarbeitet && me.id == ME_RLinks )
+	{
+		ok->removeStyle( Knopf::Style::Sichtbar );
+		warten->addStyle( TextFeld::Style::Sichtbar );
+		weiter = 1;
+	}
+	me.verarbeitet = 1;
+}
+
+void Ende::render( Bild &zRObj )
+{
+	rahmen->setPosition( zRObj.getBreite() / 2 - rahmen->getBreite() / 2, zRObj.getHeight() / 2 - rahmen->getHeight() / 2 );
+	zRObj.alphaRegion( rahmen->getX(), rahmen->getY(), rahmen->getBreite(), rahmen->getHeight(), 0xA0000000 );
+	rahmen->render( zRObj );
+	text->setPosition( rahmen->getX(), rahmen->getY() );
+	text->render( zRObj );
+	warten->setPosition( rahmen->getX(), rahmen->getY() + 50 );
+	warten->render( zRObj );
+	ok->setPosition( rahmen->getX() + rahmen->getBreite() / 2 - ok->getBreite() / 2, rahmen->getY() + 65 );
+	ok->render( zRObj );
+}
+
+// constant
+bool Ende::getWeiter() const
+{
+	return weiter;
+}
+
+// Reference Counting
+Ende *Ende::getThis()
+{
+	ref++;
+	return this;
+}
+
+Ende *Ende::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Spiel/Ende/Ende.h

@@ -0,0 +1,34 @@
+#ifndef Ende_H
+#define Ende_H
+
+#include <Knopf.h>
+
+using namespace Framework;
+
+class Ende
+{
+private:
+	LRahmen *rahmen;
+	TextFeld *text;
+	TextFeld *warten;
+	Knopf *ok;
+	bool weiter;
+	int ref;
+
+public:
+	// Konstruktor
+	Ende( Schrift *zSchrift );
+	// Destruktor
+	~Ende();
+	// nicht constant
+	void setGewonnen( char gewonnen );
+	void doMausEreignis( MausEreignis &me );
+	void render( Bild &zRObj );
+	// constant
+	bool getWeiter() const;
+	// Reference Counting
+	Ende *getThis();
+	Ende *release();
+};
+
+#endif

Asteroids/Spiel/Kamera/Kamera.cpp

@@ -0,0 +1,292 @@
+#include "Kamera.h"
+#include "../Karte/Karte.h"
+
+// Inhalt der Kamera Klasse aus Kamera.h
+// Konstruktor
+Kamera::Kamera()
+{
+	pos = Punkt( 0, 0 );
+	mmr.setFarbe( 0xFFFFFFFF );
+	mmr.setRamenBreite( 1 );
+	ref = 1;
+}
+
+// nicht constant
+void Kamera::setPosition( int x, int y )
+{
+	pos = Punkt( x, y );
+}
+
+void Kamera::addPosition( int x, int y, Karte *zMap )
+{
+	pos += Punkt( x, y );
+	if( zMap )
+	{
+		if( pos.x < 0 )
+			pos.x += zMap->getSize().x;
+		if( pos.y < 0 )
+			pos.y += zMap->getSize().y;
+		if( pos.x >= zMap->getSize().x )
+			pos.x -= zMap->getSize().x;
+		if( pos.y >= zMap->getSize().y )
+			pos.y -= zMap->getSize().y;
+	}
+}
+
+bool Kamera::beginnRender( Bild &zRObj, Karte *zMap, int n )
+{
+	Punkt kamLO( pos.x - zRObj.getBreite() / 2, pos.y - zRObj.getHeight() / 2 );
+	Punkt kamRU( pos.x + zRObj.getBreite() / 2, pos.y + zRObj.getHeight() / 2 );
+	Punkt mapGr = zMap->getSize();
+	int c = 0;
+	if( kamLO.x < 0 )
+		c |= 1;
+	if( kamLO.y / 2 < 0 )
+		c |= 2;
+	if( kamRU.x > mapGr.x )
+		c |= 4;
+	if( kamRU.y > mapGr.y )
+		c |= 8;
+	switch( c )
+	{
+	case 0:
+		if( n )
+			return 0;
+		if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+			return 0;
+		zRObj.addScrollOffset( kamLO.x, kamLO.y );
+		break;
+	case 1:
+		if( n > 1 )
+			return 0;
+		if( !n )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x + zMap->getSize().x, kamLO.y );
+		}
+		if( n == 1 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y );
+		}
+		break;
+	case 2:
+		if( n > 1 )
+			return 0;
+		if( !n )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y + mapGr.y );
+		}
+		if( n == 1 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y );
+		}
+		break;
+	case 3:
+		if( n > 3 )
+			return 0;
+		if( !n )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x + mapGr.x, kamLO.y + mapGr.y );
+		}
+		if( n == 1 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x + mapGr.x, kamLO.y );
+		}
+		if( n == 2 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y + mapGr.y );
+		}
+		if( n == 3 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y );
+		}
+		break;
+	case 4:
+		if( n > 1 )
+			return 0;
+		if( !n )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y );
+		}
+		if( n == 1 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x - mapGr.x, kamLO.y );
+		}
+		break;
+	case 6:
+		if( n > 3 )
+			return 0;
+		if( !n )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y + mapGr.y );
+		}
+		if( n == 1 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x - mapGr.x, kamLO.y + mapGr.y );
+		}
+		if( n == 2 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x - mapGr.x, kamLO.y );
+		}
+		if( n == 3 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y );
+		}
+		break;
+	case 8:
+		if( n > 1 )
+			return 0;
+		if( !n )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y );
+		}
+		if( n == 1 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y - mapGr.y );
+		}
+		break;
+	case 9:
+		if( n > 3 )
+			return 0;
+		if( !n )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x + mapGr.x, kamLO.y );
+		}
+		if( n == 1 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x + mapGr.x, kamLO.y - mapGr.y );
+		}
+		if( n == 2 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y - mapGr.y );
+		}
+		if( n == 3 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y );
+		}
+		break;
+	case 12:
+		if( n > 3 )
+			return 0;
+		if( !n )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y );
+		}
+		if( n == 1 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x, kamLO.y - mapGr.y );
+		}
+		if( n == 2 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x - mapGr.x, kamLO.y );
+		}
+		if( n == 3 )
+		{
+			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
+				return 0;
+			zRObj.addScrollOffset( kamLO.x - mapGr.x, kamLO.y - mapGr.y );
+		}
+		break;
+	}
+	return 1;
+}
+
+void Kamera::endRender( Bild &zRObj )
+{
+	zRObj.releaseDrawOptions();
+}
+
+void Kamera::beginnMinimap( Bild &zRObj, Karte *zMap )
+{
+	zRObj.setDrawOptions( zRObj.getBreite() - 260, zRObj.getHeight() - 260, 250, 250 );
+	zRObj.drawLinieH( 0, 0, 250, 0xFFFFFFFF );
+	zRObj.drawLinieH( 0, 249, 250, 0xFFFFFFFF );
+	zRObj.drawLinieV( 0, 0, 250, 0xFFFFFFFF );
+	zRObj.drawLinieV( 249, 0, 250, 0xFFFFFFFF );
+	mmr.setSize( (int)( ( zRObj.getBreite() / (double)zMap->getSize().x ) * 250 + 0.5 ), (int)( ( zRObj.getHeight() / (double)zMap->getSize().y ) * 250 + 0.5 ) );
+	mmr.setPosition( (int)( ( pos.x / (double)zMap->getSize().x ) * 250 + 0.5 ), (int)( ( pos.y / (double)zMap->getSize().y ) * 250 + 0.5 ) );
+	mmr.setPosition( mmr.getPosition() - mmr.getSize() / 2 );
+	mmr.render( zRObj );
+	if( mmr.getX() < 0 )
+		mmr.setPosition( mmr.getPosition() + Punkt( 250, 0 ) );
+	mmr.render( zRObj );
+	if( mmr.getY() < 0 )
+		mmr.setPosition( mmr.getPosition() + Punkt( 0, 250 ) );
+	if( mmr.getX() >= 250 - mmr.getBreite() )
+		mmr.setPosition( mmr.getPosition() - Punkt( 250, 0 ) );
+	mmr.render( zRObj );
+	if( mmr.getY() >= 250 - mmr.getHeight() )
+		mmr.setPosition( mmr.getPosition() - Punkt( 0, 250 ) );
+	mmr.render( zRObj );
+}
+
+void Kamera::endMinimap( Bild &zRObj )
+{
+	zRObj.releaseDrawOptions();
+}
+
+// constant
+Punkt Kamera::getPos() const
+{
+	return pos;
+}
+
+// Reference Counting
+Kamera *Kamera::getThis()
+{
+	ref++;
+	return this;
+}
+
+Kamera *Kamera::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Spiel/Kamera/Kamera.h

@@ -0,0 +1,35 @@
+#ifndef Kamera_H
+#define Kamera_H
+
+#include <Bild.h>
+#include <Rahmen.h>
+
+using namespace Framework;
+
+class Karte;
+
+class Kamera
+{
+private:
+	Punkt pos;
+	LRahmen mmr;
+	int ref;
+
+public:
+	// Konstruktor
+	Kamera();
+	// nicht constant
+	void setPosition( int x, int y );
+	void addPosition( int x, int y, Karte *zMap );
+	bool beginnRender( Bild &zRObj, Karte *zMap, int n );
+	void endRender( Bild &zRObj );
+	void beginnMinimap( Bild &zRObj, Karte *zMap );
+	void endMinimap( Bild &zRObj );
+	// constant
+	Punkt getPos() const;
+	// Reference Counting
+	Kamera *getThis();
+	Kamera *release();
+};
+
+#endif

Asteroids/Spiel/Karte/Karte.cpp

@@ -0,0 +1,193 @@
+#include "Karte.h"
+#include <Text.h>
+
+// Inhalt der Karte Klasse aus Karte.h
+// Konstruktor
+Karte::Karte()
+{
+	größe = Vec2< int >( 0, 0 );
+	spielerAnzahl = 0;
+	teamAnzahl = 0;
+	spielerFarbe = new Array< int >();
+	teamFarbe = new Array< int >();
+	teamName = new RCArray< Text >();
+	teamGröße = new Array< int >();
+	ressources = new RCArray< RessourceStr >();
+	objekte = new RCArray< ZeichnungStr >();
+	spieler = new RCArray< SpielerStr >();
+	teams = new RCArray< TeamStr >();
+	ref = 1;
+}
+
+// Destruktor
+Karte::~Karte()
+{
+	spielerFarbe->release();
+	teamFarbe->release();
+	teamName->release();
+	teamGröße->release();
+	ressources->release();
+	objekte->release();
+	spieler->release();
+	teams->release();
+}
+
+// nicht constant
+void Karte::ladeSts( Datei *zDatei )
+{
+	zDatei->lese( (char*)&spielerAnzahl, 4 );
+	zDatei->lese( (char*)&teamAnzahl, 4 );
+	spielerFarbe->leeren();
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		int farbe = 0;
+		zDatei->lese( (char*)&farbe, 4 );
+		spielerFarbe->set( farbe, i );
+	}
+	teamFarbe->leeren();
+	for( int i = 0; i < teamAnzahl; i++ )
+	{
+		int farbe = 0;
+		zDatei->lese( (char*)&farbe, 4 );
+		teamFarbe->set( farbe, i );
+	}
+	teamName->leeren();
+	for( int i = 0; i < teamAnzahl; i++ )
+	{
+		char län = 0;
+		zDatei->lese( &län, 1 );
+		char *txt = new char[ län + 1 ];
+		txt[ (int)län ] = 0;
+		zDatei->lese( txt, län );
+		Text *name = new Text( txt );
+		delete[] txt;
+		teamName->set( name, i );
+	}
+	teamGröße->leeren();
+	for( int i = 0; i < teamAnzahl; i++ )
+	{
+		int größe = 0;
+		zDatei->lese( (char*)&größe, 4 );
+		teamGröße->set( größe, i );
+	}
+}
+
+void Karte::ladeMap( Datei *zDatei, InformationKlientV *infoK, int mapId, SpielKlientV *zSpielKlient )
+{
+	int ressourceAnz = 0;
+	zDatei->lese( (char*)&ressourceAnz, 4 );
+	for( int i = 0; i < ressourceAnz; i++ )
+	{
+		ressources->add( new RessourceStr( zDatei, infoK, mapId ) );
+		zSpielKlient->setLadenProzent( 5 + (int)( 65 * ( (double)( i + 1 ) / ressourceAnz ) + 0.5 ) );
+	}
+	zDatei->lese( (char*)&größe.x, 4 );
+	zDatei->lese( (char*)&größe.y, 4 );
+	int objektAnzahl = 0;
+	zDatei->lese( (char*)&objektAnzahl, 4 );
+	for( int i = 0; i < objektAnzahl; i++ )
+	{
+		objekte->add( new ZeichnungStr( zDatei ) );
+		zSpielKlient->setLadenProzent( 70 + (int)( 10 * ( (double)( i + 1 ) / objektAnzahl ) + 0.5 ) );
+	}
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		spieler->add( new SpielerStr( zDatei ) );
+		zSpielKlient->setLadenProzent( 80 + (int)( 5 * ( (double)( i + 1 ) / spielerAnzahl ) + 0.5 ) );
+	}
+	for( int i = 0; i < teamAnzahl; i++ )
+	{
+		teams->add( new TeamStr( zDatei ) );
+		zSpielKlient->setLadenProzent( 85 + (int)( 5 * ( (double)( i + 1 ) / teamAnzahl ) + 0.5 ) );
+	}
+}
+
+// constant
+Vec2< int > Karte::getSize() const
+{
+	return größe;
+}
+
+Spieler *Karte::createSpieler( int sNum, Schrift *zSchrift, InformationKlientV *zInfoK ) const
+{
+	if( sNum < 0 || sNum >= spielerAnzahl )
+		return 0;
+	Spieler *ret = new Spieler( zInfoK, zSchrift, spieler->z( sNum ) );
+	int m2d = spieler->z( sNum )->m2d;
+	int bild = spieler->z( sNum )->bild;
+	for( auto i = &ressources->getArray(); i && i->set && i->var; i = i->next )
+	{
+		if( i->var->getId() == m2d )
+			ret->setModelData( i->var->zReccourceM2()->getThis() );
+		if( i->var->getId() == bild )
+			ret->setSpielerFarbe( spielerFarbe->hat( sNum ) ? spielerFarbe->get( sNum ) : 0, i->var->zReccourceTxt() );
+	}
+	return ret;
+}
+
+Team *Karte::createTeam( int tNum ) const
+{
+	if( tNum < 0 || tNum >= teamAnzahl )
+		return 0;
+	Team *ret = new Team( teamFarbe->get( tNum ), teamName->z( tNum )->getText(), teams->z( tNum ) );
+	return ret;
+}
+
+SpielObjekt *Karte::createZeichnung( int oNum, Schrift *zSchrift ) const
+{
+	if( oNum < 0 || oNum > objekte->getEintragAnzahl() )
+		return 0;
+	SpielObjekt *ret = new SpielObjekt( objekte->z( oNum ), zSchrift );
+	int m2d = objekte->z( oNum )->m2d;
+	int bild = objekte->z( oNum )->bild;
+	for( auto i = &ressources->getArray(); i && i->set && i->var; i = i->next )
+	{
+		if( i->var->getId() == m2d )
+			ret->setModelData( i->var->zReccourceM2()->getThis() );
+		if( i->var->getId() == bild )
+			ret->setTextur( i->var->zReccourceTxt()->getThis() );
+	}
+	return ret;
+}
+
+int Karte::getMaxTeamAnzahl() const
+{
+	return teamAnzahl;
+}
+
+int Karte::getMaxSpielerAnzahl() const
+{
+	return spielerAnzahl;
+}
+
+int Karte::getZeichnungAnzahl() const
+{
+	return objekte->getEintragAnzahl();
+}
+
+int Karte::getTeamNummer( int sNum ) const
+{
+	int min = teamGröße->get( 0 );
+	for( int i = 1; i <= teamAnzahl; i++ )
+	{
+		if( sNum < min )
+			return i - 1;
+		min += teamGröße->hat( i ) ? teamGröße->get( i ) : 0;
+	}
+	return -1;
+}
+
+// Reference Counting
+Karte *Karte::getThis()
+{
+	ref++;
+	return this;
+}
+
+Karte *Karte::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Spiel/Karte/Karte.h

@@ -0,0 +1,52 @@
+#ifndef Karte_H
+#define Karte_H
+
+#include <Datei.h>
+#include <Vec2.h>
+#include "../Team/Team.h"
+#include "../Spieler/Spieler.h"
+#include "../Objekt/SpielObjekt.h"
+#include "../../../../../../Klient/Include/KSGKlientV.h"
+#include "Strukturen.h"
+
+using namespace Framework;
+
+class Karte
+{
+private:
+	Vec2< int > größe;
+	int spielerAnzahl;
+	int teamAnzahl;
+	Array< int > *spielerFarbe;
+	Array< int > *teamFarbe;
+	RCArray< Text > *teamName;
+	Array< int > *teamGröße;
+	RCArray< RessourceStr > *ressources;
+	RCArray< ZeichnungStr > *objekte;
+	RCArray< SpielerStr > *spieler;
+	RCArray< TeamStr > *teams;
+	int ref;
+
+public:
+	// Konstruktor
+	Karte();
+	// Destruktor
+	~Karte();
+	// nicht constant
+	void ladeSts( Datei *zDatei ); // call 1
+	void ladeMap( Datei *zDatei, InformationKlientV *infoK, int mapId, SpielKlientV *zSpielKlient ); // call 2
+	// constant
+	Vec2< int > getSize() const;
+	Spieler *createSpieler( int sNum, Schrift *zSchrift, InformationKlientV *zInfoK ) const;
+	Team *createTeam( int tNum ) const;
+	SpielObjekt *createZeichnung( int oNum, Schrift *zSchrift ) const;
+	int getMaxTeamAnzahl() const;
+	int getMaxSpielerAnzahl() const;
+	int getZeichnungAnzahl() const;
+	int getTeamNummer( int sNum ) const;
+	// Reference Counting
+	Karte *getThis();
+	Karte *release();
+};
+
+#endif

Asteroids/Spiel/Karte/Strukturen.cpp

@@ -0,0 +1,201 @@
+#include "Strukturen.h"
+#include <M2Datei.h>
+#include <DateiSystem.h>
+
+// Inhalt der RessourceStr Klasse aus Strukturen.h
+// Konstruktor
+RessourceStr::RessourceStr( Datei *zDatei, InformationKlientV *zInfoK, int karteId )
+{
+	zDatei->lese( (char*)&id, 4 );
+	char län = 0;
+	zDatei->lese( &län, 1 );
+	Text txt;
+	txt.fillText( '0', län + 1 );
+	zDatei->lese( txt, län );
+	txt.getText()[ län ] = 0;
+	pfad = 0;
+	if( txt.positionVon( "spiel:" ) == 0 )
+	{
+		pfad = zInfoK->getDateiGruppePfad( zInfoK->getDateiGruppeIdVonSpiel( zInfoK->getSpielId( karteId ) ) );
+		if( pfad )
+			pfad->append( txt.getTeilText( 6 ) );
+	}
+	if( txt.positionVon( "map:" ) == 0 )
+    {
+        pfad = new Text( "data/tmp/Karten/" );
+        pfad->append( karteId );
+        pfad->append( "/" );
+		pfad->append( txt.getTeilText( 4 ) );
+	}
+	m2d = 0;
+	bild = 0;
+	if( pfad && pfad->hat( ".m2/" ) )
+	{
+		int pos = pfad->positionVon( ".m2/", pfad->anzahlVon( ".m2/" ) - 1 );
+		M2Datei *datei = new M2Datei( pfad->getTeilText( 0, pos + 3 ) );
+		datei->leseDaten();
+		m2d = datei->ladeModel( pfad->getTeilText( pos + 4 ) );
+		datei->release();
+	}
+	if( pfad->hat( ".ltdb/" ) )
+	{
+		int pos = pfad->positionVon( ".ltdb/", pfad->anzahlVon( ".ltdb/" ) - 1 );
+		LTDBDatei *datei = new LTDBDatei();
+		datei->setDatei( pfad->getTeilText( 0, pos + 5 ) );
+		datei->leseDaten( 0 );
+		bild = datei->laden( 0, pfad->getTeilText( pos + 6 ) );
+		datei->release();
+	}
+	ref = 1;
+}
+
+// Destruktor
+RessourceStr::~RessourceStr()
+{
+	if( pfad )
+		pfad->release();
+	if( m2d )
+		m2d->release();
+	if( bild )
+		bild->release();
+}
+
+// constant
+int RessourceStr::getId() const
+{
+	return id;
+}
+
+Model2DData *RessourceStr::zReccourceM2() const
+{
+	return m2d;
+}
+
+Bild *RessourceStr::zReccourceTxt() const
+{
+	return bild;
+}
+
+// Reference Counting
+RessourceStr *RessourceStr::getThis()
+{
+	ref++;
+	return this;
+}
+
+RessourceStr *RessourceStr::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}
+
+
+// Inhalt der ZeichnungStr Klasse aus Strukturen.h
+// Konstruktor
+ZeichnungStr::ZeichnungStr( Datei *zDatei )
+{
+	zDatei->lese( (char*)&pos.x, 4 );
+	zDatei->lese( (char*)&pos.y, 4 );
+	zDatei->lese( (char*)&id, 4 );
+	zDatei->lese( (char*)&m2d, 4 );
+	zDatei->lese( (char*)&bild, 4 );
+	zDatei->lese( (char*)&style, 4 );
+	zDatei->lese( (char*)&maxStabilität, 4 );
+	zDatei->lese( (char*)&maxEnergie, 4 );
+	zDatei->lese( (char*)&energieRadius, 4 );
+	zDatei->lese( (char*)&reparatur, 8 );
+	zDatei->lese( (char*)&akkuLeistung, 8 );
+	zDatei->lese( &team, 1 );
+	ref = 1;
+}
+
+// Reference Counting
+ZeichnungStr *ZeichnungStr::getThis()
+{
+	ref++;
+	return this;
+}
+
+ZeichnungStr *ZeichnungStr::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}
+
+
+// Inhalt der SpielerStr Klasse aus Strukturen.h
+// Konstruktor
+SpielerStr::SpielerStr( Datei *zDatei )
+{
+	zDatei->lese( (char*)&id, 4 );
+	zDatei->lese( (char*)&pos.x, 4 );
+	zDatei->lese( (char*)&pos.y, 4 );
+	zDatei->lese( (char*)&rot, 8 );
+	zDatei->lese( (char*)&beschleunigung, 8 );
+	zDatei->lese( (char*)&maxStabilität, 4 );
+	zDatei->lese( (char*)&maxEnergie, 4 );
+	zDatei->lese( (char*)&reparatur, 8 );
+	zDatei->lese( (char*)&akkuLeistung, 8 );
+	zDatei->lese( (char*)&laserIntensität, 4 );
+	zDatei->lese( (char*)&laserEffizienz, 4 );
+	zDatei->lese( (char*)&laserTempo, 4 );
+	zDatei->lese( (char*)&wendigkeit, 8 );
+	zDatei->lese( (char*)&netzwerk, 4 );
+	zDatei->lese( (char*)&skillPunkte, 4 );
+	zDatei->lese( (char*)&m2d, 4 );
+	zDatei->lese( (char*)&bild, 4 );
+	ref = 1;
+}
+
+// Reference Counting
+SpielerStr *SpielerStr::getThis()
+{
+	ref++;
+	return this;
+}
+
+SpielerStr *SpielerStr::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}
+
+// Inhalt der TeamStr Klasse aus Strukturen.h
+// Konstruktor
+TeamStr::TeamStr( Datei *zDatei )
+{
+	zDatei->lese( (char*)&id, 4 );
+	zDatei->lese( (char*)&maxPunkte, 4 );
+	zDatei->lese( (char*)&beschleunigung, 8 );
+	zDatei->lese( (char*)&maxStabilität, 4 );
+	zDatei->lese( (char*)&maxEnergie, 4 );
+	zDatei->lese( (char*)&reparatur, 8 );
+	zDatei->lese( (char*)&akkuLeistung, 8 );
+	zDatei->lese( (char*)&laserIntensität, 4 );
+	zDatei->lese( (char*)&laserEffizienz, 4 );
+	zDatei->lese( (char*)&laserTempo, 4 );
+	zDatei->lese( (char*)&wendigkeit, 8 );
+	zDatei->lese( (char*)&punkte, 4 );
+	ref = 1;
+}
+
+// Reference Counting
+TeamStr *TeamStr::getThis()
+{
+	ref++;
+	return this;
+}
+
+TeamStr *TeamStr::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Spiel/Karte/Strukturen.h

@@ -0,0 +1,115 @@
+#ifndef Strukturen_H
+#define Strukturen_H
+
+#include "../../../../../../Klient/Include/KSGKlientV.h"
+#include <Model2D.h>
+#include <Bild.h>
+#include <Datei.h>
+
+using namespace Framework;
+
+class RessourceStr
+{
+private:
+	int id;
+	int ref;
+	Model2DData *m2d;
+	Bild *bild;
+	Text *pfad;
+
+public:
+	// Konstruktor
+	RessourceStr( Datei *zDatei, InformationKlientV *zInfoK, int karteId );
+	// Destruktor
+	~RessourceStr();
+	// constant
+	int getId() const;
+	Model2DData *zReccourceM2() const;
+	Bild *zReccourceTxt() const;
+	// Reference Counting
+	RessourceStr *getThis();
+	RessourceStr *release();
+};
+
+class ZeichnungStr
+{
+private:
+	int ref;
+
+public:
+	Punkt pos;
+	int id;
+	int m2d;
+	int bild;
+	int style;
+	int maxStabilität;
+	int maxEnergie;
+	int energieRadius;
+	double reparatur;
+	double akkuLeistung;
+	char team;
+
+	// Konstruktor
+	ZeichnungStr( Datei *zDatei );
+	// Reference Counting
+	ZeichnungStr *getThis();
+	ZeichnungStr *release();
+};
+
+class SpielerStr
+{
+private:
+	int ref;
+
+public:
+	int id;
+	Punkt pos;
+	double rot;
+	double beschleunigung;
+	int maxStabilität;
+	int maxEnergie;
+	double reparatur;
+	double akkuLeistung;
+	int laserIntensität;
+	int laserEffizienz;
+	int laserTempo;
+	double wendigkeit;
+	int netzwerk;
+	int skillPunkte;
+	int m2d;
+	int bild;
+
+	// Konstruktor
+	SpielerStr( Datei *zDatei );
+	// Reference Counting
+	SpielerStr *getThis();
+	SpielerStr *release();
+};
+
+class TeamStr
+{
+private:
+	int ref;
+
+public:
+	int id;
+	int maxPunkte;
+	double beschleunigung;
+	int maxStabilität;
+	int maxEnergie;
+	double reparatur;
+	double akkuLeistung;
+	int laserIntensität;
+	int laserEffizienz;
+	int laserTempo;
+	double wendigkeit;
+	int punkte;
+
+	// Konstruktor
+	TeamStr( Datei *zDatei );
+	// Reference Counting
+	TeamStr *getThis();
+	TeamStr *release();
+};
+
+#endif

Asteroids/Spiel/Objekt/SpielObjekt.cpp

@@ -0,0 +1,128 @@
+#include "SpielObjekt.h"
+#include "../Define.h"
+#include "../../Initialisierung/Initialisierung.h"
+
+// Inhalt der SpielObjekt Klasse aus SpielObjekt.h
+// Konstruktor
+SpielObjekt::SpielObjekt( ZeichnungStr *zStr, Schrift *zSchrift )
+{
+	pos = zStr->pos;
+	id = zStr->id;
+	mdl = new Model2D();
+	mdl->setStyle( Model2D::Style::Sichtbar | Model2D::Style::Textur );
+	style = zStr->style;
+	stabilität = zStr->maxStabilität;
+	energie = zStr->maxEnergie;
+	maxStabilität = zStr->maxStabilität;
+	maxEnergie = zStr->maxEnergie;
+	energieRadius = zStr->energieRadius;
+	reparatur = zStr->reparatur;
+	akkuLeistung = zStr->akkuLeistung;
+	team = 0;
+	nText = initTextFeld( 0, 0, 152, 30, zSchrift, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
+						  TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha, "" );
+	ref = 1;
+}
+
+// Destruktor
+SpielObjekt::~SpielObjekt()
+{
+	mdl->release();
+	if( team )
+		team->release();
+	nText->release();
+}
+
+// nicht constant
+void SpielObjekt::setModelData( Model2DData *data )
+{
+	mdl->setModel( data );
+}
+
+void SpielObjekt::setTextur( Bild *textur )
+{
+	mdl->setTextur( textur );
+}
+
+void SpielObjekt::setTeam( Team *team )
+{
+	if( this->team )
+		this->team->release();
+	this->team = team;
+}
+
+void SpielObjekt::tick()
+{
+	repAbk -= TICK;
+	if( repAbk < 0 )
+		repAbk = 0;
+	akkuAbk -= TICK;
+	if( akkuAbk < 0 )
+		akkuAbk = 0;
+	if( !repAbk )
+	{
+		stabilität += reparatur * TICK;
+		if( stabilität > maxStabilität )
+			stabilität = maxStabilität;
+	}
+	if( !akkuAbk )
+	{
+		if( !team )
+		{
+			energie -= akkuLeistung * TICK;
+			if( energie < 0 )
+				energie = 0;
+		}
+		else
+		{
+			energie += akkuLeistung * TICK;
+			if( energie > maxEnergie )
+				energie = maxEnergie;
+		}
+	}
+}
+
+void SpielObjekt::render( Bild &zRObj )
+{
+	mdl->render( zRObj );
+}
+
+void SpielObjekt::renderLeben( Bild &zRObj )
+{
+	nText->setPosition( mdl->getPosition() - Punkt( 76, (int)( mdl->zModel()->maxP.y * mdl->getSize() ) + 30 ) );
+	nText->render( zRObj );
+	int teamF = team ? team->farbe : 0;
+	double teamStab = team ? team->maxStabilität : 0;
+	double teamEner = team ? team->maxEnergie : 0;
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 4, 150, teamF );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 25, 150, teamF );
+	int l = (int)( stabilität * 100 / ( maxStabilität + teamStab ) * 1.5 + 0.5 );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 1, l, 0xFF00FF00 );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 2, l, 0xFF00FF00 );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 3, l, 0xFF00FF00 );
+	int e = (int)( energie * 100 / ( maxEnergie + teamEner ) * 1.5 + 0.5 );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 26, e, 0xFFFFFF00 );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 27, e, 0xFFFFFF00 );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 28, e, 0xFFFFFF00 );
+}
+
+// constant
+Team *SpielObjekt::zTeam() const
+{
+	return team;
+}
+
+// Reference Counting
+SpielObjekt *SpielObjekt::getThis()
+{
+	ref++;
+	return this;
+}
+
+SpielObjekt *SpielObjekt::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Spiel/Objekt/SpielObjekt.h

@@ -0,0 +1,51 @@
+#ifndef SpielObjekt_H
+#define SpielObjekt_H
+
+#include <Vec2.h>
+#include <Model2D.h>
+#include "../Team/Team.h"
+#include "../Karte/Strukturen.h"
+#include <TextFeld.h>
+
+using namespace Framework;
+
+class SpielObjekt
+{
+private:
+	Vec2< double > pos;
+	int id;
+	Model2D *mdl;
+	int style;
+	double stabilität;
+	double energie;
+	int maxStabilität;
+	int maxEnergie;
+	int energieRadius;
+	double reparatur;
+	double akkuLeistung;
+	double repAbk;
+	double akkuAbk;
+	Team *team;
+	TextFeld *nText;
+	int ref;
+
+public:
+	// Konstruktor
+	SpielObjekt( ZeichnungStr *zStr, Schrift *zSchrift );
+	// Destruktor
+	~SpielObjekt();
+	// nicht constant
+	void setModelData( Model2DData *data );
+	void setTextur( Bild *textur );
+	void setTeam( Team *team );
+	void tick();
+	void render( Bild &zRObj );
+	void renderLeben( Bild &zRObj );
+	// constant
+	Team *zTeam() const;
+	// Reference Counting
+	SpielObjekt *getThis();
+	SpielObjekt *release();
+};
+
+#endif

Asteroids/Spiel/Schuss/Laser.cpp

@@ -0,0 +1,185 @@
+#include "Laser.h"
+#include "../Karte/Karte.h"
+#include "../Spieler/Spieler.h"
+#include "../Define.h"
+
+// Inhalt der Laser Klasse aus Laser.h
+// Konstruktor
+Laser::Laser( int id, Vec2< double > pos, Vec2< double > speed, int sNum, double intensität, int tf )
+{
+	this->id = id;
+	this->pos = pos;
+	this->speed = speed;
+	this->sNum = sNum;
+	this->intensität = intensität;
+	this->startIntensität = intensität;
+	this->tf = tf;
+	ref = 1;
+}
+
+// privat
+char Laser::getOutCode( Punkt& p, Bild &zrObj ) const
+{
+	char ret = 0;
+	if( p.x < 0 )
+		ret |= 1;
+	else if( p.x >= zrObj.getBreite() )
+		ret |= 2;
+	if( p.y < 0 )
+		ret |= 4;
+	else if( p.y >= zrObj.getHeight() )
+		ret |= 8;
+	return ret;
+}
+
+// nicht constant
+void Laser::tick( int tick, Karte *zMap )
+{
+	double tickVal = tick * TICK;
+	pos += speed * tickVal;
+	Vec2< int > gr = zMap->getSize();
+	if( pos.x < 0 )
+		pos.x += gr.x;
+	if( pos.y < 0 )
+		pos.y += gr.y;
+	if( pos.x >= gr.x )
+		pos.x -= gr.x;
+	if( pos.y >= gr.y )
+		pos.y -= gr.y;
+	intensität -= tickVal * 2;
+}
+
+void Laser::render( Bild &zRObj )
+{
+	int fa = (int)( ( intensität / startIntensität ) * 255 );
+	int f = ( ( fa << 24 ) & 0xFF000000 ) | ( tf & 0xFFFFFF );
+	Punkt a( pos );
+	Punkt b( pos - ( speed / speed.getLength() * 10 ) );
+	a += zRObj.getDrawOff();
+	b += zRObj.getDrawOff();
+	char outCode1 = getOutCode( a, zRObj );
+	char outCode2 = getOutCode( b, zRObj );
+	bool ok = 0;
+	while( 1 )
+	{
+		int xMax = zRObj.getDrawGr().x - 1;
+		int yMax = zRObj.getDrawGr().y - 1;
+		if( !( outCode1 | outCode2 ) )
+		{
+			ok = 1;
+			break;
+		}
+		else if( outCode1 & outCode2 )
+			break;
+		else
+		{
+			int x, y;
+			char outCodeOut = outCode1 ? outCode1 : outCode2;
+			if( outCodeOut & 8 )
+			{
+				x = (int)( a.x + ( b.x - a.x ) * ( yMax - a.y ) / ( b.y - a.y ) + 0.5 );
+				y = yMax;
+			}
+			else if( outCodeOut & 4 )
+			{
+				x = (int)( a.x + ( b.x - a.x ) * ( zRObj.getDrawPos().y - a.y ) / ( b.y - a.y ) + 0.5 );
+				y = zRObj.getDrawPos().y;
+			}
+			else if( outCodeOut & 2 )
+			{
+				y = (int)( a.y + ( b.y - a.y ) * ( xMax - a.x ) / ( b.x - a.x ) + 0.5 );
+				x = xMax;
+			}
+			else if( outCodeOut & 1 )
+			{
+				y = (int)( a.y + ( b.y - a.y ) * ( zRObj.getDrawPos().x - a.x ) / ( b.x - a.x ) + 0.5 );
+				x = zRObj.getDrawPos().x;
+			}
+			if( outCodeOut == outCode1 )
+			{
+				a.x = x;
+				a.y = y;
+				outCode1 = getOutCode( a, zRObj );
+			}
+			else
+			{
+				b.x = x;
+				b.y = y;
+				outCode2 = getOutCode( b, zRObj );
+			}
+		}
+	}
+	if( ok )
+	{
+		int xlän = b.x - a.x, axlän = abs( xlän );
+		int ylän = b.y - a.y, aylän = abs( ylän );
+		double xf = (double)xlän / ( aylän ? aylän : 1 );
+		double yf = (double)ylän / ( axlän ? axlän : 1 );
+		if( axlän > aylän )
+			xf = xf < 0 ? -1 : 1;
+		else
+			yf = yf < 0 ? -1 : 1;
+		double x = (double)a.x, y = (double)a.y;
+		int maxP = (int)( sqrt( xlän * xlän + ylän * ylän ) + 0.5 );
+		int count = 0;
+		int *buffer = zRObj.getBuffer();
+		int maxPixel = zRObj.getBreite() * zRObj.getHeight();
+		while( !( (int)( x + 0.5 ) == b.x && (int)( y + 0.5 ) == b.y ) && count < maxP )
+		{
+			++count;
+			if( (int)( (int)( x + 0.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) < maxPixel )
+			    buffer[ (int)( (int)( x + 0.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) ] = 0xFFFFFFFF;
+			if( (int)( (int)( x - 0.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) < maxPixel && 
+				buffer[ (int)( (int)( x - 0.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) ] != 0xFFFFFFFF )
+				zRObj.alphaPixel( (int)( x - 0.5 ), (int)( y + 0.5 ), f );
+			if( (int)( (int)( x + 1.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) < maxPixel && 
+				buffer[ (int)( (int)( x + 1.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) ] != 0xFFFFFFFF )
+				zRObj.alphaPixel( (int)( x + 1.5 ), (int)( y + 0.5 ), f );
+			if( (int)( (int)( x + 0.5 ) + (int)( y - 0.5 ) * zRObj.getBreite() ) < maxPixel && 
+				buffer[ (int)( (int)( x + 0.5 ) + (int)( y - 0.5 ) * zRObj.getBreite() ) ] != 0xFFFFFFFF )
+				zRObj.alphaPixel( (int)( x + 0.5 ), (int)( y - 0.5 ), f );
+			if( (int)( (int)( x + 0.5 ) + (int)( y + 1.5 ) * zRObj.getBreite() ) < maxPixel && 
+				buffer[ (int)( (int)( x + 0.5 ) + (int)( y + 1.5 ) * zRObj.getBreite() ) ] != 0xFFFFFFFF )
+				zRObj.alphaPixel( (int)( x + 0.5 ), (int)( y + 1.5 ), f );
+			x += xf, y += yf;
+		}
+	}
+}
+
+void Laser::renderMinimap( Bild &zRObj, Karte *zMap )
+{
+	int x = (int)( ( pos.x / zMap->getSize().x ) * 250 + 0.5 );
+	int y = (int)( ( pos.y / zMap->getSize().y ) * 250 + 0.5 );
+	zRObj.setPixelDP( x + zRObj.getDrawOff().x, y + zRObj.getDrawOff().y, tf );
+}
+
+// constant
+int Laser::getId() const
+{
+	return id;
+}
+
+int Laser::getSpieler() const
+{
+	return sNum;
+}
+
+double Laser::getIntensität() const
+{
+	return intensität;
+}
+
+// Reference Counting
+Laser *Laser::getThis()
+{
+	ref++;
+	return this;
+}
+
+Laser *Laser::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Spiel/Schuss/Laser.h

@@ -0,0 +1,41 @@
+#ifndef Laser_H
+#define Laser_H
+
+#include <Vec2.h>
+#include <Bild.h>
+
+using namespace Framework;
+
+class Karte;
+
+class Laser
+{
+private:
+	int ref;
+	int id;
+	Vec2< double > pos;
+	Vec2< double > speed;
+	double intensität;
+	double startIntensität;
+	int tf;
+	int sNum;
+	// privat
+	char getOutCode( Punkt& p, Bild &zrObj ) const;
+
+public:
+	// Konstruktor
+	Laser( int id, Vec2< double > pos, Vec2< double > speed, int sNum, double intensität, int tf );
+	// nicht constant
+	void tick( int tick, Karte *zMap );
+	void render( Bild &zRObj );
+	void renderMinimap( Bild &zRObj, Karte *zMap );
+	// constant
+	int getId() const;
+	int getSpieler() const;
+	double getIntensität() const;
+	// Reference Counting
+	Laser *getThis();
+	Laser *release();
+};
+
+#endif

Asteroids/Spiel/Ship/Ship.cpp

@@ -0,0 +1,316 @@
+#include "Ship.h"
+#include "../../Initialisierung/Initialisierung.h"
+#include <MausEreignis.h>
+#include <Rahmen.h>
+#include <Fortschritt.h>
+
+using namespace Framework;
+
+int getStellen( double d )
+{
+	int ret = 0;
+	for( int i = 1; d >= i; i *= 10 )
+		ret++;
+	return ret;
+}
+
+// Inhalt der Ship Klasse aus Ship.h
+// Konstruktor
+Ship::Ship( Schrift *zSchrift )
+{
+	ram = new LRahmen();
+	ram->setSize( 200, 282 );
+	ram->setPosition( Punkt( BildschirmGröße().x - 210, 10 ) );
+	ram->setFarbe( 0xFFFFFFFF );
+	spieler = initTextFeld( 5, 5, 190, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "" );
+	stabilität = initTextFeld( 5, 30, 165, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "" );
+	energie = initTextFeld( 5, 55, 165, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "" );
+	stabilitätB = new FBalken();
+	stabilitätB->setPosition( 5, 30 );
+	stabilitätB->setSize( 165, 20 );
+	stabilitätB->setHintergrundFarbe( 0xFF000000 );
+	stabilitätB->setFBgFarbe( 0xFF55FF55 );
+	stabilitätB->setLinienRahmenFarbe( 0xFF00FF00 );
+	stabilitätB->setLinienRahmenBreite( 1 );
+	stabilitätB->setFRFarbe( 0xFF00FF00 );
+	stabilitätB->setFRBreite( 1 );
+	stabilitätB->setStyle( FBalken::Style::Sichtbar | FBalken::Style::L_R | FBalken::Style::Hintergrund | FBalken::Style::FFarbe | FBalken::Style::Rahmen | FBalken::Style::FRahmen );
+	energieB = new FBalken();
+	energieB->setPosition( 5, 55 );
+	energieB->setSize( 165, 20 );
+	energieB->setHintergrundFarbe( 0xFF000000 );
+	energieB->setFBgFarbe( 0xFF5555FF );
+	energieB->setLinienRahmenFarbe( 0xFF0000FF );
+	energieB->setLinienRahmenBreite( 1 );
+	energieB->setFRFarbe( 0xFF0000FF );
+	energieB->setFRBreite( 1 );
+	energieB->setStyle( FBalken::Style::Sichtbar | FBalken::Style::L_R | FBalken::Style::Hintergrund | FBalken::Style::FFarbe | FBalken::Style::Rahmen | FBalken::Style::FRahmen );
+	reparatur = initTextFeld( 5, 80, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::Mehrfarbig | TextFeld::Style::VCenter, "" );
+	akkuLeistung = initTextFeld( 5, 105, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::Mehrfarbig | TextFeld::Style::VCenter, "" );
+	wendigkeit = initTextFeld( 5, 130, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::Mehrfarbig | TextFeld::Style::VCenter, "" );
+	beschleunigung = initTextFeld( 5, 155, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::Mehrfarbig | TextFeld::Style::VCenter, "" );
+	laserIntensität = initTextFeld( 5, 180, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::Mehrfarbig | TextFeld::Style::VCenter, "" );
+	laserEffizienz = initTextFeld( 5, 205, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::Mehrfarbig | TextFeld::Style::VCenter, "" );
+	laserTempo = initTextFeld( 5, 230, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::Mehrfarbig | TextFeld::Style::VCenter, "" );
+	netzwerk = initTextFeld( 5, 255, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::Mehrfarbig | TextFeld::Style::VCenter, "" );
+	stabilitätSkill = initKnopf( 172, 30, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
+	energieSkill = initKnopf( 172, 55, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
+	reparaturSkill = initKnopf( 172, 80, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
+	akkuLeistungSkill = initKnopf( 172, 105, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
+	wendigkeitSkill = initKnopf( 172, 130, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
+	beschleunigungSkill = initKnopf( 172, 155, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
+	laserIntensitätSkill = initKnopf( 172, 180, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
+	laserEffizienzSkill = initKnopf( 172, 205, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
+	laserTempoSkill = initKnopf( 172, 230, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
+	netzwerkSkill = initKnopf( 172, 255, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
+	stabilitätSkill->removeStyle( Knopf::Style::Erlaubt );
+	energieSkill->removeStyle( Knopf::Style::Erlaubt );
+	reparaturSkill->removeStyle( Knopf::Style::Erlaubt );
+	akkuLeistungSkill->removeStyle( Knopf::Style::Erlaubt );
+	wendigkeitSkill->removeStyle( Knopf::Style::Erlaubt );
+	beschleunigungSkill->removeStyle( Knopf::Style::Erlaubt );
+	laserIntensitätSkill->removeStyle( Knopf::Style::Erlaubt );
+	laserEffizienzSkill->removeStyle( Knopf::Style::Erlaubt );
+	laserTempoSkill->removeStyle( Knopf::Style::Erlaubt );
+	netzwerkSkill->removeStyle( Knopf::Style::Erlaubt );
+	ref = 1;
+}
+
+// Destruktor
+Ship::~Ship()
+{
+	ram->release();
+	spieler->release();
+	stabilität->release();
+	energie->release();
+	stabilitätB->release();
+	energieB->release();
+	reparatur->release();
+	akkuLeistung->release();
+	wendigkeit->release();
+	beschleunigung->release();
+	laserIntensität->release();
+	laserEffizienz->release();
+	laserTempo->release();
+	netzwerk->release();
+	stabilitätSkill->release();
+	energieSkill->release();
+	reparaturSkill->release();
+	akkuLeistungSkill->release();
+	wendigkeitSkill->release();
+	beschleunigungSkill->release();
+	laserIntensitätSkill->release();
+	laserEffizienzSkill->release();
+	laserTempoSkill->release();
+	netzwerkSkill->release();
+}
+
+// nicht constant
+void Ship::update( Spieler *zSpieler )
+{
+	spieler->setText( zSpieler->name->getText() );
+	spieler->setSchriftFarbe( zSpieler->farbe );
+	Text txt;
+	txt.setPrecision( getStellen( zSpieler->stabilität ) + 2 );
+	txt = zSpieler->stabilität;
+	txt += "/";
+	txt.setPrecision( getStellen( zSpieler->maxStabilität ) + 2 );
+	txt += zSpieler->maxStabilität;
+	txt += "\r0xFF00FF00(+";
+	txt.setPrecision( getStellen( zSpieler->team->maxStabilität ) + 2 );
+	txt += zSpieler->team->maxStabilität;
+	txt += ")";
+	stabilität->setText( txt );
+	stabilitätB->reset();
+	stabilitätB->setAktionAnzahl( (int)( zSpieler->maxStabilität + zSpieler->team->maxStabilität ) );
+	stabilitätB->aktionPlus( (int)( zSpieler->stabilität ) );
+	txt.setPrecision( getStellen( zSpieler->energie ) + 2 );
+	txt = zSpieler->energie;
+	txt += "/";
+	txt.setPrecision( getStellen( zSpieler->maxEnergie ) + 2 );
+	txt += zSpieler->maxEnergie;
+	txt += "\r0xFF00FF00(+";
+	txt.setPrecision( getStellen( zSpieler->team->maxEnergie ) + 2 );
+	txt += zSpieler->team->maxEnergie;
+	txt += ")";
+	energie->setText( txt );
+	energieB->reset();
+	energieB->setAktionAnzahl( (int)( zSpieler->maxEnergie + zSpieler->team->maxEnergie ) );
+	energieB->aktionPlus( (int)( zSpieler->energie ) );
+	txt = "Reparatur:";
+	txt.setPrecision( getStellen( zSpieler->reparatur ) + 2 );
+	txt += zSpieler->reparatur;
+	txt += "\r0xFF00FF00(+";
+	txt.setPrecision( getStellen( zSpieler->team->reparatur ) + 2 );
+	txt += zSpieler->team->reparatur;
+	txt += ")";
+	reparatur->setText( txt );
+	txt = "Akku:";
+	txt.setPrecision( getStellen( zSpieler->akkuLeistung ) + 2 );
+	txt += zSpieler->akkuLeistung;
+	txt += "\r0xFF00FF00(+";
+	txt.setPrecision( getStellen( zSpieler->team->akkuLeistung ) + 2 );
+	txt += zSpieler->team->akkuLeistung;
+	txt += ")";
+	akkuLeistung->setText( txt );
+	txt = "Wendigkeit:";
+	txt.setPrecision( getStellen( zSpieler->wendigkeit ) + 2 );
+	txt += zSpieler->wendigkeit;
+	txt += "\r0xFF00FF00(+";
+	txt.setPrecision( getStellen( zSpieler->team->wendigkeit ) + 2 );
+	txt += zSpieler->team->wendigkeit;
+	txt += ")";
+	wendigkeit->setText( txt );
+	txt = "Beschleunigung:";
+	txt.setPrecision( getStellen( zSpieler->beschleunigung ) + 2 );
+	txt += zSpieler->beschleunigung;
+	txt += "\r0xFF00FF00(+";
+	txt.setPrecision( getStellen( zSpieler->team->beschleunigung ) + 2 );
+	txt += zSpieler->team->beschleunigung;
+	txt += ")";
+	beschleunigung->setText( txt );
+	txt = "Laser intensität:";
+	txt.setPrecision( getStellen( zSpieler->laserIntensität ) + 2 );
+	txt += zSpieler->laserIntensität;
+	txt += "\r0xFF00FF00(+";
+	txt.setPrecision( getStellen( zSpieler->team->laserIntensität ) + 2 );
+	txt += zSpieler->team->laserIntensität;
+	txt += ")";
+	laserIntensität->setText( txt );
+	txt = "Laser effizienz:";
+	txt.setPrecision( getStellen( zSpieler->laserEffizienz ) + 2 );
+	txt += zSpieler->laserEffizienz;
+	txt += "\r0xFF00FF00(+";
+	txt.setPrecision( getStellen( zSpieler->team->laserEffizienz ) + 2 );
+	txt += zSpieler->team->laserEffizienz;
+	txt += ")";
+	laserEffizienz->setText( txt );
+	txt = "Laser tempo:";
+	txt.setPrecision( getStellen( zSpieler->laserTempo ) + 2 );
+	txt += zSpieler->laserTempo;
+	txt += "\r0xFF00FF00(+";
+	txt.setPrecision( getStellen( zSpieler->team->laserTempo ) + 2 );
+	txt += zSpieler->team->laserTempo;
+	txt += ")";
+	laserTempo->setText( txt );
+	txt = "Netzwerk:";
+	txt.setPrecision( getStellen( zSpieler->netzwerk ) + 2 );
+	txt += zSpieler->netzwerk;
+	netzwerk->setText( txt );
+	stabilitätSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );
+	energieSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );
+	reparaturSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );
+	akkuLeistungSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );
+	wendigkeitSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );
+	beschleunigungSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );
+	laserIntensitätSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );
+	laserEffizienzSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );
+	laserTempoSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );
+	netzwerkSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );
+}
+
+int Ship::doMausEreignis( MausEreignis &me )
+{
+	me.mx -= ram->getX();
+	me.my -= ram->getY();
+	if( me.mx < 0 || me.my < 0 )
+		return -1;
+	int aktion = me.verarbeitet;
+	stabilitätSkill->doMausEreignis( me );
+	if( !aktion && me.verarbeitet && me.id == ME_RLinks )
+		aktion = 2;
+	energieSkill->doMausEreignis( me );
+	if( !aktion && me.verarbeitet && me.id == ME_RLinks )
+		aktion = 3;
+	reparaturSkill->doMausEreignis( me );
+	if( !aktion && me.verarbeitet && me.id == ME_RLinks )
+		aktion = 4;
+	laserIntensitätSkill->doMausEreignis( me );
+	if( !aktion && me.verarbeitet && me.id == ME_RLinks )
+		aktion = 5;
+	laserEffizienzSkill->doMausEreignis( me );
+	if( !aktion && me.verarbeitet && me.id == ME_RLinks )
+		aktion = 6;
+	laserTempoSkill->doMausEreignis( me );
+	if( !aktion && me.verarbeitet && me.id == ME_RLinks )
+		aktion = 7;
+	beschleunigungSkill->doMausEreignis( me );
+	if( !aktion && me.verarbeitet && me.id == ME_RLinks )
+		aktion = 8;
+	wendigkeitSkill->doMausEreignis( me );
+	if( !aktion && me.verarbeitet && me.id == ME_RLinks )
+		aktion = 9;
+	netzwerkSkill->doMausEreignis( me );
+	if( !aktion && me.verarbeitet && me.id == ME_RLinks )
+		aktion = 10;
+	akkuLeistungSkill->doMausEreignis( me );
+	if( !aktion && me.verarbeitet && me.id == ME_RLinks )
+		aktion = 11;
+	me.mx += ram->getX();
+	me.my += ram->getY();
+	if( aktion > 1 )
+		return aktion - 2;
+	return -1;
+}
+
+bool Ship::tick( double tickVal )
+{
+	bool ret = stabilitätSkill->tick( tickVal );
+	ret |= energieSkill->tick( tickVal );
+	ret |= reparaturSkill->tick( tickVal );
+	ret |= akkuLeistungSkill->tick( tickVal );
+	ret |= wendigkeitSkill->tick( tickVal );
+	ret |= beschleunigungSkill->tick( tickVal );
+	ret |= laserIntensitätSkill->tick( tickVal );
+	ret |= laserEffizienzSkill->tick( tickVal );
+	ret |= laserTempoSkill->tick( tickVal );
+	ret |= netzwerkSkill->tick( tickVal );
+	return ret;
+}
+
+void Ship::render( Bild &zRObj )
+{
+	zRObj.alphaRegion( ram->getX() + 1, ram->getY() + 1, ram->getBreite() - 2, ram->getHeight() - 2, 0xA0000000 );
+	ram->render( zRObj );
+	if( !zRObj.setDrawOptions( ram->getPosition() + Punkt( 1, 1 ), ram->getSize() - Punkt( 2, 2 ) ) )
+		return;
+	spieler->render( zRObj );
+	stabilitätB->render( zRObj );
+	stabilität->render( zRObj );
+	stabilitätSkill->render( zRObj );
+	energieB->render( zRObj );
+	energie->render( zRObj );
+	energieSkill->render( zRObj );
+	reparatur->render( zRObj );
+	reparaturSkill->render( zRObj );
+	akkuLeistung->render( zRObj );
+	akkuLeistungSkill->render( zRObj );
+	wendigkeit->render( zRObj );
+	wendigkeitSkill->render( zRObj );
+	beschleunigung->render( zRObj );
+	beschleunigungSkill->render( zRObj );
+	laserIntensität->render( zRObj );
+	laserIntensitätSkill->render( zRObj );
+	laserEffizienz->render( zRObj );
+	laserEffizienzSkill->render( zRObj );
+	laserTempo->render( zRObj );
+	laserTempoSkill->render( zRObj );
+	netzwerk->render( zRObj );
+	netzwerkSkill->render( zRObj );
+	zRObj.releaseDrawOptions();
+}
+
+// Reference Counting
+Ship *Ship::getThis()
+{
+	ref++;
+	return this;
+}
+
+Ship *Ship::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return this;
+}

Asteroids/Spiel/Ship/Ship.h

@@ -0,0 +1,54 @@
+#ifndef Ship_H
+#define Ship_H
+
+#include <Knopf.h>
+#include <Fortschritt.h>
+#include "../Spieler/Spieler.h"
+
+using namespace Framework;
+
+class Ship
+{
+private:
+	LRahmen *ram;
+	TextFeld *spieler;
+	TextFeld *stabilität;
+	TextFeld *energie;
+	FBalken *stabilitätB;
+	FBalken *energieB;
+	TextFeld *reparatur;
+	TextFeld *akkuLeistung;
+	TextFeld *wendigkeit;
+	TextFeld *beschleunigung;
+	TextFeld *laserIntensität;
+	TextFeld *laserEffizienz;
+	TextFeld *laserTempo;
+	TextFeld *netzwerk;
+	Knopf *stabilitätSkill;
+	Knopf *energieSkill;
+	Knopf *reparaturSkill;
+	Knopf *akkuLeistungSkill;
+	Knopf *wendigkeitSkill;
+	Knopf *beschleunigungSkill;
+	Knopf *laserIntensitätSkill;
+	Knopf *laserEffizienzSkill;
+	Knopf *laserTempoSkill;
+	Knopf *netzwerkSkill;
+	int ref;
+
+public:
+	// Konstruktor
+	Ship( Schrift *zSchrift );
+	// Destruktor
+	~Ship();
+	// nicht constant
+	void update( Spieler *zSpieler );
+	int doMausEreignis( MausEreignis &me );
+	bool tick( double tickVal );
+	void render( Bild &zRObj );
+	// Reference Counting
+	Ship *getThis();
+	Ship *release();
+};
+
+#endif

Asteroids/Spiel/SpielKlasse.cpp

@@ -0,0 +1,871 @@
+#include "SpielKlasse.h"
+#include <time.h>
+#include <Schrift.h>
+#include <MausEreignis.h>
+#include <TastaturEreignis.h>
+#include <M2Datei.h>
+#include <DateiSystem.h>
+#include "Ship/Ship.h"
+#include "Define.h"
+
+// Inhalt der SpielKlasse Klasse aus SpielKlasse.h
+// Konstruktor
+SpielKlasse::SpielKlasse()
+{
+	spielZeit = 0;
+	rZeit = 0;
+	rendern = 0;
+	stkn = new RCArray< STKNachricht >();
+	stkna = 0;
+	schrift = 0;
+	time_t t;
+	time( &t );
+	srand( (unsigned int)t );
+	infoKlient = 0;
+	spielKlient = 0;
+	spieler = new RCArray< Spieler >();
+	teams = new RCArray< Team >();
+	objekte = new RCArray< SpielObjekt >();
+	screen = 0;
+	kam = 0;
+	spielerAnzahl = 0;
+	karteId = 0;
+	ladenProzent = 0;
+	spielerNummer = 0;
+	map = 0;
+	end = 0;
+	chat = new SpielChat();
+	tasten = new char[ 256 ];
+	for( int i = 0; i < 256; i++ )
+		tasten[ i ] = 0;
+	mx = -1;
+	my = -1;
+	bestenliste = 0;
+	schüsse = new RCArray< Laser >();
+	ship = 0;
+	spielPause = 1;
+	ref = 1;
+}
+
+// Destruktor
+SpielKlasse::~SpielKlasse()
+{
+	if( map )
+	{
+		for( int i = 0; i < map->getMaxTeamAnzahl(); i++ )
+		{
+			if( teams->z( i ) )
+				teams->z( i )->reset();
+		}
+	}
+	stkn->release();
+	if( schrift )
+		schrift->release();
+	if( infoKlient )
+		infoKlient->release();
+	if( spielKlient )
+		spielKlient->release();
+	if( kam )
+		kam->release();
+	if( map )
+		map->release();
+	if( end )
+		end->release();
+	if( bestenliste )
+		bestenliste->release();
+	if( ship )
+		ship->release();
+	chat->relese();
+	spieler->release();
+	teams->release();
+	objekte->release();
+	if( screen )
+		screen->release();
+	schüsse->release();
+	delete[] tasten;
+}
+
+// privat
+bool SpielKlasse::istAmLeben() const
+{
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+			return spieler->z( i )->istAmLeben();
+	}
+	return 0;
+}
+
+// nicht constant
+void SpielKlasse::lock()
+{
+	if( screen )
+		screen->lock();
+}
+
+void SpielKlasse::unlock()
+{
+	if( screen )
+		screen->unlock();
+}
+
+void SpielKlasse::setSchrift( Schrift *schrift )
+{
+	if( this->schrift )
+		this->schrift->release();
+	this->schrift = schrift;
+	chat->setSchrift( schrift );
+	if( !bestenliste )
+		bestenliste = new Bestenliste( schrift->getThis() );
+	if( !ship )
+		ship = new Ship( schrift );
+}
+
+void SpielKlasse::setBildschirm( Bildschirm *screen )
+{
+	this->screen = screen;
+}
+
+void SpielKlasse::nachricht( int län, char *bytes )
+{
+	if( !län )
+		return;
+	lock();
+	stkn->add( new STKNachricht( län, bytes ), stkna );
+	stkna++;
+	unlock();
+}
+
+void SpielKlasse::setKlients( InformationKlientV *infoKlient, SpielKlientV *spielKlient )
+{
+	if( this->infoKlient )
+		this->infoKlient->release();
+	this->infoKlient = infoKlient;
+	if( this->spielKlient )
+		this->spielKlient->release();
+	this->spielKlient = spielKlient;
+}
+
+void SpielKlasse::setKarteId( int karteId )
+{
+	this->karteId = karteId;
+}
+
+void SpielKlasse::ladeDaten()
+{
+	kam = new Kamera();
+	map = new Karte();
+    Text *mapPf = new Text( "data/tmp/Karten/" );
+    mapPf->append( karteId );
+    mapPf->append( "/spiel/data/data.sts" );
+	Datei *stsD = new Datei();
+	stsD->setDatei( mapPf->getText() );
+	stsD->open( Datei::Style::lesen );
+	map->ladeSts( stsD );
+	stsD->close();
+	stsD->release();
+	spielKlient->setLadenProzent( 5 );
+	mapPf->ersetzen( mapPf->getLength() - 3, mapPf->getLength(), "map" );
+	Datei *mapD = new Datei();
+	mapD->setDatei( mapPf->getText() );
+	mapD->open( Datei::Style::lesen );
+	map->ladeMap( mapD, infoKlient, karteId, spielKlient );
+	mapD->close();
+	mapD->release();
+	mapPf->release();
+	for( int i = 0; i < map->getMaxSpielerAnzahl(); i++ )
+		spieler->set( map->createSpieler( i, schrift, infoKlient ), i );
+	spielKlient->setLadenProzent( 95 );
+	for( int i = 0; i < map->getZeichnungAnzahl(); i++ )
+		objekte->set( map->createZeichnung( i, schrift ), i );
+	bestenliste->setTeamAnzahl( map->getMaxTeamAnzahl() );
+	spielKlient->setLadenProzent( 100 );
+}
+
+void SpielKlasse::doMausEreignis( MausEreignis &me )
+{
+	if( end )
+	{
+		end->doMausEreignis( me );
+		return;
+	}
+	if( !istAmLeben() )
+	{
+		if( ( me.id == ME_RLinks || me.id == ME_RRechts ) && mx >= 0 )
+		{
+			mx = -1;
+			my = -1;
+		}
+		if( me.id == ME_Bewegung && mx >= 0 )
+		{
+			kam->addPosition( mx - me.mx, my - me.my, map );
+			mx = me.mx;
+			my = me.my;
+		}
+		if( ( me.id == ME_PLinks || me.id == ME_PRechts ) && mx < 0 )
+		{
+			mx = me.mx;
+			my = me.my;
+		}
+		me.verarbeitet = 1;
+	}
+	else
+	{
+		mx = -1;
+		my = -1;
+	}
+	int skill = ship->doMausEreignis( me );
+	if( skill >= 0 )
+	{
+		char *bytes = new char[ 2 ];
+		bytes[ 0 ] = 9;
+		bytes[ 1 ] = (char)skill;
+		spielKlient->spielNachricht( 2, bytes );
+	}
+	chat->doMausEreignis( me );
+	if( bestenliste )
+		bestenliste->doMausEreignis( me );
+}
+
+void SpielKlasse::doTastaturEreignis( TastaturEreignis &te )
+{
+	bestenliste->doTastaturEreignis( te );
+	if( end )
+		return;
+	if( !chat->istAktiv() )
+	{
+		if( istAmLeben() )
+		{
+			if( te.id == TE_Press )
+			{
+				switch( te.taste )
+				{
+				case 'w':
+				case 'W':
+				case T_Oben:
+					if( !tasten[ T_Oben ] )
+					{
+						tasten[ T_Oben ] = 1;
+						char byte = 0;
+						spielKlient->spielNachricht( 1, &byte );
+						te.verarbeitet = 1;
+					}
+					break;
+				case 'a':
+				case 'A':
+				case T_Links:
+					if( !tasten[ T_Links ] )
+					{
+						tasten[ T_Links ] = 1;
+						char byte = 2;
+						spielKlient->spielNachricht( 1, &byte );
+						te.verarbeitet = 1;
+					}
+					break;
+				case 'd':
+				case 'D':
+				case T_Rechts:
+					if( !tasten[ T_Rechts ] )
+					{
+						tasten[ T_Rechts ] = 1;
+						char byte = 4;
+						spielKlient->spielNachricht( 1, &byte );
+						te.verarbeitet = 1;
+					}
+					break;
+				case T_Space:
+					if( !tasten[ T_Space ] )
+					{
+						tasten[ T_Space ] = 1;
+						char byte = 6;
+						spielKlient->spielNachricht( 1, &byte );
+						te.verarbeitet = 1;
+					}
+					break;
+				}
+			}
+			if( te.id == TE_Release )
+			{
+				switch( te.taste )
+				{
+				case 'w':
+				case 'W':
+				case T_Oben:
+					if( tasten[ T_Oben ] )
+					{
+						tasten[ T_Oben ] = 0;
+						char byte = 1;
+						spielKlient->spielNachricht( 1, &byte );
+						te.verarbeitet = 1;
+					}
+					break;
+				case 'a':
+				case 'A':
+				case T_Links:
+					if( tasten[ T_Links ] )
+					{
+						tasten[ T_Links ] = 0;
+						char byte = 3;
+						spielKlient->spielNachricht( 1, &byte );
+						te.verarbeitet = 1;
+					}
+					break;
+				case 'd':
+				case 'D':
+				case T_Rechts:
+					if( tasten[ T_Rechts ] )
+					{
+						tasten[ T_Rechts ] = 0;
+						char byte = 5;
+						spielKlient->spielNachricht( 1, &byte );
+						te.verarbeitet = 1;
+					}
+					break;
+				case T_Space:
+					if( tasten[ T_Space ] )
+					{
+						tasten[ T_Space ] = 0;
+						char byte = 7;
+						spielKlient->spielNachricht( 1, &byte );
+						te.verarbeitet = 1;
+					}
+					break;
+				}
+			}
+		}
+		else
+		{
+			if( te.id == TE_Press )
+			{
+				switch( te.taste )
+				{
+				case T_Links:
+					kam->addPosition( -2, 0, map );
+					te.verarbeitet = 1;
+					break;
+				case T_Oben:
+					kam->addPosition( 0, -2, map );
+					te.verarbeitet = 1;
+					break;
+				case T_Rechts:
+					kam->addPosition( 2, 0, map );
+					te.verarbeitet = 1;
+					break;
+				case T_Unten:
+					kam->addPosition( 0, 2, map );
+					te.verarbeitet = 1;
+					break;
+				}
+			}
+		}
+	}
+	if( !te.verarbeitet )
+		chat->doTastaturEreignis( te, spielKlient );
+}
+
+void SpielKlasse::stknVerarbeitung()
+{
+	lock();
+	for( int i = 0; i < stkna; i++ )
+	{
+		STKNachricht *n = stkn->z( i );
+		int zeit = n->getSpielZeit();
+		if( zeit > spielZeit )
+			break;
+		int län = n->getLength();
+		char *bytes = n->getNachricht();
+		län--;
+		int sNum = 0;
+		switch( bytes[ 0 ] )
+		{
+		case 0: // spieler drückt gas
+			bytes++;
+			sNum = *(int*)bytes;
+			län -= 4;
+			for( int i = 0; i < spielerAnzahl; i++ )
+			{
+				if( spieler->z( i )->getSpielerNummer() == sNum )
+					spieler->z( i )->setTastataturStatus( T_GAS, 1, zeit, map );
+			}
+			break;
+		case 1: // spieler lässt gas los
+			bytes++;
+			sNum = *(int*)bytes;
+			län -= 4;
+			for( int i = 0; i < spielerAnzahl; i++ )
+			{
+				if( spieler->z( i )->getSpielerNummer() == sNum )
+					spieler->z( i )->setTastataturStatus( T_GAS, 0, zeit, map );
+			}
+			break;
+		case 2: // spieler drückt rotl
+			bytes++;
+			sNum = *(int*)bytes;
+			län -= 4;
+			for( int i = 0; i < spielerAnzahl; i++ )
+			{
+				if( spieler->z( i )->getSpielerNummer() == sNum )
+					spieler->z( i )->setTastataturStatus( T_ROT_L, 1, zeit, map );
+			}
+			break;
+		case 3: // spieler lässt rotl los
+			bytes++;
+			sNum = *(int*)bytes;
+			län -= 4;
+			for( int i = 0; i < spielerAnzahl; i++ )
+			{
+				if( spieler->z( i )->getSpielerNummer() == sNum )
+					spieler->z( i )->setTastataturStatus( T_ROT_L, 0, zeit, map );
+			}
+			break;
+		case 4: // spieler drückt rotr
+			bytes++;
+			sNum = *(int*)bytes;
+			län -= 4;
+			for( int i = 0; i < spielerAnzahl; i++ )
+			{
+				if( spieler->z( i )->getSpielerNummer() == sNum )
+					spieler->z( i )->setTastataturStatus( T_ROT_R, 1, zeit, map );
+			}
+			break;
+		case 5: // spieler lässt rotr los
+			bytes++;
+			sNum = *(int*)bytes;
+			län -= 4;
+			for( int i = 0; i < spielerAnzahl; i++ )
+			{
+				if( spieler->z( i )->getSpielerNummer() == sNum )
+					spieler->z( i )->setTastataturStatus( T_ROT_R, 0, zeit, map );
+			}
+			break;
+		case 6: // Init Spieler
+			if( 1 )
+			{
+				bytes++;
+				spielerAnzahl = (int)*bytes;
+				bytes++;
+				län--;
+				for( int i = 0; i < spielerAnzahl; i++ )
+				{
+					int sNum = *(int*)bytes;
+					Spieler *tmp = spieler->z( sNum - 1 );
+					bytes += 4;
+					län -= 4;
+					tmp->setAccountId( *(int*)bytes );
+					bytes += 4;
+					län -= 4;
+					if( !teams->z( map->getTeamNummer( sNum ) ) )
+						teams->set( map->createTeam( map->getTeamNummer( sNum ) ), map->getTeamNummer( sNum ) );
+					tmp->setTeam( teams->get( map->getTeamNummer( sNum ) ) );
+					tmp->zTeam()->spieler->add( tmp->getThis() );
+					spieler->add( tmp );
+					bestenliste->addSpieler( tmp );
+					bestenliste->updateSpieler( tmp );
+					bestenliste->updateTeam( tmp->zTeam() );
+				}
+				int max = map->getMaxSpielerAnzahl();
+				for( int i = 0; i < max; i++ )
+				{
+					if( !spieler->z( i )->zTeam() )
+					{
+						spieler->remove( i );
+						i--;
+						max--;
+					}
+				}
+			}
+			break;
+		case 0x8: // Chat Nachricht
+			if( 1 )
+			{
+				bytes++;
+				Text *txt = new Text( "" );
+				txt->append( bytes, län );
+				chat->addNachricht( txt->getText() );
+				txt->release();
+				län = 0;
+			}
+			break;
+		case 0x9: // Spieler Nummer
+			bytes++;
+			spielerNummer = *(int*)bytes;
+			län -= 4;
+			for( int i = 0; i < spielerAnzahl; i++ )
+			{
+				if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+				{
+					ship->update( spieler->z( i ) );
+					break;
+				}
+			}
+			break;
+		case 0xA: // Start
+			spielPause = 0;
+			rendern = 1;
+			break;
+		case 0xB: // Ende
+			end = new Ende( schrift );
+			bytes++;
+			län--;
+			end->setGewonnen( *bytes );
+			break;
+		case 0xC: // Skill
+			if( 1 )
+			{
+				bytes++;
+				sNum = *(int*)bytes;
+				bytes += 4;
+				län -= 4;
+				char art = *bytes;
+				län--;
+				for( int i = 0; i < spielerAnzahl; i++ )
+				{
+					if( spieler->z( i )->getSpielerNummer() == sNum )
+					{
+						Team *tmp = spieler->z( i )->zTeam();
+						if( art == 6 || art == 7 || art == 8 )
+						{
+							for( auto *j = &tmp->spieler->getArray(); j && j->set && j->var; j = j->next )
+								j->var->setMoveZeit( zeit - spielZeit, map );
+						}
+						spieler->z( i )->setSkill( art );
+						tmp->akkuLeistung = tmp->getAkkuLeistungBonus();
+						tmp->beschleunigung = tmp->getBeschleunigungBonus();
+						tmp->laserEffizienz = tmp->getLaserEffizienzBonus();
+						tmp->laserIntensität = tmp->getLaserIntensitätBonus();
+						tmp->laserTempo = tmp->getLaserTempoBonus();
+						tmp->maxEnergie = tmp->getMaxEnergieBonus();
+						tmp->maxStabilität = tmp->getMaxStabilitätBonus();
+						tmp->reparatur = tmp->getReperaturBonus();
+						tmp->wendigkeit = tmp->getWendigkeitBonus();
+						if( art == 6 || art == 7 || art == 8 )
+						{
+							for( auto *j = &tmp->spieler->getArray(); j && j->set && j->var; j = j->next )
+								j->var->setMoveZeit( spielZeit - zeit, map );
+						}
+						break;
+					}
+				}
+				for( int i = 0; i < spielerAnzahl; i++ )
+				{
+					if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+					{
+						ship->update( spieler->z( i ) );
+						break;
+					}
+				}
+			}
+			break;
+		case 0xD: // Schuss
+			if( 1 )
+			{
+				bytes++;
+				int id = *(int*)bytes;
+				bytes += 4;
+				län -= 4;
+				sNum = *(int*)bytes;
+				bytes += 4;
+				län -= 4;
+				double xPos = *(double*)bytes;
+				bytes += 8;
+				län -= 8;
+				double yPos = *(double*)bytes;
+				bytes += 8;
+				län -= 8;
+				double xSpeed = *(double*)bytes;
+				bytes += 8;
+				län -= 8;
+				double ySpeed = *(double*)bytes;
+				bytes += 8;
+				län -= 8;
+				double intensität = *(double*)bytes;
+				län -= 8;
+				int farbe = 0;
+				for( int i = 0; i < spielerAnzahl; i++ )
+				{
+					if( spieler->z( i )->getSpielerNummer() == sNum )
+					{
+						spieler->z( i )->setMoveZeit( zeit - spielZeit, map );
+						spieler->z( i )->setPosition( Vec2< double >( xPos, yPos ) );
+						spieler->z( i )->hatGeschossen();
+						farbe = spieler->z( i )->zTeam()->farbe;
+						spieler->z( i )->setMoveZeit( spielZeit - zeit, map );
+						break;
+					}
+				}
+				if( sNum == spielerNummer )
+				{
+					for( int i = 0; i < spielerAnzahl; i++ )
+					{
+						if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+						{
+							ship->update( spieler->z( i ) );
+							bestenliste->updateSpieler( spieler->z( i ) );
+							break;
+						}
+					}
+				}
+				Laser *l = new Laser( id, Vec2< double >( xPos, yPos ), Vec2< double >( xSpeed, ySpeed ), sNum, intensität, farbe );
+				l->tick( spielZeit - zeit, map );
+				schüsse->add( l );
+			}
+			break;
+		case 0xE: // Treffer
+			if( 1 )
+			{
+				bytes++;
+				int schuss = *(int*)bytes;
+				bytes += 4;
+				län -= 4;
+				int sNum = *(int*)bytes;
+				län -= 4;
+				int anz = schüsse->getEintragAnzahl();
+				for( int i = 0; i < anz; i++ )
+				{
+					if( schüsse->z( i )->getId() == schuss )
+					{
+						Laser *tmp = schüsse->z( i );
+						tmp->tick( zeit - spielZeit, map );
+						if( sNum >= 0 )
+						{
+							for( int j = 0; j < spielerAnzahl; j++ )
+							{
+								if( spieler->z( j )->getSpielerNummer() == sNum )
+								{
+									spieler->z( j )->nimmSchaden( tmp->getIntensität() );
+									bestenliste->updateSpieler( spieler->z( j ) );
+								}
+								if( spieler->z( j )->getSpielerNummer() == tmp->getSpieler() )
+								{
+									spieler->z( j )->machSchaden( tmp->getIntensität() );
+									bestenliste->updateSpieler( spieler->z( j ) );
+								}
+							}
+						}
+						schüsse->remove( i );
+						break;
+					}
+				}
+				if( sNum == spielerNummer )
+				{
+					for( int i = 0; i < spielerAnzahl; i++ )
+					{
+						if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+						{
+							ship->update( spieler->z( i ) );
+							break;
+						}
+					}
+				}
+			}
+			break;
+		case 0xF: // Wiederbelebung
+			if( 1 )
+			{
+				bytes++;
+				int sNum = *(int*)bytes;
+				län -= 4;
+				for( int i = 0; i < spielerAnzahl; i++ )
+				{
+					if( spieler->z( i )->getSpielerNummer() == sNum )
+					{
+						spieler->z( i )->wiederbelebung();
+						break;
+					}
+				}
+				if( sNum == spielerNummer )
+				{
+					for( int i = 0; i < spielerAnzahl; i++ )
+					{
+						if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+						{
+							ship->update( spieler->z( i ) );
+							break;
+						}
+					}
+				}
+			}
+			break;
+		case 0x10: // Tod
+			if( 1 )
+			{
+				bytes++;
+				sNum = *(int*)bytes;
+				bytes += 4;
+				län -= 4;
+				int killer = *(int*)bytes;
+				län -= 4;
+				for( int i = 0; i < spielerAnzahl; i++ )
+				{
+					if( spieler->z( i )->getSpielerNummer() == sNum )
+					{
+						spieler->z( i )->sterben();
+						bestenliste->updateSpieler( spieler->z( i ) );
+					}
+					if( spieler->z( i )->getSpielerNummer() == killer )
+					{
+						spieler->z( i )->addKill();
+						spieler->z( i )->zTeam()->punkte++;
+						bestenliste->updateTeam( spieler->z( i )->zTeam() );
+						bestenliste->updateSpieler( spieler->z( i ) );
+					}
+				}
+				if( sNum == spielerNummer )
+				{
+					for( int i = 0; i < spielerAnzahl; i++ )
+					{
+						if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+						{
+							ship->update( spieler->z( i ) );
+							break;
+						}
+					}
+				}
+			}
+			break;
+		default:
+			// Fehler beim verarbeiten
+			break;
+		}
+		if( län != 0 )
+		{
+			// Fehler beim verarbeiten
+			chat->addNachricht( "Es ist ein Fehler beim verarbeiten einer Nachricht aufgetreten.", 0xFFFF0000 );
+		}
+		n->setVerarbeitet();
+	}
+	for( int i = stkna; i > 0; i-- )
+	{
+		if( !stkn->z( 0 ) || !stkn->z( 0 )->istVerarbeitet() )
+			break;
+		stkna--;
+		stkn->remove( 0 );
+	}
+	unlock();
+}
+
+bool SpielKlasse::tick( double zeit )
+{
+	if( spielPause )
+	{
+		zeit = 0;
+		stknVerarbeitung();
+		return 1;
+	}
+	rZeit += zeit;
+	double sZ = 0;
+	while( sZ + TICK < rZeit )
+	{
+		sZ += TICK;
+		rZeit -= TICK;
+		spielZeit++;
+		stknVerarbeitung();
+		if( end )
+			return 1;
+		int x = 0;
+		int y = 0;
+		bool setKam = 0;
+		lock();
+		int objektAnzahl = objekte->getEintragAnzahl();
+		for( int i = 0; i < objektAnzahl; i++ )
+			objekte->z( i )->tick();
+		for( int i = 0; i < spielerAnzahl; i++ )
+		{
+			if( spieler->z( i )->tick( map ) && spieler->z( i )->getSpielerNummer() == spielerNummer )
+				ship->update( spieler->z( i ) );
+			if( spielerNummer == spieler->z( i )->getSpielerNummer() )
+			{
+				x = (int)spieler->z( i )->getPos().x;
+				y = (int)spieler->z( i )->getPos().y;
+				setKam = spieler->z( i )->istAmLeben();
+			}
+		}
+		int schussAnzahl = schüsse->getEintragAnzahl();
+		for( int i = 0; i < schussAnzahl; i++ )
+			schüsse->z( i )->tick( 1, map );
+		unlock();
+		if( setKam )
+		{
+			double px = ( ( x - kam->getPos().x ) / 100.0 ) * ( abs( ( x - kam->getPos().x ) / 2 ) * TICK );
+			double py = ( ( y - kam->getPos().y ) / 100.0 ) * ( abs( ( y - kam->getPos().y ) / 2 ) * TICK );
+			if( abs( x - kam->getPos().x ) > abs( x - ( kam->getPos().x - map->getSize().x ) ) )
+				px = ( ( x - ( kam->getPos().x - map->getSize().x ) ) / 100.0 ) * ( abs( ( x - kam->getPos().x ) / 2 ) * TICK );
+			else if( abs( x - kam->getPos().x ) > abs( x - ( kam->getPos().x + map->getSize().x ) ) )
+				px = ( ( x - ( kam->getPos().x + map->getSize().x ) ) / 100.0 ) * ( abs( ( x - kam->getPos().x ) / 2 ) * TICK );
+			if( abs( y - kam->getPos().y ) > abs( y - ( kam->getPos().y - map->getSize().y ) ) )
+				py = ( ( y - ( kam->getPos().y - map->getSize().y ) ) / 100.0 ) * ( abs( ( y - kam->getPos().y ) / 2 ) * TICK );
+			else if( abs( y - kam->getPos().y ) > abs( y - ( kam->getPos().y + map->getSize().y ) ) )
+				py = ( ( y - ( kam->getPos().y + map->getSize().y ) ) / 100.0 ) * ( abs( ( y - kam->getPos().y ) / 2 ) * TICK );
+			kam->addPosition( (int)px, (int)py, map );
+		}
+		chat->tick( !zeit ? 0.05 : zeit );
+		if( ship )
+		    ship->tick( !zeit ? 0.05 : zeit );
+	}
+	return 1;
+}
+
+void SpielKlasse::render( Bild &zRObj )
+{
+	if( !rendern )
+		return;
+	lock();
+	for( int i = 0; kam->beginnRender( zRObj, map, i ); i++ )
+	{
+		int objektAnzahl = objekte->getEintragAnzahl();
+		for( int i = 0; i < objektAnzahl; i++ )
+			objekte->z( i )->render( zRObj );
+		for( int j = 0; j < spielerAnzahl; j++ )
+			spieler->z( j )->render( zRObj );
+		int schussAnzahl = schüsse->getEintragAnzahl();
+		for( int j = 0; j < schussAnzahl; j++ )
+			schüsse->z( j )->render( zRObj );
+		for( int j = 0; j < spielerAnzahl; j++ )
+			spieler->z( j )->renderLeben( zRObj );
+		kam->endRender( zRObj );
+	}
+	kam->beginnMinimap( zRObj, map );
+	for( int j = 0; j < spielerAnzahl; j++ )
+		spieler->z( j )->renderMinimap( zRObj, map );
+	int schussAnzahl = schüsse->getEintragAnzahl();
+	for( int j = 0; j < schussAnzahl; j++ )
+		schüsse->z( j )->renderMinimap( zRObj, map );
+	kam->endMinimap( zRObj );
+	chat->render( zRObj );
+	if( bestenliste )
+		bestenliste->render( zRObj );
+	if( ship )
+		ship->render( zRObj );
+	if( end )
+		end->render( zRObj );
+	unlock();
+}
+
+// constant
+int SpielKlasse::läuft() const
+{
+	if( !rendern )
+		return 3;
+	if( !end )
+		return 2;
+	if( end && !end->getWeiter() )
+		return 1;
+	if( end && end->getWeiter() )
+		return 0;
+	return 0;
+}
+
+// Reference Counting
+SpielV *SpielKlasse::getThis()
+{
+	ref++;
+	return this;
+}
+
+SpielV *SpielKlasse::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Spiel/SpielKlasse.h

@@ -0,0 +1,76 @@
+#ifndef SpielKlasse_H
+#define SpielKlasse_H
+
+#include "SpielV.h"
+#include "Spieler\Spieler.h"
+#include "Karte\Karte.h"
+#include "Chat\Chat.h"
+#include "Ende\Ende.h"
+#include "Bestenliste\Bestenliste.h"
+#include "..\Netzwerk\STKNachricht.h"
+#include "Schuss\Laser.h"
+#include <Bildschirm.h>
+#include "Objekt/SpielObjekt.h"
+
+class SpielKlasse : public SpielV
+{
+private:
+	RCArray< STKNachricht > *stkn;
+	int stkna;
+	Bestenliste *bestenliste;
+	Schrift *schrift;
+	InformationKlientV *infoKlient;
+	SpielKlientV *spielKlient;
+	RCArray< Spieler > *spieler;
+	RCArray< Team > *teams;
+	RCArray< SpielObjekt > *objekte;
+	Bildschirm *screen;
+	Karte *map;
+	Kamera *kam;
+	SpielChat *chat;                                                                                                   
+	Ende *end;
+	RCArray< Laser > *schüsse;
+	Model2DData *shipData;
+	Bild *shipTextur;
+	Ship *ship;
+	bool rendern;
+	int spielZeit;
+	double rZeit;
+	int spielerAnzahl;
+	int karteId;
+	int ladenProzent;
+	int spielerNummer;
+	char *tasten;
+	int mx;
+	int my;
+	bool spielPause;
+	int ref;
+	bool istAmLeben() const;
+
+public:
+	// Konstruktor
+	SpielKlasse();
+	// Destruktor
+	~SpielKlasse();
+	// nicht constant
+	void lock();
+	void unlock();
+	void setSchrift( Schrift *schrift ) override; // call 4
+	void setBildschirm( Bildschirm *screen ) override; // call 3
+	void nachricht( int län, char *bytes ) override;
+	void setKlients( InformationKlientV *infoKlient, SpielKlientV *spielKlient ) override; // call 2
+	void setKarteId( int karteId ) override; // call 1
+	void ladeDaten() override; // call 5
+	void doMausEreignis( MausEreignis &me ) override;
+	void doTastaturEreignis( TastaturEreignis &te ) override;
+	void stknVerarbeitung();
+	bool tick( double zeit ) override;
+	void render( Bild &zRObj ) override;
+	// constant
+	int läuft() const override;
+	// Reference Counting
+	SpielV *getThis() override;
+	SpielV *release() override;
+};
+
+#endif

Asteroids/Spiel/Spieler/Spieler.cpp

@@ -0,0 +1,591 @@
+#include "Spieler.h"
+#include "../../Initialisierung/Initialisierung.h"
+#include "../Karte/Karte.h"
+#include "../Define.h"
+
+// Inhalt der Spieler Klasse aus Spieler.h
+// Konstruktor
+Spieler::Spieler( InformationKlientV *zInfoK, Schrift *zSchrift, SpielerStr *zStr )
+{
+	accountId = 0;
+	sNum = zStr->id;
+	farbe = 0;
+	ship = new Model2D();
+	ship->setStyle( Model2D::Style::Sichtbar | Model2D::Style::Textur );
+	team = 0;
+	info = zInfoK->getThis();
+	name = 0;
+	for( int i = 0; i < T_MAX; i++ )
+		tastatur[ i ] = 0;
+	amLeben = 1;
+	schussAbk = 0;
+	repAbk = 0;
+	reinkAbk = 0;
+	maxReinkAbk = 5;
+	ref = 1;
+	startPos = zStr->pos;
+	pos = zStr->pos;
+	speed = Vec2< double >( 0, 0 );
+	rotation = zStr->rot;
+	beschleunigung = zStr->beschleunigung;
+	energie = zStr->maxEnergie;
+	stabilität = zStr->maxStabilität;
+	reparatur = zStr->reparatur;
+	laserIntensität = zStr->laserIntensität;
+	laserEffizienz = zStr->laserEffizienz;
+	akkuLeistung = zStr->akkuLeistung;
+	maxEnergie = zStr->maxEnergie;
+	maxStabilität = zStr->maxStabilität;
+	laserTempo = zStr->laserTempo;
+	netzwerk = zStr->netzwerk;
+	wendigkeit = zStr->wendigkeit;
+	skillPunkte =zStr->skillPunkte;
+	schadenBekommen = 0;
+	schadenGemacht = 0;
+	treibstoffVerbraucht = 0;
+	schüsse = 0;
+	treffer = 0;
+	punkte = 0;
+	kills = 0;
+	tode = 0;
+	zeitAmLeben = 0;
+	zeitTod = 0;
+	nText = initTextFeld( 0, 0, 152, 30, zSchrift, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
+						  TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha, "" );
+	spielZeit = 0;
+	stopXSpeedT = -1;
+	stopYSpeedT = -1;
+	stopXSpeed = 0;
+	stopYSpeed = 0;
+	ship->setPosition( pos );
+	ship->setDrehung( (float)rotation );
+}
+
+// Destruktor
+Spieler::~Spieler()
+{
+	ship->release();
+	info->release();
+	if( team )
+		team->release();
+	if( name )
+		name->release();
+}
+
+// nicht constant
+void Spieler::setModelData( Model2DData *data )
+{
+	ship->setModel( data );
+}
+
+void Spieler::setAccountId( int accId )
+{
+	accountId = accId;
+	name = info->getSpielerName( accountId );
+	if( name )
+		nText->setText( *name );
+}
+
+void Spieler::setTeam( Team *team )
+{
+	if( this->team )
+		this->team->release();
+	this->team = team;
+	nText->setHintergrundFarbe( 0xA0000000 | ( team->farbe & 0x00FFFFFF ) );
+	nText->setLinienRahmenFarbe( team->farbe );
+}
+
+void Spieler::setSpielerFarbe( int fc, Bild *zTextur )
+{
+	farbe = fc;
+	nText->setSchriftFarbe( fc );
+	Bild *shb = new Bild();
+	shb->neuBild( zTextur->getBreite(), zTextur->getHeight(), 0 );
+	int maxP = shb->getBreite() * shb->getHeight();
+	int *buffer = zTextur->getBuffer();
+	for( int i = 0; i < maxP; i++ )
+	{
+		if( buffer[ i ] )
+		{
+			shb->setPixelDP( i, ( buffer[ i ] & 0xFF000000 ) | ( fc & 0x00FFFFFF ) );
+			shb->alphaPixelDP( i, buffer[ i ] );
+		}
+	}
+	ship->setTextur( shb );
+}
+
+void Spieler::setGeschwindigkeit( double xSpeed, double ySpeed )
+{
+	speed = Vec2< double >( xSpeed, ySpeed );
+}
+
+void Spieler::setPosition( Vec2< double > p )
+{
+	pos = p;
+	ship->setPosition( pos );
+}
+
+void Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv, int sZ, Karte *zMap )
+{
+	if( !amLeben )
+	{
+		tastatur[ ts ] = aktiv;
+		return;
+	}
+	int z = sZ - spielZeit;
+	setMoveZeit( z, zMap );
+	tastatur[ ts ] = aktiv;
+	setMoveZeit( -z, zMap );
+}
+
+bool Spieler::tick( Karte *zMap )
+{
+	if( !team )
+		return 0;
+	bool ret = 0;
+	double tv = TICK;
+	reinkAbk -= tv;
+	if( reinkAbk < 0 )
+		reinkAbk = 0;
+	if( !reinkAbk && !amLeben )
+	{ // Wiederbelebung
+		//wiederbelebung( spielZeit );
+	}
+	if( amLeben )
+	{
+		schussAbk -= tv;
+		if( schussAbk < 0 )
+			schussAbk = 0;
+		repAbk -= tv;
+		if( repAbk < 0 )
+			repAbk = 0;
+		setMoveZeit( 1, zMap );
+		if( !schussAbk )
+		{
+			if( energie != ( maxEnergie + team->maxEnergie ) )
+				ret = 1;
+			energie += ( akkuLeistung + team->akkuLeistung ) * tv;
+			if( energie >( maxEnergie + team->maxEnergie ) )
+				energie = ( maxEnergie + team->maxEnergie );
+		}
+		if( !repAbk )
+		{
+			if( stabilität != ( maxStabilität + team->maxStabilität ) )
+				ret = 1;
+			stabilität += ( reparatur + team->reparatur ) * tv;
+			if( stabilität > ( maxStabilität + team->maxStabilität ) )
+				stabilität = ( maxStabilität + team->maxStabilität );
+		}
+		zeitAmLeben += tv;
+	}
+	else
+	{
+		zeitTod += tv;
+		spielZeit++;
+	}
+	return ret;
+}
+
+void Spieler::render( Bild &zRObj )
+{
+	if( !amLeben )
+		return;
+	ship->render( zRObj );
+}
+
+void Spieler::renderLeben( Bild &zRObj )
+{
+	if( !team || !amLeben )
+		return;
+	nText->setPosition( ship->getPosition() - Punkt( 76, (int)( ship->zModel()->maxP.y * ship->getSize() ) + 30 ) );
+	nText->render( zRObj );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 4, 150, team->farbe );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 25, 150, team->farbe );
+	int l = (int)( stabilität * 100 / ( maxStabilität + team->maxStabilität ) * 1.5 + 0.5 );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 1, l, 0xFF00FF00 );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 2, l, 0xFF00FF00 );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 3, l, 0xFF00FF00 );
+	int e = (int)( energie * 100 / ( maxEnergie + team->maxEnergie ) * 1.5 + 0.5 );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 26, e, 0xFFFFFF00 );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 27, e, 0xFFFFFF00 );
+	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 28, e, 0xFFFFFF00 );
+}
+
+void Spieler::renderMinimap( Bild &zRObj, Karte *zMap )
+{
+	if( !team || !amLeben )
+		return;
+	int x = (int)( ( pos.x / zMap->getSize().x ) * 250 + 0.5 ) - 2;
+	int y = (int)( ( pos.y / zMap->getSize().y ) * 250 + 0.5 ) - 2;
+	zRObj.fillRegion( x, y, 4, 4, team->farbe );
+	zRObj.fillRegion( x + 1, y + 1, 2, 2, farbe );
+}
+
+void Spieler::setSkill( int art )
+{
+	skillPunkte--;
+	switch( art )
+	{
+	case 0: // Max Stabilität
+		maxStabilität += 10;
+		team->maxStabilität = team->getMaxStabilitätBonus();
+		break;
+	case 1: // Max Energie
+		maxEnergie += 10;
+		team->maxEnergie = team->getMaxEnergieBonus();
+		break;
+	case 2: // Reparatur
+		reparatur += 0.1;
+		team->reparatur = team->getReperaturBonus();
+		break;
+	case 3: // Laser Intensität
+		laserIntensität += 3;
+		team->laserIntensität = team->getLaserIntensitätBonus();
+		break;
+	case 4: // Laser Effizienz
+		laserEffizienz += 2;
+		team->laserEffizienz = team->getLaserEffizienzBonus();
+		break;
+	case 5: // Laser Tempo
+		laserTempo += 10;
+		team->laserTempo = team->getLaserTempoBonus();
+		break;
+	case 6: // Beschleunigung
+		beschleunigung += 2;
+		team->beschleunigung = team->getBeschleunigungBonus();
+		break;
+	case 7: // Wendigkeit
+		wendigkeit += 0.15;
+		team->wendigkeit = team->getWendigkeitBonus();
+		break;
+	case 8: // Netzwerk
+		netzwerk += 1;
+		team->maxStabilität = team->getMaxStabilitätBonus();
+		team->maxEnergie = team->getMaxEnergieBonus();
+		team->reparatur = team->getReperaturBonus();
+		team->laserIntensität = team->getLaserIntensitätBonus();
+		team->laserEffizienz = team->getLaserEffizienzBonus();
+		team->laserTempo = team->getLaserTempoBonus();
+		team->beschleunigung = team->getBeschleunigungBonus();
+		team->wendigkeit = team->getWendigkeitBonus();
+		team->akkuLeistung = team->getAkkuLeistungBonus();
+		break;
+	case 9: // Akkuleistung
+		akkuLeistung += 0.4;
+		team->akkuLeistung = team->getAkkuLeistungBonus();
+		break;
+	}
+}
+
+void Spieler::nimmSchaden( double intensität )
+{
+	stabilität -= intensität;
+	schadenBekommen += intensität;
+	repAbk = 2;
+}
+
+void Spieler::machSchaden( double intensität )
+{
+	schadenGemacht += intensität;
+	treffer++;
+}
+
+void Spieler::addKill()
+{
+	kills++;
+	punkte++;
+	skillPunkte += 2;
+	maxReinkAbk--;
+	if( maxReinkAbk < 5 )
+		maxReinkAbk = 5;
+}
+
+void Spieler::sterben()
+{
+	amLeben = 0;
+	tode++;
+	stabilität = 0;
+	reinkAbk += maxReinkAbk;
+	maxReinkAbk++;
+	punkte--;
+}
+
+void Spieler::wiederbelebung()
+{
+	pos = startPos;
+	reinkAbk = maxReinkAbk * 2;
+	energie = maxEnergie + team->maxEnergie;
+	stabilität = maxStabilität + team->maxStabilität;
+	schussAbk = 0;
+	repAbk = 0;
+	speed = Vec2< double >( 0, 0 );
+	rotation = 0;
+	ship->setDrehung( (float)rotation );
+	ship->setPosition( pos );
+	for( int i = 0; i < T_MAX; i++ )
+		tastatur[ i ] = 0;
+	amLeben = 1;
+}
+
+void Spieler::setMoveZeit( int z, Karte *zMap )
+{
+	spielZeit += z;
+	double tv = TICK * z;
+	if( tv < 0 )
+	{
+		if( speed.x || speed.y )
+			pos += speed * tv;
+		Vec2< int > gr = zMap->getSize();
+		while( pos.x < 0 )
+			pos.x += gr.x;
+		while( pos.y < 0 )
+			pos.y += gr.y;
+		while( pos.x >= gr.x )
+			pos.x -= gr.x;
+		while( pos.y >= gr.y )
+			pos.y -= gr.y;
+		ship->setPosition( pos );
+		if( tastatur[ T_ROT_R ] )
+			rotation += tv * ( wendigkeit + team->wendigkeit );
+		if( tastatur[ T_ROT_L ] )
+			rotation -= tv * ( wendigkeit + team->wendigkeit );
+		ship->setDrehung( (float)rotation );
+		if( tastatur[ T_GAS ] )
+		{
+			treibstoffVerbraucht += tv;
+			speed.x += ( beschleunigung + team->beschleunigung ) * cos( rotation ) * tv;
+			speed.y += ( beschleunigung + team->beschleunigung ) * sin( rotation ) * tv;
+		}
+		else
+		{
+			double movementAngle = atan2( speed.y, speed.x );
+			for( int i = 1; i <= -z; i++ )
+			{
+				if( stopXSpeedT == spielZeit + ( -z - i ) )
+					speed.x = stopXSpeed;
+				if( stopYSpeedT == spielZeit + ( -z - i ) )
+					speed.y = stopYSpeed;
+				if( speed.x != 0 )
+					speed.x += 30.0f * cos( movementAngle + PI ) * -TICK;
+				if( speed.y != 0 )
+					speed.y += 30.0f * sin( movementAngle + PI ) * -TICK;
+			}
+		}
+	}
+	else
+	{
+		if( tastatur[ T_GAS ] )
+		{
+			treibstoffVerbraucht += tv;
+			speed.x += ( beschleunigung + team->beschleunigung ) * cos( rotation ) * tv;
+			speed.y += ( beschleunigung + team->beschleunigung ) * sin( rotation ) * tv;
+		}
+		else
+		{
+			double movementAngle = atan2( speed.y, speed.x );
+			for( int i = 1; i <= z; i++ )
+			{
+				if( speed.x != 0 )
+					speed.x += 30.0f * cos( movementAngle + PI ) * TICK;
+				if( speed.y != 0 )
+					speed.y += 30.0f * sin( movementAngle + PI ) * TICK;
+				if( speed.x < 6.f && speed.x > -6.f )
+				{
+					stopXSpeedT = spielZeit - ( z - i );
+					stopXSpeed = speed.x;
+					speed.x = 0;
+				}
+				if( speed.y < 6.f && speed.y > -6.f )
+				{
+					stopYSpeedT = spielZeit - ( z - i );
+					stopYSpeed = speed.y;
+					speed.y = 0;
+				}
+			}
+		}
+		if( tastatur[ T_ROT_R ] )
+			rotation += tv * ( wendigkeit + team->wendigkeit );
+		if( tastatur[ T_ROT_L ] )
+			rotation -= tv * ( wendigkeit + team->wendigkeit );
+		ship->setDrehung( (float)rotation );
+		if( speed.x || speed.y )
+			pos += speed * tv;
+		Vec2< int > gr = zMap->getSize();
+		while( pos.x < 0 )
+			pos.x += gr.x;
+		while( pos.y < 0 )
+			pos.y += gr.y;
+		while( pos.x >= gr.x )
+			pos.x -= gr.x;
+		while( pos.y >= gr.y )
+			pos.y -= gr.y;
+		ship->setPosition( pos );
+	}
+}
+
+void Spieler::hatGeschossen()
+{
+	double kosten = ( laserIntensität + team->laserIntensität + ( laserTempo + team->laserTempo ) / 5 ) - ( laserEffizienz + team->laserEffizienz );
+	if( kosten < 1 )
+		kosten = 1;
+	energie -= kosten;
+	schussAbk = 1;
+	schüsse++;
+}
+
+// constant
+int Spieler::getAccountId() const
+{
+	return accountId;
+}
+
+Text *Spieler::getName() const
+{
+	return name ? name->getThis() : 0;
+}
+
+Text *Spieler::zName() const
+{
+	return name;
+}
+
+bool Spieler::hatSkill() const
+{
+	return skillPunkte != 0;
+}
+
+bool Spieler::istAmLeben() const
+{
+	return amLeben;
+}
+
+// Statistik Werte
+int Spieler::getSpielerNummer() const
+{
+	return sNum;
+}
+
+Team *Spieler::zTeam() const
+{
+	return team;
+}
+
+int Spieler::getSpielerFarbe() const
+{
+	return farbe;
+}
+
+int Spieler::getSchadenBekommen() const
+{
+	return (int)schadenBekommen;
+}
+
+int Spieler::getSchadenGemacht() const
+{
+	return (int)schadenGemacht;
+}
+
+int Spieler::getTreibstoffVerbraucht() const
+{
+	return (int)treibstoffVerbraucht;
+}
+
+int Spieler::getSchüsse() const
+{
+	return schüsse;
+}
+
+int Spieler::getTreffer() const
+{
+	return treffer;
+}
+
+int Spieler::getPunkte() const
+{
+	return punkte;
+}
+
+int Spieler::getKills() const
+{
+	return kills;
+}
+
+int Spieler::getTode() const
+{
+	return tode;
+}
+
+int Spieler::getZeitAmLeben() const
+{
+	return (int)zeitAmLeben;
+}
+
+int Spieler::getZeitTod() const
+{
+	return (int)zeitTod;
+}
+
+Punkt Spieler::getPos() const
+{
+	return (Punkt)pos;
+}
+
+double Spieler::getTeamMaxEnergieBonus() const
+{
+	return maxEnergie / 100 * netzwerk;
+}
+
+double Spieler::getTeamMaxStabilitätBonus() const
+{
+	return maxStabilität / 100 * netzwerk;
+}
+
+double Spieler::getTeamReparaturBonus() const
+{
+	return reparatur / 100 * netzwerk;
+}
+
+double Spieler::getTeamLaserIntensitätBonus() const
+{
+	return laserIntensität / 100 * netzwerk;
+}
+
+double Spieler::getTeamLaserEffizienzBonus() const
+{
+	return laserEffizienz / 100 * netzwerk;
+}
+
+double Spieler::getTeamAkkuLeistungBonus() const
+{
+	return akkuLeistung / 100 * netzwerk;
+}
+
+double Spieler::getTeamLaserTempoBonus() const
+{
+	return laserTempo / 100 * netzwerk;
+}
+
+double Spieler::getTeamBeschleunigungBonus() const
+{
+	return beschleunigung / 100 * netzwerk;
+}
+
+double Spieler::getTeamWendigkeitBonus() const
+{
+	return wendigkeit / 100 * netzwerk;
+}
+
+// Reference Counting
+Spieler *Spieler::getThis()
+{
+	ref++;
+	return this;
+}
+
+Spieler *Spieler::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Spiel/Spieler/Spieler.h

@@ -0,0 +1,140 @@
+#ifndef Spieler_H
+#define Spieler_H
+
+#include <KSGKlientV.h>
+#include <Model2D.h>
+#include <TextFeld.h>
+#include "..\Kamera\Kamera.h"
+#include "../Team/Team.h"
+#include "../Karte/Strukturen.h"
+
+class Team;
+class Laser;
+class Karte;
+class Ship;
+
+enum TastaturStatus
+{
+	T_GAS,
+	T_ROT_L,
+	T_ROT_R,
+	T_FEUER,
+	T_MAX
+};
+
+class Spieler
+{
+	friend class Ship;
+private:
+	int accountId;
+	int sNum;
+	int farbe;
+	Model2D *ship;
+	Team *team;
+	InformationKlientV *info;
+	Text *name;
+	bool tastatur[ T_MAX ];
+	bool amLeben;
+	double schussAbk;
+	double repAbk;
+	double reinkAbk;
+	int maxReinkAbk;
+	int spielZeit;
+	int stopXSpeedT;
+	int stopYSpeedT;
+	double stopXSpeed;
+	double stopYSpeed;
+	int ref;
+	// Raumschiff Eigenschaften
+	Punkt startPos;
+	Vec2< double > pos;
+	Vec2< double > speed;
+	double rotation;
+	double beschleunigung;
+	double energie;
+	double stabilität;
+	double reparatur;
+	double laserIntensität;
+	double laserEffizienz;
+	double akkuLeistung;
+	double maxEnergie;
+	double maxStabilität;
+	double laserTempo;
+	double netzwerk;
+	double wendigkeit;
+	int skillPunkte;
+	// Statistik Werte
+	double schadenBekommen;
+	double schadenGemacht;
+	double treibstoffVerbraucht;
+	int schüsse;
+	int treffer;
+	int punkte;
+	int kills;
+	int tode;
+	double zeitAmLeben;
+	double zeitTod;
+	// Namen Anzeige
+	TextFeld *nText;
+
+public:
+	// Konstruktor
+	Spieler( InformationKlientV *zInfoK, Schrift *zSchrift, SpielerStr *zStr );
+	// Destruktor
+	~Spieler();
+	// nicht constant
+	void setModelData( Model2DData *data );
+	void setAccountId( int accId );
+	void setTeam( Team *team );
+	void setSpielerFarbe( int fc, Bild *zTextur );
+	void setGeschwindigkeit( double xSpeed, double ySpeed );
+	void setPosition( Vec2< double > p );
+	void setTastataturStatus( TastaturStatus ts, bool aktiv, int sZ, Karte *zMap );
+	bool tick( Karte *zMap );
+	void render( Bild &zRObj );
+	void renderLeben( Bild &zRObj );
+	void renderMinimap( Bild &zRObj, Karte *zMap );
+	void setSkill( int art );
+	void nimmSchaden( double intensität );
+	void machSchaden( double intensität );
+	void addKill();
+	void sterben();
+	void wiederbelebung();
+	void setMoveZeit( int z, Karte *zMap );
+	void hatGeschossen();
+	// constant
+	int getAccountId() const;
+	Text *getName() const;
+	Text *zName() const;
+	bool hatSkill() const;
+	bool istAmLeben() const;
+	// Statistik Werte
+	int getSpielerNummer() const;
+	Team *zTeam() const;
+	int getSpielerFarbe() const;
+	int getSchadenBekommen() const;
+	int getSchadenGemacht() const;
+	int getTreibstoffVerbraucht() const;
+	int getSchüsse() const;
+	int getTreffer() const;
+	int getPunkte() const;
+	int getKills() const;
+	int getTode() const;
+	int getZeitAmLeben() const;
+	int getZeitTod() const;
+	Punkt getPos() const;
+	double getTeamMaxEnergieBonus() const;
+	double getTeamMaxStabilitätBonus() const;
+	double getTeamReparaturBonus() const;
+	double getTeamLaserIntensitätBonus() const;
+	double getTeamLaserEffizienzBonus() const;
+	double getTeamAkkuLeistungBonus() const;
+	double getTeamLaserTempoBonus() const;
+	double getTeamBeschleunigungBonus() const;
+	double getTeamWendigkeitBonus() const;
+	// Reference Counting
+	Spieler *getThis();
+	Spieler *release();
+};
+
+#endif

Asteroids/Spiel/Team/Team.cpp

@@ -0,0 +1,134 @@
+#include "Team.h"
+#include "../Spieler/Spieler.h"
+
+// Inhalt der Team Klasse aus Team.h
+// Konstruktor
+Team::Team( int f, char *n, TeamStr *zStr )
+{
+	id = zStr->id;
+	farbe = f;
+	name = n;
+	spieler = new RCArray< Spieler >();
+	punkte = zStr->punkte;
+	maxPunkte = zStr->maxPunkte;
+	maxEnergieS = zStr->maxEnergie;
+	maxStabilitätS = zStr->maxStabilität;
+	reparaturS = zStr->reparatur;
+	laserIntensitätS = zStr->laserIntensität;
+	laserEffizienzS = zStr->laserEffizienz;
+	akkuLeistungS = zStr->akkuLeistung;
+	laserTempoS = zStr->laserTempo;
+	beschleunigungS = zStr->beschleunigung;
+	wendigkeitS = zStr->wendigkeit;
+	reset();
+	ref = 1;
+}
+
+// Destruktor
+Team::~Team()
+{
+	spieler->release();
+}
+
+// nicht constant
+void Team::reset()
+{
+	spieler->leeren();
+	maxEnergie = maxEnergieS;
+	maxStabilität = maxStabilitätS;
+	reparatur = reparaturS;
+	laserIntensität = laserIntensitätS;
+	laserEffizienz = laserEffizienzS;
+	akkuLeistung = akkuLeistungS;
+	laserTempo = laserTempoS;
+	beschleunigung = beschleunigungS;
+	wendigkeit = wendigkeitS;
+}
+
+// constant
+double Team::getMaxEnergieBonus() const
+{
+	double ret = maxEnergieS;
+	for( auto *i = &spieler->getArray(); i && i->set; i = i->next )
+		ret += i->var->getTeamMaxEnergieBonus();
+	return ret;
+}
+
+double Team::getMaxStabilitätBonus() const
+{
+	double ret = maxStabilitätS;
+	for( auto *i = &spieler->getArray(); i && i->set; i = i->next )
+		ret += i->var->getTeamMaxStabilitätBonus();
+	return ret;
+}
+
+double Team::getReperaturBonus() const
+{
+	double ret = reparaturS;
+	for( auto *i = &spieler->getArray(); i && i->set; i = i->next )
+		ret += i->var->getTeamReparaturBonus();
+	return ret;
+}
+
+double Team::getLaserIntensitätBonus() const
+{
+	double ret = laserIntensitätS;
+	for( auto *i = &spieler->getArray(); i && i->set; i = i->next )
+		ret += i->var->getTeamLaserIntensitätBonus();
+	return ret;
+}
+
+double Team::getLaserEffizienzBonus() const
+{
+	double ret = laserEffizienzS;
+	for( auto *i = &spieler->getArray(); i && i->set; i = i->next )
+		ret += i->var->getTeamLaserEffizienzBonus();
+	return ret;
+}
+
+double Team::getAkkuLeistungBonus() const
+{
+	double ret = akkuLeistungS;
+	for( auto *i = &spieler->getArray(); i && i->set; i = i->next )
+		ret += i->var->getTeamAkkuLeistungBonus();
+	return ret;
+}
+
+double Team::getLaserTempoBonus() const
+{
+	double ret = laserTempoS;
+	for( auto *i = &spieler->getArray(); i && i->set; i = i->next )
+		ret += i->var->getTeamLaserTempoBonus();
+	return ret;
+}
+
+double Team::getBeschleunigungBonus() const
+{
+	double ret = beschleunigungS;
+	for( auto *i = &spieler->getArray(); i && i->set; i = i->next )
+		ret += i->var->getTeamBeschleunigungBonus();
+	return ret;
+}
+
+double Team::getWendigkeitBonus() const
+{
+	double ret = wendigkeitS;
+	for( auto *i = &spieler->getArray(); i && i->set; i = i->next )
+		ret += i->var->getTeamWendigkeitBonus();
+	return ret;
+}
+
+// Reference Counting
+Team *Team::getThis()
+{
+	ref++;
+	return this;
+}
+
+Team *Team::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Spiel/Team/Team.h

@@ -0,0 +1,63 @@
+#ifndef Team_H
+#define Team_H
+
+class Spieler; // Spieler.h
+#include <Text.h>
+#include <Array.h>
+#include "../Karte/Strukturen.h"
+
+using namespace Framework;
+
+class Team
+{
+private:
+	double maxEnergieS;
+	double maxStabilitätS;
+	double reparaturS;
+	double laserIntensitätS;
+	double laserEffizienzS;
+	double akkuLeistungS;
+	double laserTempoS;
+	double beschleunigungS;
+	double wendigkeitS;
+	int ref;
+
+public:
+	// variablen
+	int id;
+	int farbe;
+	Text name;
+	RCArray< Spieler > *spieler;
+	int punkte;
+	int maxPunkte;
+	double maxEnergie;
+	double maxStabilität;
+	double reparatur;
+	double laserIntensität;
+	double laserEffizienz;
+	double akkuLeistung;
+	double laserTempo;
+	double beschleunigung;
+	double wendigkeit;
+	// Konstruktor
+	Team( int f, char *n, TeamStr *zStr );
+	// Destruktor
+	~Team();
+	// nicht constant
+	void reset();
+	// constant
+	double getMaxEnergieBonus() const;
+	double getMaxStabilitätBonus() const;
+	double getReperaturBonus() const;
+	double getLaserIntensitätBonus() const;
+	double getLaserEffizienzBonus() const;
+	double getAkkuLeistungBonus() const;
+	double getLaserTempoBonus() const;
+	double getBeschleunigungBonus() const;
+	double getWendigkeitBonus() const;
+	// Reference Counting
+	Team *getThis();
+	Team *release();
+};
+
+#endif

Asteroids/SpielStatistik/Chat/StatistikChat.cpp

@@ -0,0 +1,518 @@
+#include "StatistikChat.h"
+#include <Punkt.h>
+#include <DateiSystem.h>
+#include <MausEreignis.h>
+#include <AlphaFeld.h>
+#include <Scroll.h>
+#include <Rahmen.h>
+#include <TastaturEreignis.h>
+#include "../../Initialisierung/Initialisierung.h"
+
+// Inhalt der ChatListeSpieler Klasse aus StatistikChat.h
+// Konstruktor
+ChatListeSpieler::ChatListeSpieler( int accountId, int eigeneId, Schrift *zSchrift, BilderV *bilder, InformationKlientV *zInfoc,
+									bool istFreund, void( *addChatF )( void*, int ), void( *addFreundF )( void*, int ),
+									void( *accountAnsehenF )( void *, int ), void *param )
+									: addChatF( addChatF ),
+									addFreundF( addFreundF ),
+									accountAnsehenF( accountAnsehenF ),
+									nachrichtParam( param ),
+									accountId( accountId ),
+									bg( new AlphaFeld() ),
+									name( initTextFeld( 0, 0, 133, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::VCenter, "" ) ),
+									accountAnsehen( initKnopf( 133, 0, 20, 20, 0, 0, "" ) ),
+									nachrichtSenden( initKnopf( 153, 0, 20, 20, 0, 0, "" ) ),
+									freundesanfrageSenden( initKnopf( 173, 0, 20, 20, 0, 0, "" ) ),
+									pos( 0, 0 ),
+									gr( 133, 20 ),
+									online( 1 ),
+									minKnopfX( 113 - ( ( ( accountId != eigeneId ) + !istFreund ) * 20 ) ),
+									knopfX( 133 ),
+									mausIn( 0 ),
+									tickVal( 0 ),
+									rend( 0 ),
+									ref( 1 )
+{
+	Bild *ansehenBild = bilder->get( "chat.ltdb/ansehen.png" );
+	if( !ansehenBild )
+	{
+		LTDBDatei *datei = new LTDBDatei();
+		datei->setDatei( new Text( "data/client/bilder/chat.ltdb" ) );
+		datei->leseDaten( 0 );
+		ansehenBild = datei->laden( 0, new Text( "ansehen.png" ) );
+		datei->release();
+		bilder->add( "chat.ltdb/ansehen.png", ansehenBild->getThis() );
+	}
+	Bild *nachrichtBild = bilder->get( "chat.ltdb/nachricht.png" );
+	if( !nachrichtBild )
+	{
+		LTDBDatei *datei = new LTDBDatei();
+		datei->setDatei( new Text( "data/client/bilder/chat.ltdb" ) );
+		datei->leseDaten( 0 );
+		nachrichtBild = datei->laden( 0, new Text( "nachricht.png" ) );
+		datei->release();
+		bilder->add( "chat.ltdb/nachricht.png", nachrichtBild->getThis() );
+	}
+	Bild *einladungBild = bilder->get( "chat.ltdb/neuerfreund.png" );
+	if( !nachrichtBild )
+	{
+		LTDBDatei *datei = new LTDBDatei();
+		datei->setDatei( new Text( "data/client/bilder/chat.ltdb" ) );
+		datei->leseDaten( 0 );
+		einladungBild = datei->laden( 0, new Text( "neuerfreund.png" ) );
+		datei->release();
+		bilder->add( "chat.ltdb/neuerfreund.png", einladungBild->getThis() );
+	}
+	bg->setSize( gr );
+	bg->setFarbe( 0x0000FF00 );
+	bg->setStrength( -4 );
+	name->setText( zInfoc->getSpielerName( accountId ) );
+	accountAnsehen->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
+	accountAnsehen->setHintergrundBildZ( ansehenBild );
+	nachrichtSenden->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
+	nachrichtSenden->setHintergrundBildZ( nachrichtBild );
+	freundesanfrageSenden->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
+	freundesanfrageSenden->setHintergrundBildZ( einladungBild );
+}
+
+// Destruktor
+ChatListeSpieler::~ChatListeSpieler()
+{
+	bg->release();
+	name->release();
+	accountAnsehen->release();
+	nachrichtSenden->release();
+	freundesanfrageSenden->release();
+}
+
+// nicht constant
+void ChatListeSpieler::setOffline()
+{
+	online = 0;
+}
+
+void ChatListeSpieler::setPosition( int y )
+{
+	if( pos.y != y )
+		rend = 1;
+	pos.y = y;
+}
+
+void ChatListeSpieler::doMausEreignis( MausEreignis &me )
+{
+	int mx = me.mx;
+	int my = me.my;
+	me.mx -= pos.x;
+	me.my -= pos.y;
+	if( me.mx > 0 && me.mx < gr.x && me.my > 0 && me.my < gr.y )
+		mausIn = 1;
+	else
+		mausIn = 0;
+	me.mx += 133 - knopfX;
+	bool vera = me.verarbeitet;
+	accountAnsehen->doMausEreignis( me );
+	int aktion = ( me.verarbeitet && !vera ) ? 1 : 0;
+	nachrichtSenden->doMausEreignis( me );
+	aktion = ( me.verarbeitet && !vera && !aktion ) ? 2 : aktion;
+	freundesanfrageSenden->doMausEreignis( me );
+	aktion = ( me.verarbeitet && !vera && !aktion ) ? 3 : aktion;
+	me.mx -= 133 - knopfX;
+	if( me.id == ME_RLinks && mausIn )
+	{
+		switch( aktion )
+		{
+		case 1:
+			accountAnsehenF( nachrichtParam, accountId );
+			break;
+		case 2:
+			addChatF( nachrichtParam, accountId );
+			break;
+		case 3:
+			addFreundF( nachrichtParam, accountId );
+			break;
+		}
+	}
+	me.mx = mx;
+	me.my = my;
+}
+
+bool ChatListeSpieler::tick( double tickVal )
+{
+	rend |= name->tick( tickVal );
+	rend |= accountAnsehen->tick( tickVal );
+	rend |= nachrichtSenden->tick( tickVal );
+	rend |= freundesanfrageSenden->tick( tickVal );
+	this->tickVal += tickVal * 60;
+	int val = ( int )this->tickVal;
+	if( val )
+	{
+		this->tickVal -= val;
+		if( mausIn && knopfX != minKnopfX )
+		{
+			if( knopfX - val < minKnopfX )
+				knopfX = minKnopfX;
+			else
+				knopfX -= val;
+			rend = 1;
+		}
+		if( !mausIn && knopfX != gr.x )
+		{
+			if( knopfX + val > gr.x )
+				knopfX = gr.x;
+			else
+				knopfX += val;
+			rend = 1;
+		}
+		if( !online && bg->getFarbe() != 0x00FF0000 )
+		{
+			int g = ( bg->getFarbe() >> 8 ) & 0xFF;
+			if( g - val < 0 )
+				bg->setFarbe( 0x00FF0000 );
+			else
+			{
+				bg->setFarbe( ( ( ( g - val ) << 8 ) & 0xFF00 ) | ( bg->getFarbe() & 0xFFFF00FF ) );
+				bg->setFarbe( ( ( ( 255 - ( g - val ) ) << 16 ) & 0xFF0000 ) | ( bg->getFarbe() & 0xFF00FFFF ) );
+			}
+			rend = 1;
+		}
+	}
+	bool ret = rend;
+	rend = 0;
+	return ret;
+}
+
+void ChatListeSpieler::render( Bild &zRObj )
+{
+	if( !zRObj.setDrawOptions( pos, gr ) )
+		return;
+	bg->render( zRObj );
+	name->render( zRObj );
+	zRObj.addScrollOffset( 133 - knopfX, 0 );
+	accountAnsehen->render( zRObj );
+	nachrichtSenden->render( zRObj );
+	freundesanfrageSenden->render( zRObj );
+	zRObj.releaseDrawOptions();
+}
+
+// constant
+int ChatListeSpieler::getAccountId() const
+{
+	return accountId;
+}
+
+// Reference Counting
+ChatListeSpieler *ChatListeSpieler::getThis()
+{
+	ref++;
+	return this;
+}
+
+ChatListeSpieler *ChatListeSpieler::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}
+
+
+// Inhalt der ChatListe Klasse aus StatistikChat.h
+// Konstruktor
+ChatListe::ChatListe( int eigeneId, InformationKlientV *infoc, Schrift *schrift, BilderV *bilder,
+					  void( *addChat )( void*, int ), void( *addFreund )( void*, int ),
+					  void( *accountAnsehen )( void *, int ), void *param )
+					  : addChat( addChat ),
+					  addFreund( addFreund ),
+					  accountAnsehen( accountAnsehen ),
+					  nachrichtParam( nachrichtParam ),
+					  eigeneId( eigeneId ),
+					  spieler( new RCArray< ChatListeSpieler >() ),
+					  vScroll( new VScrollBar() ),
+					  pos( 620, 295 ),
+					  gr( 150, 150 ),
+					  infoc( infoc ),
+					  schrift( schrift ),
+					  bilder( bilder ),
+					  ram( new LRahmen() ),
+					  rend( 0 ),
+					  ref( 1 )
+{
+	vScroll->setKlickScroll( 10 );
+	vScroll->update( 0, 148 );
+	ram->setFarbe( 0xFFFFFFFF );
+	ram->setSize( 150, 150 );
+}
+
+// Destruktor
+ChatListe::~ChatListe()
+{
+	spieler->release();
+	vScroll->release();
+	infoc->release();
+	schrift->release();
+	ram->release();
+}
+
+// nicht constant
+void ChatListe::addSpieler( int accountId, bool istFreund )
+{
+	int anz = spieler->getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+	{
+		if( spieler->z( i ) && spieler->z( i )->getAccountId() == accountId )
+			return;
+	}
+	ChatListeSpieler *s = new ChatListeSpieler( accountId, eigeneId, schrift, bilder, infoc, istFreund, addChat, addFreund, accountAnsehen, nachrichtParam );
+	s->setPosition( anz * 20 );
+	spieler->add( s );
+	rend = 1;
+}
+
+void ChatListe::setOffline( int accountId )
+{
+	int anz = spieler->getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+	{
+		if( spieler->z( i ) && spieler->z( i )->getAccountId() == accountId )
+		{
+			spieler->z( i )->setOffline();
+			return;
+		}
+	}
+}
+
+void ChatListe::doMausEreignis( MausEreignis &me )
+{
+	int mx = me.mx;
+	int my = me.my;
+	me.mx -= pos.x;
+	me.my -= pos.y - vScroll->getScroll();
+	vScroll->doMausMessage( 134, 1, 15, 148, me );
+	int anz = spieler->getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+	{
+		if( spieler->z( i ) )
+			spieler->z( i )->doMausEreignis( me );
+	}
+	me.mx = mx;
+	me.my = my;
+}
+
+bool ChatListe::tick( double tickVal )
+{
+	rend |= vScroll->getRend();
+	int anz = spieler->getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+	{
+		if( spieler->z( i ) )
+			rend |= spieler->z( i )->tick( tickVal );
+	}
+	bool ret = rend;
+	rend = 0;
+	return ret;
+}
+
+void ChatListe::render( Bild &zRObj )
+{
+	if( !zRObj.setDrawOptions( pos, gr ) )
+		return;
+	int anz = spieler->getEintragAnzahl();
+	zRObj.addScrollOffset( 0, vScroll->getScroll() );
+	for( int i = 0; i < anz; i++ )
+	{
+		if( spieler->z( i ) )
+			spieler->z( i )->render( zRObj );
+	}
+	zRObj.addScrollOffset( 0, -vScroll->getScroll() );
+	vScroll->render( 134, 1, 15, 148, zRObj );
+	ram->render( zRObj );
+	zRObj.releaseDrawOptions();
+}
+
+// constant
+
+// Reference Counting
+ChatListe *ChatListe::getThis()
+{
+	ref++;
+	return this;
+}
+
+ChatListe *ChatListe::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}
+
+
+// Inhalt der StatistikChat Klasse aus StatistikChat.h
+// Konstruktor
+StatistikChat::StatistikChat( int eigeneId, SpielKlientV *spielc, InformationKlientV *infoc, Schrift *schrift, BilderV *bilder,
+							  void( *addNachricht )( void *, Text *, Text *, Text *, Text *, char, void * ),
+							  void( *addChat )( void*, int ), void( *addFreund )( void*, int ),
+							  void( *accountAnsehen )( void *, int ), void *param )
+							  : addNachricht( addNachricht ),
+							  nachrichtParam( nachrichtParam ),
+							  spielc( spielc ),
+							  infoc( infoc ),
+							  verlauf( initTextFeld( 10, 295, 600, 150, schrift, TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::VScroll | TextFeld::Style::Mehrzeilig, "" ) ),
+							  nachricht( initTextFeld( 10, 450, 575, 20, schrift, TextFeld::Style::TextFeld, "" ) ),
+							  senden( initKnopf( 590, 450, 20, 20, 0, 0, "" ) ),
+							  verlassen( initKnopf( 630, 450, 130, 20, schrift, Knopf::Style::Sichtbar, "Verlassen" ) ),
+							  spielerListe( new ChatListe( eigeneId, infoc->getThis(), schrift, bilder, addChat, addFreund, accountAnsehen, nachrichtParam ) ),
+							  beenden( 0 ),
+							  ref( 1 )
+{
+	Bild *sendenBild = bilder->get( "chat.ltdb/senden.png" );
+	if( !sendenBild )
+	{
+		LTDBDatei *datei = new LTDBDatei();
+		datei->setDatei( new Text( "data/client/bilder/chat.ltdb" ) );
+		datei->leseDaten( 0 );
+		sendenBild = datei->laden( 0, new Text( "senden.png" ) );
+		datei->release();
+		bilder->add( "chat.ltdb/senden.png", sendenBild->getThis() );
+	};
+	senden->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
+	senden->setHintergrundBildZ( sendenBild );
+}
+
+// Destruktor
+StatistikChat::~StatistikChat()
+{
+	spielc->release();
+	infoc->release();
+	verlauf->release();
+	nachricht->release();
+	senden->release();
+	verlassen->release();
+	spielerListe->release();
+}
+
+// nicht constant
+void StatistikChat::addSpieler( int accountId, bool istFreund )
+{
+	spielerListe->addSpieler( accountId, istFreund );
+}
+
+void StatistikChat::spielerOffline( int accountId )
+{
+	spielerListe->setOffline( accountId );
+}
+
+void StatistikChat::addChatNachricht( int vonAccount, char *nachricht )
+{
+	Text *txt = vonAccount ? infoc->getSpielerName( vonAccount ) : 0;
+	if( !txt )
+		txt = new Text();
+	else
+		*txt += ": ";
+	*txt += nachricht;
+	*txt += "\n";
+	verlauf->zSchrift()->textFormatieren( txt, verlauf->getBreite() - 15, 12 );
+	verlauf->zText()->append( txt );
+	verlauf->updateVScroll();
+}
+
+void StatistikChat::doMausEreignis( MausEreignis &me )
+{
+	verlauf->doMausEreignis( me );
+	nachricht->doMausEreignis( me );
+	spielerListe->doMausEreignis( me );
+	bool vera = me.verarbeitet;
+	senden->doMausEreignis( me );
+	int aktion = ( me.verarbeitet && !vera ) ? 1 : 0;
+	verlassen->doMausEreignis( me );
+	aktion = ( me.verarbeitet && !vera && !aktion ) ? 2 : aktion;
+	if( me.id == ME_RLinks )
+	{
+		if( aktion == 1 )
+		{
+			if( nachricht->zText()->getLength() )
+			{
+				short län = 1 + nachricht->zText()->getLength();
+				char *bytes = new char[ län ];
+				bytes[ 0 ] = 1;
+				for( int i = 0; i < län - 1; i++ )
+					bytes[ i + 1 ] = nachricht->zText()->getText()[ i ];
+				if( !spielc->statistikNachricht( län, bytes ) )
+					addNachricht( nachrichtParam, new Text( "Fehler" ), new Text( "Die Nachricht konnte nicht gesendet werden." ), new Text( "Ok" ), 0, 0, 0 );
+				else
+				{
+					nachricht->setAuswahl( 0, 0 );
+					nachricht->setText( "" );
+				}
+				delete[] bytes;
+			}
+		}
+		if( aktion == 2 )
+			beenden = 1;
+	}
+}
+
+void StatistikChat::doTastaturEreignis( TastaturEreignis &te )
+{
+	bool vera = te.verarbeitet;
+	nachricht->doTastaturEreignis( te );
+	if( !vera && te.verarbeitet && te.id == TE_Release && te.taste == T_Enter )
+	{
+		if( nachricht->zText()->getLength() )
+		{
+			short län = 1 + nachricht->zText()->getLength();
+			char *bytes = new char[ län ];
+			bytes[ 0 ] = 1;
+			for( int i = 0; i < län - 1; i++ )
+				bytes[ i + 1 ] = nachricht->zText()->getText()[ i ];
+			if( !spielc->statistikNachricht( län, bytes ) )
+				addNachricht( nachrichtParam, new Text( "Fehler" ), new Text( "Die Nachricht konnte nicht gesendet werden." ), new Text( "Ok" ), 0, 0, 0 );
+			else
+			{
+				nachricht->setAuswahl( 0, 0 );
+				nachricht->setText( "" );
+			}
+			delete[] bytes;
+		}
+	}
+}
+
+bool StatistikChat::tick( double tickVal )
+{
+	bool rend = verlauf->tick( tickVal );
+	rend |= nachricht->tick( tickVal );
+	rend |= senden->tick( tickVal );
+	rend |= verlassen->tick( tickVal );
+	rend |= spielerListe->tick( tickVal );
+	return rend;
+}
+
+void StatistikChat::render( Bild &zRObj )
+{
+	verlauf->render( zRObj );
+	nachricht->render( zRObj );
+	senden->render( zRObj );
+	verlassen->render( zRObj );
+	spielerListe->render( zRObj );
+}
+
+// constant
+bool StatistikChat::hatVerlassen()
+{
+	return beenden;
+}
+
+// Reference Counting
+StatistikChat *StatistikChat::getThis()
+{
+	ref++;
+	return this;
+}
+
+StatistikChat *StatistikChat::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/SpielStatistik/Chat/StatistikChat.h

@@ -0,0 +1,131 @@
+#ifndef StatistikChat_H
+#define StatistikChat_H
+
+#include <Fenster.h>
+#include <Knopf.h>
+#include <KSGKlientV.h>
+#include <BilderV.h>
+
+using namespace Framework;
+
+class ChatListeSpieler
+{
+private:
+	void( *addChatF )( void *, int );
+	void( *addFreundF )( void *, int );
+	void( *accountAnsehenF )( void *, int );
+	void *nachrichtParam;
+	int accountId;
+	AlphaFeld *bg;
+	TextFeld *name;
+	Knopf *accountAnsehen;
+	Knopf *nachrichtSenden;
+	Knopf *freundesanfrageSenden;
+	Punkt pos;
+	Punkt gr;
+	bool online;
+	int minKnopfX;
+	int knopfX;
+	bool mausIn;
+	double tickVal;
+	bool rend;
+	int ref;
+
+public:
+	// Konstruktor
+	ChatListeSpieler( int accountId, int eigeneId, Schrift *zSchrift, BilderV *bilder, InformationKlientV *zInfoc,
+											  bool istFreund, void( *addChatF )( void*, int ), void( *addFreundF )( void*, int ),
+											  void( *accountAnsehenF )( void *, int ), void *param );
+	// Destruktor
+	~ChatListeSpieler();
+	// nicht constant
+	void setOffline();
+	void setPosition( int y );
+	void doMausEreignis( MausEreignis &me );
+	bool tick( double tickVal );
+	void render( Bild &zRObj );
+	// constant
+	int getAccountId() const;
+	// Reference Counting
+	ChatListeSpieler *getThis();
+	ChatListeSpieler *release();
+};
+
+class ChatListe
+{
+private:
+	void( *addChat )( void *, int );
+	void( *addFreund )( void *, int );
+	void( *accountAnsehen )( void *, int );
+	void *nachrichtParam;
+	int eigeneId;
+	RCArray< ChatListeSpieler > *spieler;
+	VScrollBar *vScroll;
+	Punkt pos;
+	Punkt gr;
+	InformationKlientV *infoc;
+	Schrift *schrift;
+	BilderV *bilder;
+	LRahmen *ram;
+	bool rend;
+	int ref;
+
+public:
+	// Konstruktor
+	ChatListe( int eigeneId, InformationKlientV *infoc, Schrift *schrift, BilderV *bilder,
+									   void( *addChat )( void*, int ), void( *addFreund )( void*, int ),
+									   void( *accountAnsehen )( void *, int ), void *param );
+	// Destruktor
+	~ChatListe();
+	// nicht constant
+	void addSpieler( int accountId, bool istFreund );
+	void setOffline( int accountId );
+	void doMausEreignis( MausEreignis &me );
+	bool tick( double tickVal );
+	void render( Bild &zRObj );
+	// constant
+
+	// Reference Counting
+	ChatListe *getThis();
+	ChatListe *release();
+};
+
+class StatistikChat
+{
+private:
+	void( *addNachricht )( void *, Text *, Text *, Text *, Text *, char, void * );
+	void *nachrichtParam;
+	SpielKlientV *spielc;
+	InformationKlientV *infoc;
+	TextFeld *verlauf;
+	TextFeld *nachricht;
+	Knopf *senden;
+	Knopf *verlassen;
+	ChatListe *spielerListe;
+	bool beenden;
+	int ref;
+
+public:
+	// Konstruktor
+	StatistikChat( int eigeneId, SpielKlientV *spielc, InformationKlientV *infoc, Schrift *schrift, BilderV *bilder,
+										   void( *addNachricht )( void *, Text *, Text *, Text *, Text *, char, void * ),
+										   void( *addChat )( void*, int ), void( *addFreund )( void*, int ),
+										   void( *accountAnsehen )( void *, int ), void *param );
+	// Destruktor
+	~StatistikChat();
+	// nicht constant
+	void addSpieler( int accountId, bool istFreund );
+	void spielerOffline( int accountId );
+	void addChatNachricht( int vonAccount, char *nachricht );
+	void doMausEreignis( MausEreignis &me );
+	void doTastaturEreignis( TastaturEreignis &te );
+	bool tick( double tickVal );
+	void render( Bild &zRObj );
+	// constant
+	bool hatVerlassen();
+	// Reference Counting
+	StatistikChat *getThis();
+	StatistikChat *release();
+};
+
+#endif

Asteroids/SpielStatistik/SpielStatistik.cpp

@@ -0,0 +1,388 @@
+#include "SpielStatistik.h"
+#include "../Initialisierung/Initialisierung.h"
+#include <MausEreignis.h>
+#include <Punkt.h>
+
+// Inhalt der SpielStatistik Klasse aus SpielStatistik.h
+// Konstruktor
+SpielStatistik::SpielStatistik()
+{
+	InitializeCriticalSection( &cs );
+	addNachrichtF = 0;
+	addChatF = 0;
+	addFreundF = 0;
+	accountAnsehenF = 0;
+	istFreundF = 0;
+	nachrichtParam = 0;
+	bilder = 0;
+	schrift = 0;
+	screen = 0;
+	infoc = 0;
+	spielc = 0;
+	status = 0;
+	gss = new Array< SSDSpieler* >();
+	gts = new Array< SSDTeam* >();
+	chat = 0;
+	tabelle = 0;
+	accountId = 0;
+	rend = 0;
+	ref = 1;
+}
+
+// Destruktor
+SpielStatistik::~SpielStatistik()
+{
+	if( chat )
+		chat->release();
+	if( tabelle )
+		tabelle->release();
+	if( schrift )
+		schrift->release();
+	if( screen )
+		screen->release();
+	if( infoc )
+		infoc->release();
+	if( spielc )
+		spielc->release();
+	int anz = gss->getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+	{
+		if( gss->hat( i ) )
+			delete gss->get( i );
+	}
+	gss->release();
+	anz = gts->getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+	{
+		if( gts->hat( i ) )
+			delete gts->get( i );
+	}
+	gts->release();
+	DeleteCriticalSection( &cs );
+}
+
+// nicht constant
+void SpielStatistik::lock()
+{
+	EnterCriticalSection( &cs );
+}
+
+void SpielStatistik::unlock()
+{
+	LeaveCriticalSection( &cs );
+}
+
+void SpielStatistik::bereit()
+{
+	char byte = 0;
+	spielc->statistikNachricht( 1, &byte );
+}
+
+void SpielStatistik::setBilder( BilderV *b )
+{
+	bilder = b;
+}
+
+void SpielStatistik::setAccountId( int id )
+{
+	accountId = id;
+}
+
+void SpielStatistik::setRückrufFunktionen( void( *addNachrichtF )( void *, Text *, Text *, Text *, Text *, char, void * ),
+										   void( *addChatF )( void *, int ), void( *addFreundF )( void *, int ),
+										   void( *accountAnsehenF )( void *, int ), bool( *istFreundF )( void *, int ), void *nachrichtParam )
+{
+	this->addNachrichtF = addNachrichtF;
+	this->addChatF = addChatF;
+	this->addFreundF = addFreundF;
+	this->accountAnsehenF = accountAnsehenF;
+	this->istFreundF = istFreundF;
+	this->nachrichtParam = nachrichtParam;
+}
+
+void SpielStatistik::setSchrift( Schrift *schrift )
+{
+	if( this->schrift )
+		this->schrift->release();
+	this->schrift = schrift;
+}
+
+void SpielStatistik::setBildschirm( Bildschirm *screen )
+{
+	if( this->screen )
+		this->screen->release();
+	this->screen = screen;
+}
+
+void SpielStatistik::setKlients( InformationKlientV *infoc, SpielKlientV *spielc )
+{
+	if( this->infoc )
+		this->infoc->release();
+	if( this->spielc )
+		this->spielc->release();
+	this->infoc = infoc;
+	this->spielc = spielc;
+}
+
+void SpielStatistik::nachricht( int län, char *bytes )
+{
+	lock();
+	char num = *bytes;
+	bytes++;
+	län--;
+	switch( num )
+	{
+	case 0: // Spieler Statistik
+		if( 1 )
+		{
+			SSDSpieler *ssdgs = new SSDSpieler();
+			ssdgs->spielerNummer = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			char snlän = *bytes;
+			län--;
+			bytes++;
+			char *txt = new char[ snlän + 1 ];
+			txt[ snlän ] = 0;
+			for( int i = 0; i < snlän; i++ )
+				txt[ i ] = bytes[ i ];
+			bytes += snlän;
+			län -= snlän;
+			ssdgs->spielerName = txt;
+			delete[] txt;
+			char tnlän = *bytes;
+			län--;
+			bytes++;
+			txt = new char[ tnlän + 1 ];
+			txt[ tnlän ] = 0;
+			for( int i = 0; i < tnlän; i++ )
+				txt[ i ] = bytes[ i ];
+			bytes += tnlän;
+			län -= tnlän;
+			ssdgs->teamName = txt;
+			delete[] txt;
+			ssdgs->spielerFarbe = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgs->teamFarbe = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgs->schadenBekommen = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgs->schadenGemacht = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgs->treibstoffVerbraucht = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgs->schüsse = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgs->treffer = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgs->punkte = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgs->kills = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgs->tode = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgs->zeitAmLeben = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgs->zeitTod = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			gss->add( ssdgs );
+		}
+		break;
+	case 1: // Team Statistik
+		if( 1 )
+		{
+			SSDTeam *ssdgt = new SSDTeam();
+			ssdgt->teamNummer = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			char tnlän = *bytes;
+			län--;
+			bytes++;
+			char *txt = new char[ tnlän + 1 ];
+			txt[ tnlän ] = 0;
+			for( int i = 0; i < tnlän; i++ )
+				txt[ i ] = bytes[ i ];
+			bytes += tnlän;
+			län -= tnlän;
+			ssdgt->teamName = txt;
+			delete[] txt;
+			ssdgt->teamFarbe = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgt->schadenBekommen = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgt->schadenGemacht = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgt->treibstoffVerbraucht = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgt->schüsse = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgt->treffer = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgt->punkte = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgt->kills = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgt->tode = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			ssdgt->gewonnen = *bytes != 0;
+			bytes++;
+			län--;
+			gts->add( ssdgt );
+		}
+		break;
+	case 2: // Ladevorgang abgeschlossen
+		if( 1 )
+		{
+			chat = new StatistikChat( accountId, spielc->getThis(), infoc->getThis(), schrift->getThis(), bilder, addNachrichtF, addChatF, addFreundF, accountAnsehenF, nachrichtParam );
+			int anz = gss->getEintragAnzahl();
+			for( int i = 0; i < anz; i++ )
+			{
+				if( gss->hat( i ) )
+				{
+					int acc = infoc->getAccountId( gss->get( i )->spielerName );
+					if( acc )
+						chat->addSpieler( acc, istFreundF( nachrichtParam, acc ) || acc == accountId );
+				}
+			}
+			tabelle = new StatistikTabelle( gss->getThis(), gts->getThis(), schrift, screen );
+			status = 1;
+		}
+		break;
+	case 3: // Chat Nachricht
+		if( 1 )
+		{
+			int vonAccount = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			char *txt = new char[ län + 1 ];
+			txt[ län ] = 0;
+			for( int i = 0; i < län; i++ )
+				txt[ i ] = bytes[ i ];
+			if( status == 1 )
+				chat->addChatNachricht( vonAccount, txt );
+			delete[] txt;
+		}
+		break;
+	case 4: // Spieler hat verlassen
+		if( 1 )
+		{
+			int acc = *(int*)bytes;
+			bytes += 4;
+			län -= 4;
+			if( status == 1 )
+				chat->spielerOffline( acc );
+		}
+		break;
+	default:
+		// Fehler
+		break;
+	}
+	if( län != 0 )
+	{
+		// Fehler
+	}
+	unlock();
+}
+
+void SpielStatistik::doMausEreignis( MausEreignis &me )
+{
+	if( !status )
+		return;
+	lock();
+	if( status == 1 )
+	{
+		tabelle->doMausEreignis( me );
+		chat->doMausEreignis( me );
+	}
+	unlock();
+}
+
+void SpielStatistik::doTastaturEreignis( TastaturEreignis &te )
+{
+	if( !status )
+		return;
+	lock();
+	if( status == 1 )
+		chat->doTastaturEreignis( te );
+	unlock();
+}
+
+bool SpielStatistik::tick( double zeit )
+{
+	if( !status )
+		return 0;
+	lock();
+	if( status == 1 )
+	{
+		rend |= chat->tick( zeit );
+		rend |= tabelle->tick( zeit );
+		if( chat->hatVerlassen() && status == 1 )
+		{
+			spielc->trenne();
+			status = 2;
+		}
+	}
+	bool ret = rend;
+	rend = 0;
+	unlock();
+	return ret;
+}
+
+void SpielStatistik::render( Bild &zRObj )
+{
+	if( !status )
+		return;
+	lock();
+	chat->render( zRObj );
+	tabelle->render( zRObj );
+	unlock();
+}
+
+void SpielStatistik::verlassen()
+{
+	if( spielc )
+		spielc->trenne();
+	status = 2;
+}
+
+// constant
+int SpielStatistik::getStatus() const // 0 = laden, 1 = läuft, 2 = fortsetzen
+{
+	return status;
+}
+
+// Reference Counting
+SpielStatistikV *SpielStatistik::getThis()
+{
+	ref++;
+	return this;
+}
+
+SpielStatistikV *SpielStatistik::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/SpielStatistik/SpielStatistik.h

@@ -0,0 +1,63 @@
+#ifndef SpielStatistik_H
+#define SpielStatistik_H
+
+#include <SpielStatistikV.h>
+#include "SpielStatistikDaten.h"
+#include "Chat/StatistikChat.h"
+#include "Tabelle/StatistikTabelle.h"
+
+class SpielStatistik : public SpielStatistikV
+{
+private:
+	void( *addNachrichtF )( void *, Text *, Text *, Text *, Text *, char, void * );
+	void( *addChatF )( void *, int );
+	void( *addFreundF )( void *, int );
+	void( *accountAnsehenF )( void *, int );
+	bool( *istFreundF )( void *, int );
+	void *nachrichtParam;
+	BilderV *bilder;
+	Schrift *schrift;
+	Bildschirm *screen;
+	InformationKlientV *infoc;
+	SpielKlientV *spielc;
+	CRITICAL_SECTION cs;
+	Array< SSDSpieler* > *gss;
+	Array< SSDTeam* > *gts;
+	StatistikChat *chat;
+	StatistikTabelle *tabelle;
+	int accountId;
+	bool rend;
+	int status;
+	int ref;
+
+public:
+	// Konstruktor
+	SpielStatistik();
+	// Destruktor
+	~SpielStatistik();
+	// nicht constant
+	void lock();
+	void unlock();
+	virtual void bereit();
+	virtual void setBilder( BilderV *b );
+	virtual void setAccountId( int id );
+	virtual void setRückrufFunktionen( void( *addNachrichtF )( void *, Text *, Text *, Text *, Text *, char, void * ),
+															   void( *addChatF )( void *, int ), void( *addFreundF )( void *, int ),
+															   void( *accountAnsehenF )( void *, int ), bool( *istFreundF )( void *, int ), void *nachrichtParam );
+	virtual void setSchrift( Schrift *schrift );
+	virtual void setBildschirm( Bildschirm *screen );
+	virtual void setKlients( InformationKlientV *infoc, SpielKlientV *spielc );
+	virtual void nachricht( int län, char *bytes );
+	virtual void doMausEreignis( MausEreignis &me );
+	virtual void doTastaturEreignis( TastaturEreignis &te );
+	virtual bool tick( double zeit );
+	virtual void render( Bild &zRObj );
+	virtual void verlassen();
+	// constant
+	virtual int getStatus() const; // 0 = laden, 1 = läuft, 2 = fortsetzen
+	// Reference Counting
+	virtual SpielStatistikV *getThis();
+	virtual SpielStatistikV *release();
+};
+
+#endif

Asteroids/SpielStatistik/SpielStatistikDaten.h

@@ -0,0 +1,45 @@
+#ifndef SpielStatistikDaten_H
+#define SpielStatistikDaten_H
+
+#include <Text.h>
+#include <Bild.h>
+#include <Array.h>
+
+using namespace Framework;
+
+struct SSDSpieler
+{
+	int spielerNummer;
+	Text spielerName;
+	Text teamName;
+	int spielerFarbe;
+	int teamFarbe;
+	int schadenBekommen;
+	int schadenGemacht;
+	int treibstoffVerbraucht;
+	int schüsse;
+	int treffer;
+	int punkte;
+	int kills;
+	int tode;
+	int zeitAmLeben;
+	int zeitTod;
+};
+
+struct SSDTeam
+{
+	int teamNummer;
+	Text teamName;
+	int teamFarbe;
+	int schadenBekommen;
+	int schadenGemacht;
+	int treibstoffVerbraucht;
+	int schüsse;
+	int treffer;
+	int punkte;
+	int kills;
+	int tode;
+	bool gewonnen;
+};
+
+#endif

Asteroids/SpielStatistik/Tabelle/StatistikTabelle.cpp

@@ -0,0 +1,429 @@
+#include "StatistikTabelle.h"
+#include "../../Initialisierung/Initialisierung.h"
+
+#define ABSTYLE     AuswahlBox::Style::Sichtbar | AuswahlBox::Style::Erlaubt | AuswahlBox::Style::Rahmen | AuswahlBox::Style::AuswahlBuffer | AuswahlBox::Style::MausBuffer | AuswahlBox::Style::MaxHeight | AuswahlBox::Style::Hintergrund | AuswahlBox::Style::VScroll
+#define OTSTYLE     ObjTabelle::Style::Sichtbar | ObjTabelle::Style::Erlaubt | ObjTabelle::Style::Rahmen | ObjTabelle::Style::Raster | ObjTabelle::Style::scroll | ObjTabelle::Style::SpaltenBreiteMax | ObjTabelle::Style::SpaltenBreiteMin | ObjTabelle::Style::SpaltenBreiteChangeable | ObjTabelle::Style::SpaltenBeweglich
+
+// Inhalt der StatistikTabelle Klasse aus StatistikTabelle.h
+// Konstruktor
+StatistikTabelle::StatistikTabelle( Array< SSDSpieler* > *ssdgs, Array< SSDTeam* > *ssdgt,
+									Schrift *zSchrift, Bildschirm *zScreen, bool historie )
+									: schrift( zSchrift->getThis() ),
+									ssdgs( ssdgs ),
+									ssdgt( ssdgt ),
+									stAuswahl( initAuswahlBox( 10, 10, 120, 20, zSchrift, ABSTYLE, { "Spieler", "Teams" } ) ),
+									sortAuswahlGS( initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Spielername", "Teamname",
+									"Spielerfarbe", "Teamfarbe", "Schaden bekommen", "Schaden gemacht", "Treibstoff verbraucht",
+									"Präzision", "Punkte", "Kills", "Tode", "Zeit am Leben", "Zeit tod" } ) ),
+									sortAuswahlGT( initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Teamname", "Teamfarbe",
+									"Schaden bekommen", "Schaden gemacht", "Treibstoff verbraucht", "Präzision", "Punkte", "Kills", "Tode" } ) ),
+									sortRichtungGS( initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
+									sortRichtungGT( initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
+									gesamtSpieler( initObjTabelle( 10, 40, 760, 245, zSchrift, OTSTYLE, { { "Spielername", 120, 20, 200 },
+									{ "Teamname", 120, 20, 120 }, { "Spielerfarbe", 100, 20, 100 }, { "Teamfarbe", 100, 20, 100 },
+									{ "Schaden bekommen", 130, 20, 130 }, { "Schaden gemacht", 130, 20, 130 },
+									{ "Treibstoff verbraucht", 140, 20, 140 }, { "Präzision", 60, 20, 60 }, { "Punkte", 50, 20, 50 },
+									{ "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 }, { "Zeit Am Leben", 120, 20, 120 },
+									{ "Zeit tod", 60, 20, 60 } }, 20 ) ),
+									gesamtTeam( initObjTabelle( 10, 40, 760, 245, zSchrift, OTSTYLE, { { "Teamname", 120, 20, 120 },
+									{ "Teamfarbe", 100, 20, 100 }, { "Schaden bekommen", 130, 20, 130 }, { "Schaden gemacht", 130, 20, 130 },
+									{ "Treibstoff verbraucht", 140, 20, 140 }, { "Präzision", 60, 20, 60 }, { "Punkte", 50, 20, 50 },
+									{ "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 } }, 20 ) ),
+									teamS( 0 ),
+									rend( 0 ),
+									ref( 1 )
+{
+	tabelleFüllen( gesamtSpieler );
+	tabelleFüllen( gesamtTeam );
+	if( historie )
+	{
+		sortRichtungGS->setSize( 110, 20 );
+		sortRichtungGT->setSize( 110, 20 );
+		gesamtSpieler->setSize( 760, 380 );
+		gesamtTeam->setSize( 760, 380 );
+	}
+}
+
+// Destruktor
+StatistikTabelle::~StatistikTabelle()
+{
+	tabelleLehren( gesamtSpieler, 1 );
+	tabelleLehren( gesamtTeam, 1 );
+	schrift->release();
+	ssdgs->release();
+	ssdgt->release();
+	stAuswahl->release();
+	sortAuswahlGS->release();
+	sortAuswahlGT->release();
+	sortRichtungGS->release();
+	sortRichtungGT->release();
+	gesamtSpieler->release();
+	gesamtTeam->release();
+}
+
+// privat
+void StatistikTabelle::tabelleLehren( ObjTabelle *zT, bool überschrift )
+{
+	int sAnz = zT->getSpaltenAnzahl();
+	int zAnz = zT->getZeilenAnzahl();
+	for( int i = !überschrift; i < zAnz; i++ )
+	{
+		for( int j = 0; j < sAnz; j++ )
+			( (TextFeld*)zT->zZeichnung( j, !überschrift ) )->release();
+		zT->removeZeile( !überschrift );
+	}
+}
+
+void StatistikTabelle::tabelleFüllen( ObjTabelle *zT )
+{
+	if( zT == gesamtSpieler )
+	{
+		if( !sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() ) )
+			return;
+		if( !sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() ) )
+			return;
+		Array< int > reihenfolge;
+		bool aufsteigend = sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() )->istGleich( "Aufwärts" );
+		int anz = ssdgs->getEintragAnzahl();
+		bool *fertig = new bool[ anz ];
+		ZeroMemory( fertig, anz );
+		bool spielername = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Spielername" );
+		bool teamname = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Teamname" );
+		bool spielerfarbe = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Spielerfarbe" );
+		bool teamfarbe = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Teamfarbe" );
+		bool schadenBekommen = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Schaden bekommen" );
+		bool schadenGemacht = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Schaden gemacht" );
+		bool treibstoffVerbraucht = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Treibstoff verbraucht" );
+		bool präzision = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Präzision" );
+		bool punkte = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Punkte" );
+		bool kills = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Kills" );
+		bool tode = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Tode" );
+		bool zeitamleben = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Zeit am Leben" );
+		bool zeittod = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Zeit tod" );
+		for( int i = 0; i < anz; i++ )
+		{
+			Text minMaxT;
+			int minMax;
+			int pos = -1;
+			for( int j = 0; j < anz; j++ )
+			{
+				if( !ssdgs->hat( j ) || fertig[ j ] )
+					continue;
+				if( spielername && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->spielerName < minMaxT ) || ( !aufsteigend && ssdgs->get( j )->spielerName > minMaxT ) ) )
+				{ // Sortiert nach Spieler Name
+					minMaxT = ssdgs->get( j )->spielerName.getText();
+					pos = j;
+				}
+				if( teamname && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdgs->get( j )->teamName > minMaxT ) ) )
+				{ // Sortiert nach Team Name
+					minMaxT = ssdgs->get( j )->teamName.getText();
+					pos = j;
+				}
+				if( spielerfarbe && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->spielerFarbe < minMax ) || ( !aufsteigend && ssdgs->get( j )->spielerFarbe > minMax ) ) )
+				{ // Sortiert nach Spieler Farbe
+					minMax = ssdgs->get( j )->spielerFarbe;
+					pos = j;
+				}
+				if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdgs->get( j )->teamFarbe > minMax ) ) )
+				{ // Sortiert nach Team Farbe
+					minMax = ssdgs->get( j )->teamFarbe;
+					pos = j;
+				}
+				if( schadenBekommen && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->schadenBekommen < minMax ) || ( !aufsteigend && ssdgs->get( j )->schadenBekommen > minMax ) ) )
+				{ // Sortiert nach Schaden bekommen
+					minMax = ssdgs->get( j )->schadenBekommen;
+					pos = j;
+				}
+				if( schadenGemacht && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->schadenGemacht < minMax ) || ( !aufsteigend && ssdgs->get( j )->schadenGemacht > minMax ) ) )
+				{ // Sortiert nach Schaden gemacht
+					minMax = ssdgs->get( j )->schadenGemacht;
+					pos = j;
+				}
+				if( treibstoffVerbraucht && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->treibstoffVerbraucht < minMax ) || ( !aufsteigend && ssdgs->get( j )->treibstoffVerbraucht > minMax ) ) )
+				{ // Sortiert nach Treibstoff verbraucht
+					minMax = ssdgs->get( j )->treibstoffVerbraucht;
+					pos = j;
+				}
+				if( präzision && ( pos < 0 || ( aufsteigend && ( ssdgs->get( j )->treffer ? (int)( 100 / ( (double)ssdgs->get( j )->schüsse / ssdgs->get( j )->treffer ) ) : 0 ) < minMax ) || ( !aufsteigend && ( 100 / ( ssdgs->get( j )->schüsse / ssdgs->get( j )->treffer ) ) > minMax ) ) )
+				{ // Sortiert nach Treibstoff verbraucht
+					minMax = (int)( 100 / ( (double)ssdgs->get( j )->schüsse / ssdgs->get( j )->treffer ) );
+					pos = j;
+				}
+				if( punkte && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->punkte < minMax ) || ( !aufsteigend && ssdgs->get( j )->punkte > minMax ) ) )
+				{ // Sortiert nach Punkten
+					minMax = ssdgs->get( j )->punkte;
+					pos = j;
+				}
+				if( kills && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->kills < minMax ) || ( !aufsteigend && ssdgs->get( j )->kills > minMax ) ) )
+				{ // Sortiert nach Kills
+					minMax = ssdgs->get( j )->kills;
+					pos = j;
+				}
+				if( tode && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->tode < minMax ) || ( !aufsteigend && ssdgs->get( j )->tode > minMax ) ) )
+				{ // Sortiert nach Toden
+					minMax = ssdgs->get( j )->tode;
+					pos = j;
+				}
+				if( zeitamleben && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->zeitAmLeben < minMax ) || ( !aufsteigend && ssdgs->get( j )->zeitAmLeben > minMax ) ) )
+				{ // Sortiert nach Zeit Am Leben
+					minMax = ssdgs->get( j )->zeitAmLeben;
+					pos = j;
+				}
+				if( zeittod && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->zeitTod < minMax ) || ( !aufsteigend && ssdgs->get( j )->zeitTod > minMax ) ) )
+				{ // Sortiert nach Zeit Tod
+					minMax = ssdgs->get( j )->zeitTod;
+					pos = j;
+				}
+			}
+			if( pos >= 0 )
+			{
+				reihenfolge.add( pos );
+				fertig[ pos ] = 1;
+			}
+			else
+				break;
+		}
+		delete[] fertig;
+		anz = reihenfolge.getEintragAnzahl();
+		for( int j = 0; j < anz; j++ )
+		{
+			int i = reihenfolge.get( j );
+			zT->addZeile( Text( "Spieler " ) += ssdgs->get( i )->spielerNummer );
+			int zNum = zT->getZeilenNummer( Text( "Spieler " ) += ssdgs->get( i )->spielerNummer );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Spielername" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgs->get( i )->spielerName ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgs->get( i )->teamName ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Spielerfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
+			( (TextFeld*)zT->zZeichnung( zT->getSpaltenNummer( "Spielerfarbe" ), zNum ) )->setHintergrundFarbe( ssdgs->get( i )->spielerFarbe );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
+			( (TextFeld*)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdgs->get( i )->teamFarbe );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden bekommen" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->schadenBekommen ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden gemacht" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->schadenGemacht ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Treibstoff verbraucht" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->treibstoffVerbraucht ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Präzision" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ( ssdgs->get( i )->treffer ? ( 100 / ( ssdgs->get( i )->schüsse / ssdgs->get( i )->treffer ) ) : 0 ) ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Punkte" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->punkte ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->kills ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->tode ) );
+			Text zeitAmLeben;
+			zeitAmLeben += ssdgs->get( i )->zeitAmLeben / 60;
+			zeitAmLeben += ":";
+			zeitAmLeben += ssdgs->get( i )->zeitAmLeben % 60;
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Zeit Am Leben" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, zeitAmLeben ) );
+			Text zeitTod;
+			zeitTod += ssdgs->get( i )->zeitTod / 60;
+			zeitTod += ":";
+			zeitTod += ssdgs->get( i )->zeitTod % 60;
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Zeit tod" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, zeitTod ) );
+		}
+		return;
+	}
+	if( zT == gesamtTeam )
+	{
+		if( !sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() ) )
+			return;
+		if( !sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() ) )
+			return;
+		Array< int > reihenfolge;
+		bool aufsteigend = sortRichtungGT->zEintragText( sortRichtungGT->getAuswahl() )->istGleich( "Aufwärts" );
+		int anz = ssdgt->getEintragAnzahl();
+		bool *fertig = new bool[ anz ];
+		ZeroMemory( fertig, anz );
+		bool teamname = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Teamname" );
+		bool teamfarbe = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Teamfarbe" );
+		bool schadenBekommen = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Schaden bekommen" );
+		bool schadenGemacht = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Schaden gemacht" );
+		bool treibstoffVerbraucht = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Treibstoff verbraucht" );
+		bool präzision = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Präzision" );
+		bool punkte = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Punkte" );
+		bool kills = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Kills" );
+		bool tode = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Tode" );
+		for( int i = 0; i < anz; i++ )
+		{
+			Text minMaxT;
+			int minMax;
+			int pos = -1;
+			for( int j = 0; j < anz; j++ )
+			{
+				if( !ssdgt->hat( j ) || fertig[ j ] )
+					continue;
+				if( teamname && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdgt->get( j )->teamName > minMaxT ) ) )
+				{ // Sortiert nach Team Name
+					minMaxT = ssdgt->get( j )->teamName.getText();
+					pos = j;
+				}
+				if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdgt->get( j )->teamFarbe > minMax ) ) )
+				{ // Sortiert nach Team Farbe
+					minMax = ssdgt->get( j )->teamFarbe;
+					pos = j;
+				}
+				if( schadenBekommen && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->schadenBekommen < minMax ) || ( !aufsteigend && ssdgt->get( j )->schadenBekommen > minMax ) ) )
+				{ // Sortiert nach Schaden bekommen
+					minMax = ssdgt->get( j )->schadenBekommen;
+					pos = j;
+				}
+				if( schadenGemacht && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->schadenGemacht < minMax ) || ( !aufsteigend && ssdgt->get( j )->schadenGemacht > minMax ) ) )
+				{ // Sortiert nach Schaden gemacht
+					minMax = ssdgt->get( j )->schadenGemacht;
+					pos = j;
+				}
+				if( treibstoffVerbraucht && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->treibstoffVerbraucht < minMax ) || ( !aufsteigend && ssdgt->get( j )->treibstoffVerbraucht > minMax ) ) )
+				{ // Sortiert nach Linienlängen
+					minMax = ssdgt->get( j )->treibstoffVerbraucht;
+					pos = j;
+				}
+				if( präzision && ( pos < 0 || ( aufsteigend && ( ssdgt->get( j )->treffer ? (int)( 100 / ( (double)ssdgt->get( j )->schüsse / ssdgt->get( j )->treffer ) ) : 0 ) < minMax ) || ( !aufsteigend && ( 100 / ( ssdgt->get( j )->schüsse / ssdgt->get( j )->treffer ) ) > minMax ) ) )
+				{ // Sortiert nach Präzision
+					minMax = (int)( 100 / ( (double)ssdgt->get( j )->schüsse / ssdgt->get( j )->treffer ) );
+					pos = j;
+				}
+				if( punkte && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->punkte < minMax ) || ( !aufsteigend && ssdgt->get( j )->punkte > minMax ) ) )
+				{ // Sortiert nach Punkten
+					minMax = ssdgt->get( j )->punkte;
+					pos = j;
+				}
+				if( kills && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->kills < minMax ) || ( !aufsteigend && ssdgt->get( j )->kills > minMax ) ) )
+				{ // Sortiert nach Kills
+					minMax = ssdgt->get( j )->kills;
+					pos = j;
+				}
+				if( tode && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->tode < minMax ) || ( !aufsteigend && ssdgt->get( j )->tode > minMax ) ) )
+				{ // Sortiert nach Toden
+					minMax = ssdgt->get( j )->tode;
+					pos = j;
+				}
+			}
+			if( pos >= 0 )
+			{
+				reihenfolge.add( pos );
+				fertig[ pos ] = 1;
+			}
+			else
+				break;
+		}
+		delete[] fertig;
+		anz = reihenfolge.getEintragAnzahl();
+		for( int j = 0; j < anz; j++ )
+		{
+			int i = reihenfolge.get( j );
+			zT->addZeile( Text( "Team " ) += ssdgt->get( i )->teamNummer );
+			int zNum = zT->getZeilenNummer( Text( "Team " ) += ssdgt->get( i )->teamNummer );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgt->get( i )->teamName ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
+			( (TextFeld*)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdgt->get( i )->teamFarbe );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden bekommen" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->schadenBekommen ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden gemacht" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->schadenGemacht ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Treibstoff verbraucht" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->treibstoffVerbraucht ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Präzision" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ( ssdgt->get( j )->treffer ? ( 100 / ( ssdgt->get( j )->schüsse / ssdgt->get( j )->treffer ) ) : 0 ) ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Punkte" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->punkte ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->kills ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->tode ) );
+		}
+		return;
+	}
+}
+
+// nicht constant
+void StatistikTabelle::doMausEreignis( MausEreignis &me )
+{
+	// Auswahl Boxen
+	int ausw = stAuswahl->getAuswahl();
+	stAuswahl->doMausEreignis( me );
+	if( ausw != stAuswahl->getAuswahl() )
+	{
+		teamS = stAuswahl->zEintragText( stAuswahl->getAuswahl() )->istGleich( "Teams" );
+		stAuswahl->einklappen();
+	}
+	if( teamS )
+	{ // Team Statistik
+		int ausw = sortAuswahlGT->getAuswahl();
+		sortAuswahlGT->doMausEreignis( me );
+		if( ausw != sortAuswahlGT->getAuswahl() )
+		{ // Sortierungs Spalte ändert sich
+			tabelleLehren( gesamtTeam, 0 );
+			tabelleFüllen( gesamtTeam );
+			sortAuswahlGT->einklappen();
+		}
+		ausw = sortRichtungGT->getAuswahl();
+		sortRichtungGT->doMausEreignis( me );
+		if( ausw != sortRichtungGT->getAuswahl() )
+		{ // Sortierungs Richtung ändert sich
+			tabelleLehren( gesamtTeam, 0 );
+			tabelleFüllen( gesamtTeam );
+			sortRichtungGT->einklappen();
+		}
+		gesamtTeam->doMausEreignis( me );
+	}
+	else
+	{ // Spieler Statistik
+		int ausw = sortAuswahlGS->getAuswahl();
+		sortAuswahlGS->doMausEreignis( me );
+		if( ausw != sortAuswahlGS->getAuswahl() )
+		{ // Sortierungs Spalte ändert sich
+			tabelleLehren( gesamtSpieler, 0 );
+			tabelleFüllen( gesamtSpieler );
+			sortAuswahlGS->einklappen();
+		}
+		ausw = sortRichtungGS->getAuswahl();
+		sortRichtungGS->doMausEreignis( me );
+		if( ausw != sortRichtungGS->getAuswahl() )
+		{ // Sortierungs Richtung ändert sich
+			tabelleLehren( gesamtSpieler, 0 );
+			tabelleFüllen( gesamtSpieler );
+			sortRichtungGS->einklappen();
+		}
+		gesamtSpieler->doMausEreignis( me );
+	}
+}
+
+bool StatistikTabelle::tick( double tickVal )
+{
+	if( teamS )
+	{ // Team Statistik
+		rend |= gesamtTeam->tick( tickVal );
+		rend |= sortAuswahlGT->tick( tickVal );
+		rend |= sortRichtungGT->tick( tickVal );
+	}
+	else
+	{ // Spieler Statistik
+		rend |= gesamtSpieler->tick( tickVal );
+		rend |= sortAuswahlGS->tick( tickVal );
+		rend |= sortRichtungGS->tick( tickVal );
+	}
+	// Auswahl Boxen
+	rend |= stAuswahl->tick( tickVal );
+	bool ret = rend;
+	rend = 0;
+	return ret;
+}
+
+void StatistikTabelle::render( Bild &zRObj )
+{
+	if( teamS )
+	{ // Team Statistik
+		gesamtTeam->render( zRObj );
+		sortAuswahlGT->render( zRObj );
+		sortRichtungGT->render( zRObj );
+	}
+	else
+	{ // Spieler Statistik
+		gesamtSpieler->render( zRObj );
+		sortAuswahlGS->render( zRObj );
+		sortRichtungGS->render( zRObj );
+	}
+	// Auswahl Boxen
+	stAuswahl->render( zRObj );
+}
+
+// Reference Counting
+StatistikTabelle *StatistikTabelle::getThis()
+{
+	ref++;
+	return this;
+}
+
+StatistikTabelle *StatistikTabelle::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/SpielStatistik/Tabelle/StatistikTabelle.h

@@ -0,0 +1,44 @@
+#ifndef StatistikTabelle_H
+#define StatistikTabelle_H
+
+#include <Tabelle.h>
+#include <AuswahlBox.h>
+#include "../SpielStatistikDaten.h"
+
+using namespace Framework;
+
+class StatistikTabelle
+{
+private:
+	Schrift *schrift;
+	Array< SSDSpieler* > *ssdgs;
+	Array< SSDTeam* > *ssdgt;
+	AuswahlBox *stAuswahl;
+	AuswahlBox *sortAuswahlGS;
+	AuswahlBox *sortAuswahlGT;
+	AuswahlBox *sortRichtungGS;
+	AuswahlBox *sortRichtungGT;
+	ObjTabelle *gesamtSpieler;
+	ObjTabelle *gesamtTeam;
+	bool teamS;
+	bool rend;
+	int ref;
+	// privat
+	void tabelleLehren( ObjTabelle *zT, bool überschrift );
+	void tabelleFüllen( ObjTabelle *zT );
+
+public:
+	// Konstruktor
+	StatistikTabelle( Array< SSDSpieler* > *ssdgs, Array< SSDTeam* > *ssdgt, Schrift *zSchrift, Bildschirm *zScreen, bool historie = 0 );
+	// Destruktor
+	~StatistikTabelle();
+	// nicht constant
+	void doMausEreignis( MausEreignis &me );
+	bool tick( double tickVal );
+	void render( Bild &zRObj );
+	// Reference Counting
+	StatistikTabelle *getThis();
+	StatistikTabelle *release();
+};
+
+#endif

Asteroids/Start/DLLStart.cpp

@@ -0,0 +1,36 @@
+#include "..\Spiel\SpielKlasse.h"
+#include "..\SpielStatistik\SpielStatistik.h"
+#include "..\HistorieStatistik\HistorieStatistik.h"
+#include "../../../../../Klient/Include/AufzeichnungV.h"
+#include "../Editor/Editor.h"
+//#include "..\Aufzeichnung\Aufzeichnung.h"
+
+extern "C"
+{ // Dll Einstiegs Funktionen
+	__declspec( dllexport ) SpielV *getSpielKlasse()
+	{
+		return new SpielKlasse();
+	}
+
+	__declspec( dllexport ) SpielStatistikV *GetStatistikKlasse()
+	{
+		return new SpielStatistik();
+	}
+
+	__declspec( dllexport ) AccountHistorieStatistikV *GetAccountHistorieStatistik()
+	{
+		return 0;
+		//return new HistorieStatistik();
+	}
+
+	__declspec( dllexport ) AufzeichnungV *GetAufzeichnung()
+	{
+		return 0;
+		//return new Aufzeichnung();
+	}
+
+	__declspec( dllexport ) EditorV *getEditor()
+	{
+		return new Editor();
+	}
+}

build.bat

@@ -0,0 +1,3 @@
+"D:\Visual Studio 2017\MSBuild\15.0\Bin\MSBuild.exe" "Asteroids.sln" /p:configuration=release /p:platform=win32
+"D:\Visual Studio 2017\MSBuild\15.0\Bin\MSBuild.exe" "Asteroids.sln" /p:configuration=release /p:platform=x64
+"D:\Visual Studio 2017\MSBuild\15.0\Bin\MSBuild.exe" "Asteroids.sln" /p:configuration=debug /p:platform=x64