Projektdateien hinzufügen.

Asteroids Linux/Asteroids Linux.vcxproj

@@ -0,0 +1,110 @@
+<?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|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{f0d57004-ad2a-4cf5-8c52-9d5036845626}</ProjectGuid>
+    <Keyword>Linux</Keyword>
+    <RootNamespace>Asteroids_Linux</RootNamespace>
+    <MinimumVisualStudioVersion>15.0</MinimumVisualStudioVersion>
+    <ApplicationType>Linux</ApplicationType>
+    <ApplicationTypeRevision>1.0</ApplicationTypeRevision>
+    <TargetLinuxPlatform>Generic</TargetLinuxPlatform>
+    <LinuxProjectType>{D51BCBC9-82E9-4017-911E-C93873C4EA2B}</LinuxProjectType>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings" />
+  <ImportGroup Label="Shared" />
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <TargetName>Asteroids</TargetName>
+    <TargetExt>.so</TargetExt>
+    <RemoteProjectDir>$(RemoteRootDir)/Spiele/Asteroids/debug</RemoteProjectDir>
+    <IncludePath>..\..\..\..\..\Allgemein\Framework;../../../Framework/debug;..\..\..\..\..\Allgemein\Network\Network;../../../Network/debug;..\Asteroids;$(IncludePath)</IncludePath>
+    <OutDir>$(ProjectDir)bin\$(Platform)\debug\</OutDir>
+    <IntDir>$(ProjectDir)obj\$(Platform)\debug\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <TargetName>Asteroids</TargetName>
+    <TargetExt>.so</TargetExt>
+    <RemoteProjectDir>$(RemoteRootDir)/Spiele/Asteroids/release</RemoteProjectDir>
+    <IncludePath>..\..\..\..\..\Allgemein\Framework;../../../Framework/debug;..\..\..\..\..\Allgemein\Network\Network;../../../Network/debug;..\Asteroids;$(IncludePath);$(ISenseIncludePath)</IncludePath>
+    <OutDir>$(ProjectDir)bin\$(Platform)\release\</OutDir>
+    <IntDir>$(ProjectDir)obj\$(Platform)\release\</IntDir>
+  </PropertyGroup>
+  <ItemGroup>
+    <ClCompile Include="..\Asteroids\Editor.cpp" />
+    <ClCompile Include="..\Asteroids\KartenLeser.cpp" />
+    <ClCompile Include="..\Asteroids\Klient.cpp" />
+    <ClCompile Include="..\Asteroids\Karte.cpp" />
+    <ClCompile Include="..\Asteroids\Strukturen.cpp" />
+    <ClCompile Include="..\Asteroids\SpielObjekt.cpp" />
+    <ClCompile Include="..\Asteroids\Laser.cpp" />
+    <ClCompile Include="..\Asteroids\Spiel.cpp" />
+    <ClCompile Include="..\Asteroids\Spieler.cpp" />
+    <ClCompile Include="..\Asteroids\STS.cpp" />
+    <ClCompile Include="..\Asteroids\Team.cpp" />
+    <ClCompile Include="..\Asteroids\DllStart.cpp" />
+    <ClCompile Include="..\Asteroids\SpielerStatistik.cpp" />
+    <ClCompile Include="..\Asteroids\Statistik.cpp" />
+    <ClCompile Include="..\Asteroids\TeamStatistik.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\Asteroids\SSDatenbankV.h" />
+    <ClInclude Include="..\Asteroids\Editor.h" />
+    <ClInclude Include="..\Asteroids\ESEditorV.h" />
+    <ClInclude Include="..\Asteroids\KartenLeser.h" />
+    <ClInclude Include="..\Asteroids\SSKlient.h" />
+    <ClInclude Include="..\Asteroids\SSKlientV.h" />
+    <ClInclude Include="..\Asteroids\Define.h" />
+    <ClInclude Include="..\Asteroids\Karte.h" />
+    <ClInclude Include="..\Asteroids\Strukturen.h" />
+    <ClInclude Include="..\Asteroids\SpielObjekt.h" />
+    <ClInclude Include="..\Asteroids\Laser.h" />
+    <ClInclude Include="..\Asteroids\Spiel.h" />
+    <ClInclude Include="..\Asteroids\Spieler.h" />
+    <ClInclude Include="..\Asteroids\SpielKlasse.h" />
+    <ClInclude Include="..\Asteroids\STS.h" />
+    <ClInclude Include="..\Asteroids\Team.h" />
+    <ClInclude Include="..\Asteroids\SpielerStatistik.h" />
+    <ClInclude Include="..\Asteroids\Statistik.h" />
+    <ClInclude Include="..\Asteroids\StatistikKlasse.h" />
+    <ClInclude Include="..\Asteroids\TeamStatistik.h" />
+  </ItemGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Link>
+      <UnresolvedSymbolReferences>false</UnresolvedSymbolReferences>
+    </Link>
+    <ClCompile>
+      <AdditionalOptions>-fPIC %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Link>
+      <UnresolvedSymbolReferences>false</UnresolvedSymbolReferences>
+    </Link>
+    <ClCompile>
+      <AdditionalOptions>-fPIC %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets" />
+</Project>

Asteroids Linux/Asteroids Linux.vcxproj.filters

@@ -0,0 +1,156 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Datenbank">
+      <UniqueIdentifier>{7492de47-4d4a-460e-b8e6-04dcfd9f6f1f}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Editor">
+      <UniqueIdentifier>{0acd8ea3-5e20-4503-8fc0-04bcab7cabac}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Leser">
+      <UniqueIdentifier>{09fdeeef-dc51-4074-8a7b-336a30de3e6c}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Netzwerk">
+      <UniqueIdentifier>{134adb2e-f094-4582-aeed-d93aba44c9dd}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel">
+      <UniqueIdentifier>{78740f0d-247d-4c65-871a-ff44688702ea}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Start">
+      <UniqueIdentifier>{9a6bee7e-f54f-47aa-b3ae-294043a9d430}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Statistik">
+      <UniqueIdentifier>{7c13f5e6-9f6a-47ed-a87d-cc37f2fefb23}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Statistik\Team">
+      <UniqueIdentifier>{8778f753-a407-4627-8950-1ac03d8eb7ed}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Statistik\Spieler">
+      <UniqueIdentifier>{f99735dd-a393-440e-9856-99d364b21225}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel\Karte">
+      <UniqueIdentifier>{6313eb2b-15b4-4861-9c09-69abb5f7a957}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel\Objekt">
+      <UniqueIdentifier>{cdf38f72-a225-4327-815d-348b35eb1755}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel\Schuss">
+      <UniqueIdentifier>{e50cbe1b-0d90-4267-a080-4f36dbf1dc0c}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel\Spieler">
+      <UniqueIdentifier>{9f3887f5-f637-4dff-a0e7-bff171d427a5}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel\Team">
+      <UniqueIdentifier>{7af58e2f-8a20-454a-a056-1e169883dc89}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\Asteroids\Editor.cpp">
+      <Filter>Editor</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\KartenLeser.cpp">
+      <Filter>Leser</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\Klient.cpp">
+      <Filter>Netzwerk</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\Statistik.cpp">
+      <Filter>Statistik</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\SpielerStatistik.cpp">
+      <Filter>Statistik\Spieler</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\TeamStatistik.cpp">
+      <Filter>Statistik\Team</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\DllStart.cpp">
+      <Filter>Start</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\Karte.cpp">
+      <Filter>Spiel\Karte</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\Strukturen.cpp">
+      <Filter>Spiel\Karte</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\SpielObjekt.cpp">
+      <Filter>Spiel\Objekt</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\Laser.cpp">
+      <Filter>Spiel\Schuss</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\Spieler.cpp">
+      <Filter>Spiel\Spieler</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\Team.cpp">
+      <Filter>Spiel\Team</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\Spiel.cpp">
+      <Filter>Spiel</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Asteroids\STS.cpp">
+      <Filter>Spiel</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\Asteroids\SSDatenbankV.h">
+      <Filter>Datenbank</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\ESEditorV.h">
+      <Filter>Editor</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\Editor.h">
+      <Filter>Editor</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\KartenLeser.h">
+      <Filter>Leser</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\SSKlient.h">
+      <Filter>Netzwerk</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\SSKlientV.h">
+      <Filter>Netzwerk</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\Statistik.h">
+      <Filter>Statistik</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\StatistikKlasse.h">
+      <Filter>Statistik</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\SpielerStatistik.h">
+      <Filter>Statistik\Spieler</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\TeamStatistik.h">
+      <Filter>Statistik\Team</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\Karte.h">
+      <Filter>Spiel\Karte</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\Strukturen.h">
+      <Filter>Spiel\Karte</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\SpielObjekt.h">
+      <Filter>Spiel\Objekt</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\Laser.h">
+      <Filter>Spiel\Schuss</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\Spieler.h">
+      <Filter>Spiel\Spieler</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\Define.h">
+      <Filter>Spiel</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\Spiel.h">
+      <Filter>Spiel</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\SpielKlasse.h">
+      <Filter>Spiel</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\STS.h">
+      <Filter>Spiel</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Asteroids\Team.h">
+      <Filter>Spiel\Team</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

Asteroids Linux/readme/readme.html

@@ -0,0 +1,85 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset='utf-8'>
+
+    <link rel="stylesheet" type="text/css" href="stylesheet.css" media="screen">
+
+    <title>Getting Started</title>
+  </head>
+
+<body>
+
+    <div class="container">
+        <div id="header">
+            <h1>Getting Started</h1>
+            <h2>Visual C++ for Linux Development extension</h2>
+        </div>
+    
+    <table>
+    <tr>    
+    <div id="main_content">
+        
+        <td>
+        <div id="lpanel">
+            <h1>Setting up your project for Linux Development</h1>
+
+            <p>With this extension you can author C++ code for Linux servers, desktops and devices. You can manage your connections to these machines from within VS. VS will automatically copy and remote build your sources and can launch your application with the debugger. Our project system supports targeting specific architectures, including ARM.</p>
+            <img src="images\ArchOptions.gif"/>
+            
+            <h1>Connecting to Linux</h1>
+            <h2>Prerequisites</h2>
+            <p>Today we only support building remotely on the Linux target machine. We are not limited by specific Linux distros but we do have dependencies on the presence of some tools. Specifically, we need openssh-server, g++, gdb and gdbserver. Use your favorite package manager to install them, e.g. on Debian based systems: sudo apt-get install openssh-server g++ gdb gdbserver</p>
+            
+            <h2>First connection</h2>
+            <p>The first time you target a Linux machine you will be prompted for connection information.  This is triggered by building the project.</p>
+            <img src="images\firstconnection.png"/>
+                
+            <h2>Adding and removing connections</h2>
+            <p>To add a new connection, go to Tools > Options and search for Linux. From here you can add and remove connections.</p>
+            <img src="images\ManageConnections.gif"/>
+            
+            <p>To change which connection a project is using go to the project properties remote settings and update the target machine.</p>
+            <img src="images\ChangeRemote.gif"/>
+            
+            <h1>Project Properties</h1>
+            <p>All of the options necessary to control C++ compilation are exposed on the project properies pages. We'll cover a few specific to how things work for Linux. First under remote settings, you will see the remote root is set to ~/projects/ by default and that we are setting the remote project directory to match our project name in that location. </p>
+            <img src="images\OutputTypes.gif"/>
+            
+            <p>Looking at the General settings for the project, you can see how our output and intermediate directories were configured. Additionally, you’ll see that this project was configured as an application – thus our executable is under bin/x64/Debug/ as ConsoleApplication1.out. Notice that for configuration types we also support static and dynamic libraries.</p>
+            
+            <p>Add additional library dependencies on the Linker > Input property page.</p>
+            <img src="images\linker.png"/>
+            
+            <p>You can pass additional pre launch commands to the debugger to do things like launch graphical apps on the remote linux machine.</p>
+            <img src="images\debuggerexport.png"/>
+            
+            <p>You can also send post build events to control remote behavior, as in this example that exports a gpio pin for use without requiring the executable run as super user.</p>
+            <img src="images\postbuild.png"/>
+            
+        </div>
+        </td>
+        <td>
+        <div id="rpanel">
+
+            <h1>Resources</h1>
+
+            <p>Check out the <a href="http://aka.ms/vslinuxext">VS Gallery VC++ for Linux Development page</a> where we will keep updates posted. You can also check out our <a href="https://blogs.msdn.microsoft.com/vcblog/2016/03/30/visual-c-for-linux-development">announcment blog post</a> for more in depth details on configuring the project properties.</p>
+            
+            <p>Here are other utilities you will find useful in connection with this extension.</p>
+            <ul>
+                <li>Learn more about <a href="http://aka.ms/vsiot">IoT Development</a></li>
+                <li><a href="http://aka.ms/vsiotext">VC++ for IoT Development Tools</a></li>
+                <li><a href="https://github.com/Azure/azure-iot-sdks">Azure IoT SDK</a>, includes a C API for connecting small devices to the Azure IoT Hub</li>
+            </ul>
+
+            <h1>Give us feedback</h1>
+            <p><a href="http://aka.ms/vslinux-feedback">UserVoice</a></p>
+        </div>
+        </td>   
+    </div>
+    </tr>
+    </table>
+    </div>
+</body>
+</html>

Asteroids Linux/readme/stylesheet.css

@@ -0,0 +1,119 @@
+body {
+  margin: 0;
+  padding: 0;
+  border: 0;
+  color: #1E1E1E;
+  font-size: 13px;
+  font-family: "Segoe UI", Helvetica, Arial, sans-serif;
+  line-height: 1.45;
+  word-wrap: break-word;
+}
+
+/* General & 'Reset' Stuff */
+
+
+.container {
+  width: 1100px;
+  margin: 0 auto;
+}
+
+section {
+  display: block;
+  margin: 0;
+}
+
+h1, h2, h3, h4, h5, h6 {
+  margin: 0;
+}
+
+table, tr {
+    width: 1100px;
+    padding: 0px;
+    vertical-align: top;
+  }
+
+/* Header, <header>
+   header   - container
+   h1       - project name
+   h2       - project description
+*/
+
+#header {
+  color: #FFF;
+  background: #68217a;
+  position:relative;
+}
+h1, h2 {
+  font-family: "Segoe UI Light", "Segoe UI", Helvetica, Arial, sans-serif;
+  line-height: 1;
+  margin: 0 18px;;
+  padding: 0;
+}
+#header h1 {
+  font-size: 3.4em;
+  padding-top: 18px;
+  font-weight: normal;
+  margin-left: 15px;
+}
+
+#header h2 {
+  font-size: 1.5em;
+  margin-top: 10px;
+  padding-bottom: 18px;
+  font-weight: normal;
+}
+
+#main_content {
+  width: 100%;
+  display: flex;
+  flex-direction: row;
+}
+
+
+h1, h2, h3, h4, h5, h6 {
+  font-weight: bolder;
+}
+
+#main_content h1 {
+  font-size: 1.8em;
+  margin-top: 34px;
+}
+
+    #main_content h1:first-child {
+        margin-top: 30px;
+    }
+
+#main_content h2 {
+  font-size: 1.8em;
+}
+p, ul {
+    margin: 11px 18px;
+}
+
+#main_content a {
+    color: #06C;
+    text-decoration: none;
+}
+ul {
+        margin-top: 13px;
+    margin-left: 18px;
+    padding-left: 0;
+}
+    ul li {
+        margin-left: 18px;
+        padding-left: 0;
+    }
+#lpanel {
+    width: 870px;
+    float: left;
+}
+#rpanel ul {
+    list-style-type: none;
+}
+    #rpanel ul li {
+        line-height: 1.8em;
+    }
+#rpanel {
+    background: #e7e7e7;
+    width: 230px;
+}

Asteroids.sln

@@ -0,0 +1,30 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.26020.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Asteroids Linux", "Asteroids Linux\Asteroids Linux.vcxproj", "{F0D57004-AD2A-4CF5-8C52-9D5036845626}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|ARM = Debug|ARM
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Release|ARM = Release|ARM
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{F0D57004-AD2A-4CF5-8C52-9D5036845626}.Debug|ARM.ActiveCfg = Debug|x64
+		{F0D57004-AD2A-4CF5-8C52-9D5036845626}.Debug|Win32.ActiveCfg = Debug|x64
+		{F0D57004-AD2A-4CF5-8C52-9D5036845626}.Debug|x64.ActiveCfg = Debug|x64
+		{F0D57004-AD2A-4CF5-8C52-9D5036845626}.Debug|x64.Build.0 = Debug|x64
+		{F0D57004-AD2A-4CF5-8C52-9D5036845626}.Release|ARM.ActiveCfg = Release|x64
+		{F0D57004-AD2A-4CF5-8C52-9D5036845626}.Release|Win32.ActiveCfg = Release|x64
+		{F0D57004-AD2A-4CF5-8C52-9D5036845626}.Release|x64.ActiveCfg = Release|x64
+		{F0D57004-AD2A-4CF5-8C52-9D5036845626}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Asteroids/Asteroids.vcxproj

@@ -0,0 +1,209 @@
+<?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>{BF881B0D-A590-4548-B4D7-5B8C22028D07}</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>Unicode</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>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\..\..\Allgemein\Framework;..\..\..\..\Klient\Include;..\..\..\..\..\Allgemein\Network\Network;$(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;$(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;$(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>
+    <CustomBuildStep>
+      <Outputs>kopieren...;%(Outputs)</Outputs>
+    </CustomBuildStep>
+  </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>
+      <Outputs>kopieren...;%(Outputs)</Outputs>
+      <Command>copy "..\x64\Debug\Asteroids.dll" "..\..\..\..\Server\Spiel Server\spiele\Asteroids\bin\Asteroids.dll"</Command>
+    </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>
+      <Outputs>kopieren...;%(Outputs)</Outputs>
+      <Command>copy "..\Release\Asteroids.dll" "..\..\..\..\Server\Fertig\x32\spiele\Asteroids\bin\Asteroids.dll"</Command>
+    </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>
+      <Outputs>kopieren...;%(Outputs)</Outputs>
+      <Command>copy "..\x64\Release\Asteroids.dll" "..\..\..\..\Server\Fertig\x64\spiele\Asteroids\bin\Asteroids.dll"</Command>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="Editor.cpp" />
+    <ClCompile Include="KartenLeser.cpp" />
+    <ClCompile Include="Klient.cpp" />
+    <ClCompile Include="Karte.cpp" />
+    <ClCompile Include="Strukturen.cpp" />
+    <ClCompile Include="SpielObjekt.cpp" />
+    <ClCompile Include="Laser.cpp" />
+    <ClCompile Include="Spiel.cpp" />
+    <ClCompile Include="Spieler.cpp" />
+    <ClCompile Include="STS.cpp" />
+    <ClCompile Include="Team.cpp" />
+    <ClCompile Include="DllStart.cpp" />
+    <ClCompile Include="SpielerStatistik.cpp" />
+    <ClCompile Include="Statistik.cpp" />
+    <ClCompile Include="TeamStatistik.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="SSDatenbankV.h" />
+    <ClInclude Include="Editor.h" />
+    <ClInclude Include="ESEditorV.h" />
+    <ClInclude Include="KartenLeser.h" />
+    <ClInclude Include="SSKlient.h" />
+    <ClInclude Include="SSKlientV.h" />
+    <ClInclude Include="Define.h" />
+    <ClInclude Include="Karte.h" />
+    <ClInclude Include="Strukturen.h" />
+    <ClInclude Include="SpielObjekt.h" />
+    <ClInclude Include="Laser.h" />
+    <ClInclude Include="Spiel.h" />
+    <ClInclude Include="Spieler.h" />
+    <ClInclude Include="SpielKlasse.h" />
+    <ClInclude Include="STS.h" />
+    <ClInclude Include="Team.h" />
+    <ClInclude Include="SpielerStatistik.h" />
+    <ClInclude Include="Statistik.h" />
+    <ClInclude Include="StatistikKlasse.h" />
+    <ClInclude Include="TeamStatistik.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

Asteroids/Asteroids.vcxproj.filters

@@ -0,0 +1,156 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Datenbank">
+      <UniqueIdentifier>{7492de47-4d4a-460e-b8e6-04dcfd9f6f1f}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Editor">
+      <UniqueIdentifier>{0acd8ea3-5e20-4503-8fc0-04bcab7cabac}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Leser">
+      <UniqueIdentifier>{09fdeeef-dc51-4074-8a7b-336a30de3e6c}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Netzwerk">
+      <UniqueIdentifier>{134adb2e-f094-4582-aeed-d93aba44c9dd}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel">
+      <UniqueIdentifier>{78740f0d-247d-4c65-871a-ff44688702ea}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Start">
+      <UniqueIdentifier>{9a6bee7e-f54f-47aa-b3ae-294043a9d430}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Statistik">
+      <UniqueIdentifier>{7c13f5e6-9f6a-47ed-a87d-cc37f2fefb23}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Statistik\Team">
+      <UniqueIdentifier>{8778f753-a407-4627-8950-1ac03d8eb7ed}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Statistik\Spieler">
+      <UniqueIdentifier>{f99735dd-a393-440e-9856-99d364b21225}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel\Karte">
+      <UniqueIdentifier>{6313eb2b-15b4-4861-9c09-69abb5f7a957}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel\Objekt">
+      <UniqueIdentifier>{cdf38f72-a225-4327-815d-348b35eb1755}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel\Schuss">
+      <UniqueIdentifier>{e50cbe1b-0d90-4267-a080-4f36dbf1dc0c}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel\Spieler">
+      <UniqueIdentifier>{9f3887f5-f637-4dff-a0e7-bff171d427a5}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel\Team">
+      <UniqueIdentifier>{7af58e2f-8a20-454a-a056-1e169883dc89}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Editor.cpp">
+      <Filter>Editor</Filter>
+    </ClCompile>
+    <ClCompile Include="KartenLeser.cpp">
+      <Filter>Leser</Filter>
+    </ClCompile>
+    <ClCompile Include="Klient.cpp">
+      <Filter>Netzwerk</Filter>
+    </ClCompile>
+    <ClCompile Include="STS.cpp">
+      <Filter>Spiel</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel.cpp">
+      <Filter>Spiel</Filter>
+    </ClCompile>
+    <ClCompile Include="DllStart.cpp">
+      <Filter>Start</Filter>
+    </ClCompile>
+    <ClCompile Include="Statistik.cpp">
+      <Filter>Statistik</Filter>
+    </ClCompile>
+    <ClCompile Include="TeamStatistik.cpp">
+      <Filter>Statistik\Team</Filter>
+    </ClCompile>
+    <ClCompile Include="SpielerStatistik.cpp">
+      <Filter>Statistik\Spieler</Filter>
+    </ClCompile>
+    <ClCompile Include="Team.cpp">
+      <Filter>Spiel\Team</Filter>
+    </ClCompile>
+    <ClCompile Include="Karte.cpp">
+      <Filter>Spiel\Karte</Filter>
+    </ClCompile>
+    <ClCompile Include="Spieler.cpp">
+      <Filter>Spiel\Spieler</Filter>
+    </ClCompile>
+    <ClCompile Include="Laser.cpp">
+      <Filter>Spiel\Schuss</Filter>
+    </ClCompile>
+    <ClCompile Include="SpielObjekt.cpp">
+      <Filter>Spiel\Objekt</Filter>
+    </ClCompile>
+    <ClCompile Include="Strukturen.cpp">
+      <Filter>Spiel\Karte</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="SSDatenbankV.h">
+      <Filter>Datenbank</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor.h">
+      <Filter>Editor</Filter>
+    </ClInclude>
+    <ClInclude Include="ESEditorV.h">
+      <Filter>Editor</Filter>
+    </ClInclude>
+    <ClInclude Include="KartenLeser.h">
+      <Filter>Leser</Filter>
+    </ClInclude>
+    <ClInclude Include="SSKlient.h">
+      <Filter>Netzwerk</Filter>
+    </ClInclude>
+    <ClInclude Include="SSKlientV.h">
+      <Filter>Netzwerk</Filter>
+    </ClInclude>
+    <ClInclude Include="Define.h">
+      <Filter>Spiel</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel.h">
+      <Filter>Spiel</Filter>
+    </ClInclude>
+    <ClInclude Include="SpielKlasse.h">
+      <Filter>Spiel</Filter>
+    </ClInclude>
+    <ClInclude Include="STS.h">
+      <Filter>Spiel</Filter>
+    </ClInclude>
+    <ClInclude Include="Statistik.h">
+      <Filter>Statistik</Filter>
+    </ClInclude>
+    <ClInclude Include="StatistikKlasse.h">
+      <Filter>Statistik</Filter>
+    </ClInclude>
+    <ClInclude Include="TeamStatistik.h">
+      <Filter>Statistik\Team</Filter>
+    </ClInclude>
+    <ClInclude Include="SpielerStatistik.h">
+      <Filter>Statistik\Spieler</Filter>
+    </ClInclude>
+    <ClInclude Include="Team.h">
+      <Filter>Spiel\Team</Filter>
+    </ClInclude>
+    <ClInclude Include="Karte.h">
+      <Filter>Spiel\Karte</Filter>
+    </ClInclude>
+    <ClInclude Include="Spieler.h">
+      <Filter>Spiel\Spieler</Filter>
+    </ClInclude>
+    <ClInclude Include="Laser.h">
+      <Filter>Spiel\Schuss</Filter>
+    </ClInclude>
+    <ClInclude Include="SpielObjekt.h">
+      <Filter>Spiel\Objekt</Filter>
+    </ClInclude>
+    <ClInclude Include="Strukturen.h">
+      <Filter>Spiel\Karte</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

Asteroids/Define.h

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

Asteroids/DllStart.cpp

@@ -0,0 +1,15 @@
+#include "Spiel.h"
+#include "Editor.h"
+
+extern "C"
+{
+	__declspec( dllexport ) Spiel *getSpielKlasse()
+	{
+		return new Spiel();
+	}
+
+    __declspec( dllexport ) Editor *getEditorKlasse()
+    {
+        return new Editor();
+    }
+}

Asteroids/ESEditorV.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <Server.h>
+#include <Thread.h>
+
+using namespace Framework;
+using namespace Network;
+
+class ESEditorV
+{
+private:
+
+public:
+    virtual ~ESEditorV()
+    {}
+    // nicht constant
+    virtual void setPfad( char *pfad ) = 0;
+    virtual void open() = 0;
+    virtual bool nachricht( SKlient *k ) = 0;
+    // constant
+    virtual char *getLetzterFehler() const = 0;
+    // Reference Counting 
+    virtual ESEditorV *getThis() = 0;
+    virtual ESEditorV *release() = 0;
+};

Asteroids/Editor.cpp

@@ -0,0 +1,748 @@
+#include "Editor.h"
+#include <Datei.h>
+#include "STS.h"
+#include "KartenLeser.h"
+#include "Strukturen.h"
+
+// Inhalt der Editor Klasse aus Editor.h
+// Konstruktor
+Editor::Editor()
+{
+    ref = 1;
+}
+
+// Destruktor
+Editor::~Editor()
+{}
+
+// nicht constant
+void Editor::setPfad( char *pfad )
+{
+    this->pfad = pfad;
+    this->pfad += "/editor";
+}
+
+void Editor::open()
+{
+
+}
+
+bool Editor::nachricht( SKlient *k )
+{
+    err = "";
+    char n = 0;
+    k->getNachrichtEncrypted( &n, 1 );
+    switch( n )
+    {
+    case 0: // Initialisierung
+        k->sendeEncrypted( "\1", 1 );
+        if( DateiExistiert( pfad ) )
+            k->sendeEncrypted( "\2", 1 );
+        else
+        {
+            if( createSitzung() )
+                k->sendeEncrypted( "\1", 1 );
+            else
+                return 0;
+        }
+        return 1;
+    case 1: // Sitzung verwerfen
+        if( createSitzung() )
+            k->sendeEncrypted( "\1", 1 );
+        else
+            return 0;
+        return 1;
+    case 2: // Sitzung speichern unt beenden
+        if( saveSitzung() )
+            k->sendeEncrypted( "\1", 1 );
+        else
+            return 0;
+        return 1;
+    case 3: // Lade Spieler Daten
+    {
+        Text tmpPf = pfad.getText();
+        tmpPf += "/player";
+        Datei d;
+        d.setDatei( tmpPf );
+        RCArray< Text > *files = d.getDateiListe();
+        if( files )
+        {
+            k->sendeEncrypted( "\1", 1 );
+            int anz = files->getEintragAnzahl();
+            k->sendeEncrypted( (char*)&anz, 4 );
+            for( int i = 0; i < anz; i++ )
+            {
+                Text pf = tmpPf;
+                pf += "/";
+                pf += files->z( i )->getText();
+                Datei player;
+                player.setDatei( pf );
+                player.open( Datei::Style::lesen );
+                SpielerStr p( player.getThis() );
+                player.close();
+                k->sendeEncrypted( (char*)&p.id, 4 );
+                k->sendeEncrypted( (char*)&p.pos.x, 4 );
+                k->sendeEncrypted( (char*)&p.pos.y, 4 );
+                k->sendeEncrypted( (char*)&p.rot, 8 );
+                k->sendeEncrypted( (char*)&p.beschleunigung, 8 );
+                k->sendeEncrypted( (char*)&p.maxStability, 4 );
+                k->sendeEncrypted( (char*)&p.maxEnergie, 4 );
+                k->sendeEncrypted( (char*)&p.reparatur, 8 );
+                k->sendeEncrypted( (char*)&p.akkuLeistung, 8 );
+                k->sendeEncrypted( (char*)&p.laserIntensity, 4 );
+                k->sendeEncrypted( (char*)&p.laserEffizienz, 4 );
+                k->sendeEncrypted( (char*)&p.laserTempo, 4 );
+                k->sendeEncrypted( (char*)&p.wendigkeit, 8 );
+                k->sendeEncrypted( (char*)&p.antriebEffizienz, 8 );
+                k->sendeEncrypted( (char*)&p.netzwerk, 4 );
+                k->sendeEncrypted( (char*)&p.skillPunkte, 4 );
+                k->sendeEncrypted( (char*)&p.m2d, 4 );
+                k->sendeEncrypted( (char*)&p.bild, 4 );
+            }
+        }
+        else
+        {
+            err = "Fehler beim laden von ";
+            err += tmpPf.getText();
+            return 0;
+        }
+        return 1;
+    }
+    case 4: // Lade Team Daten
+    {
+        Text tmpPf = pfad.getText();
+        tmpPf += "/team";
+        Datei d;
+        d.setDatei( tmpPf );
+        RCArray< Text > *files = d.getDateiListe();
+        if( files )
+        {
+            k->sendeEncrypted( "\1", 1 );
+            int anz = files->getEintragAnzahl();
+            k->sendeEncrypted( (char*)&anz, 4 );
+            for( int i = 0; i < anz; i++ )
+            {
+                Text pf = tmpPf;
+                pf += "/";
+                pf += files->z( i )->getText();
+                Datei team;
+                team.setDatei( pf );
+                team.open( Datei::Style::lesen );
+                TeamStr t( team.getThis() );
+                team.close();
+                k->sendeEncrypted( (char*)&t.id, 4 );
+                k->sendeEncrypted( (char*)&t.maxPunkte, 4 );
+                k->sendeEncrypted( (char*)&t.beschleunigung, 8 );
+                k->sendeEncrypted( (char*)&t.maxStability, 4 );
+                k->sendeEncrypted( (char*)&t.maxEnergie, 4 );
+                k->sendeEncrypted( (char*)&t.reparatur, 8 );
+                k->sendeEncrypted( (char*)&t.akkuLeistung, 8 );
+                k->sendeEncrypted( (char*)&t.laserIntensity, 4 );
+                k->sendeEncrypted( (char*)&t.laserEffizienz, 4 );
+                k->sendeEncrypted( (char*)&t.laserTempo, 4 );
+                k->sendeEncrypted( (char*)&t.wendigkeit, 8 );
+                k->sendeEncrypted( (char*)&t.antriebEffizienz, 8 );
+                k->sendeEncrypted( (char*)&t.punkte, 4 );
+            }
+        }
+        else
+        {
+            err = "Fehler beim laden von ";
+            err += tmpPf.getText();
+            return 0;
+        }
+        return 1;
+    }
+    case 5: // Lade Objekt Daten
+    {
+        Text tmpPf = pfad.getText();
+        tmpPf += "/object";
+        Datei d;
+        d.setDatei( tmpPf );
+        RCArray< Text > *files = d.getDateiListe();
+        if( files )
+        {
+            k->sendeEncrypted( "\1", 1 );
+            int anz = files->getEintragAnzahl();
+            k->sendeEncrypted( (char*)&anz, 4 );
+            for( int i = 0; i < anz; i++ )
+            {
+                Text pf = tmpPf;
+                pf += "/";
+                pf += files->z( i )->getText();
+                Datei object;
+                object.setDatei( pf );
+                object.open( Datei::Style::lesen );
+                ObjektStr o( object.getThis() );
+                object.close();
+                k->sendeEncrypted( (char*)&o.pos.x, 4 );
+                k->sendeEncrypted( (char*)&o.pos.y, 4 );
+                k->sendeEncrypted( (char*)&o.id, 4 );
+                k->sendeEncrypted( (char*)&o.m2d, 4 );
+                k->sendeEncrypted( (char*)&o.bild, 4 );
+                k->sendeEncrypted( (char*)&o.style, 4 );
+                k->sendeEncrypted( (char*)&o.maxStability, 4 );
+                k->sendeEncrypted( (char*)&o.maxEnergie, 4 );
+                k->sendeEncrypted( (char*)&o.energieRadius, 4 );
+                k->sendeEncrypted( (char*)&o.reparatur, 8 );
+                k->sendeEncrypted( (char*)&o.akkuLeistung, 8 );
+                k->sendeEncrypted( (char*)&o.team, 1 );
+            }
+        }
+        else
+        {
+            err = "Fehler beim laden von ";
+            err += tmpPf.getText();
+            return 0;
+        }
+        return 1;
+    }
+    case 6: // Save Player
+    {
+        k->sendeEncrypted( "\1", 1 );
+        SpielerStr p( 0 );
+        k->getNachrichtEncrypted( (char*)&p.id, 4 );
+        k->getNachrichtEncrypted( (char*)&p.pos.x, 4 );
+        k->getNachrichtEncrypted( (char*)&p.pos.y, 4 );
+        k->getNachrichtEncrypted( (char*)&p.rot, 8 );
+        k->getNachrichtEncrypted( (char*)&p.beschleunigung, 8 );
+        k->getNachrichtEncrypted( (char*)&p.maxStability, 4 );
+        k->getNachrichtEncrypted( (char*)&p.maxEnergie, 4 );
+        k->getNachrichtEncrypted( (char*)&p.reparatur, 8 );
+        k->getNachrichtEncrypted( (char*)&p.akkuLeistung, 8 );
+        k->getNachrichtEncrypted( (char*)&p.laserIntensity, 4 );
+        k->getNachrichtEncrypted( (char*)&p.laserEffizienz, 4 );
+        k->getNachrichtEncrypted( (char*)&p.laserTempo, 4 );
+        k->getNachrichtEncrypted( (char*)&p.wendigkeit, 8 );
+        k->getNachrichtEncrypted( (char*)&p.antriebEffizienz, 8 );
+        k->getNachrichtEncrypted( (char*)&p.netzwerk, 4 );
+        k->getNachrichtEncrypted( (char*)&p.skillPunkte, 4 );
+        k->getNachrichtEncrypted( (char*)&p.m2d, 4 );
+        k->getNachrichtEncrypted( (char*)&p.bild, 4 );
+        Text pf = pfad.getText();
+        pf += "/player/";
+        pf += p.id;
+        pf += ".p";
+        Datei player;
+        player.setDatei( pf );
+        if( player.open( Datei::Style::schreiben ) )
+        {
+            p.save( player.getThis() );
+            player.close();
+            k->sendeEncrypted( "\1", 1 );
+            return 1;
+        }
+        err = "Fehler beim Schreiben von ";
+        err += pf.getText();
+        return 0;
+    }
+    case 7: // Save Team
+    {
+        k->sendeEncrypted( "\1", 1 );
+        TeamStr t( 0 );
+        k->getNachrichtEncrypted( (char*)&t.id, 4 );
+        k->getNachrichtEncrypted( (char*)&t.maxPunkte, 4 );
+        k->getNachrichtEncrypted( (char*)&t.beschleunigung, 8 );
+        k->getNachrichtEncrypted( (char*)&t.maxStability, 4 );
+        k->getNachrichtEncrypted( (char*)&t.maxEnergie, 4 );
+        k->getNachrichtEncrypted( (char*)&t.reparatur, 8 );
+        k->getNachrichtEncrypted( (char*)&t.akkuLeistung, 8 );
+        k->getNachrichtEncrypted( (char*)&t.laserIntensity, 4 );
+        k->getNachrichtEncrypted( (char*)&t.laserEffizienz, 4 );
+        k->getNachrichtEncrypted( (char*)&t.laserTempo, 4 );
+        k->getNachrichtEncrypted( (char*)&t.wendigkeit, 8 );
+        k->getNachrichtEncrypted( (char*)&t.antriebEffizienz, 8 );
+        k->getNachrichtEncrypted( (char*)&t.punkte, 4 );
+        Text pf = pfad.getText();
+        pf += "/player/";
+        pf += t.id;
+        pf += ".t";
+        Datei team;
+        team.setDatei( pf );
+        if( team.open( Datei::Style::schreiben ) )
+        {
+            t.save( team.getThis() );
+            team.close();
+            k->sendeEncrypted( "\1", 1 );
+            return 1;
+        }
+        err = "Fehler beim Schreiben von ";
+        err += pf.getText();
+        return 0;
+    }
+    case 8: // Save Objekt
+    {
+        k->sendeEncrypted( "\1", 1 );
+        ObjektStr o( 0 );
+        k->sendeEncrypted( (char*)&o.pos.x, 4 );
+        k->sendeEncrypted( (char*)&o.pos.y, 4 );
+        k->sendeEncrypted( (char*)&o.id, 4 );
+        k->sendeEncrypted( (char*)&o.m2d, 4 );
+        k->sendeEncrypted( (char*)&o.bild, 4 );
+        k->sendeEncrypted( (char*)&o.style, 4 );
+        k->sendeEncrypted( (char*)&o.maxStability, 4 );
+        k->sendeEncrypted( (char*)&o.maxEnergie, 4 );
+        k->sendeEncrypted( (char*)&o.energieRadius, 4 );
+        k->sendeEncrypted( (char*)&o.reparatur, 8 );
+        k->sendeEncrypted( (char*)&o.akkuLeistung, 8 );
+        k->sendeEncrypted( (char*)&o.team, 1 );
+        Text pf = pfad.getText();
+        pf += "/objekt/";
+        pf += o.id;
+        pf += ".o";
+        Datei objekt;
+        objekt.setDatei( pf );
+        if( objekt.erstellen() && objekt.open( Datei::Style::schreiben ) )
+        {
+            o.save( objekt.getThis() );
+            objekt.close();
+            k->sendeEncrypted( "\1", 1 );
+            return 1;
+        }
+        err = "Fehler beim Schreiben von ";
+        err += pf.getText();
+        return 0;
+    }
+    case 9: // Delete Objekt
+    {
+        k->sendeEncrypted( "\1", 1 );
+        int id;
+        k->sendeEncrypted( (char*)&id, 4 );
+        Text pf = pfad.getText();
+        pf += "/objekt/";
+        pf += id;
+        pf += ".o";
+        if( DateiRemove( pf ) )
+        {
+            k->sendeEncrypted( "\1", 1 );
+            return 1;
+        }
+        err = "Fehler beim löschen der Datei ";
+        err += pf;
+        return 0;
+    }
+    default:
+        err = "Unbekannte Nachricht. Error Code: " __FILE__ ":";
+        err += __LINE__;
+        return 0;
+    }
+    return 0;
+}
+
+// constant
+char *Editor::getLetzterFehler() const
+{
+    return err;
+}
+
+// Reference Counting 
+ESEditorV *Editor::getThis()
+{
+    ref++;
+    return this;
+}
+
+ESEditorV *Editor::release()
+{
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
+}
+
+// privat
+bool Editor::createSitzung()
+{
+    DateiRemove( pfad );
+    Text pf = pfad.getText();
+    pf.remove( pf.getLength() - 6, pf.getLength() );
+    pf += "map/server/data.map";
+    Datei d;
+    d.setDatei( pf.getText() );
+    if( d.open( Datei::Style::lesen ) )
+    {
+        pf = pfad.getText();
+        pf += "/resource/";
+        int rAnz = 0;
+        d.lese( (char*)&rAnz, 4 );
+        for( int i = 0; i < rAnz; i++ )
+        {
+            int id = 0;
+            d.lese( (char*)&id, 4 );
+            Text tmpPf = pf.getText();
+            tmpPf += id;
+            tmpPf += ".r";
+            char len = 0;
+            d.lese( &len, 1 );
+            char *path = new char[ len + 1 ];
+            path[ (int)len ] = 0;
+            d.lese( path, len );
+            Datei r;
+            r.setDatei( tmpPf );
+            r.erstellen();
+            if( !r.open( Datei::Style::schreiben ) )
+            {
+                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
+                err += tmpPf;
+                err += ". Fehler Code: " __FILE__ ":";
+                err += __LINE__;
+                err += "\n";
+            }
+            r.schreibe( &len, 1 );
+            r.schreibe( path, len );
+            r.close();
+            delete[] path;
+        }
+        pf = pfad.getText();
+        pf += "/size";
+        Datei s;
+        s.setDatei( pf.getText() );
+        if( !s.open( Datei::Style::schreiben ) )
+        {
+            err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
+            err += pf;
+            err += ". Fehler Code: " __FILE__ ":";
+            err += __LINE__;
+            err += "\n";
+        }
+        __int64 size = 0;
+        d.lese( (char*)&size, 8 );
+        s.schreibe( (char*)&size, 8 );
+        s.close();
+        int objAnz = 0;
+        d.lese( (char*)&objAnz, 4 );
+        for( int i = 0; i < objAnz; i++ )
+        {
+            ObjektStr objStr( &d );
+            Text tmpPf = pfad.getText();
+            tmpPf += "/object/";
+            tmpPf += objStr.id;
+            tmpPf += ".o";
+            Datei obj;
+            obj.setDatei( tmpPf.getText() );
+            obj.erstellen();
+            if( !obj.open( Datei::Style::schreiben ) )
+            {
+                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+                err += tmpPf;
+                err += ". Fehler Code: " __FILE__ ":";
+                err += __LINE__;
+                err += "\n";
+            }
+            objStr.save( &obj );
+            obj.close();
+        }
+        SpielerTeamStruktur *sts = new SpielerTeamStruktur();
+        Text tmp = pfad.getText();
+        pf.remove( pf.getLength() - 12, pf.getLength() );
+        tmp.remove( 0, tmp.positionVon( '/', tmp.anzahlVon( '/' ) ) );
+        int kartenId = tmp;
+        tmp = pfad.getText();
+        tmp.remove( tmp.getLength() - 6, tmp.getLength() );
+        tmp += "map/server/";
+        KartenLeser *stsReader = new KartenLeser( kartenId, 0, tmp );
+        stsReader->ladeSpielerTeamStruktur( sts );
+        stsReader->release();
+        for( int i = 0; i < sts->spielerAnzahl; i++ )
+        {
+            SpielerStr spStr( &d );
+            Text tmpPf = pfad.getText();
+            tmpPf += "/player/";
+            tmpPf += spStr.id;
+            tmpPf += ".p";
+            Datei pl;
+            pl.setDatei( tmpPf.getText() );
+            pl.erstellen();
+            if( !pl.open( Datei::Style::schreiben ) )
+            {
+                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+                err += tmpPf;
+                err += ". Fehler Code: " __FILE__ ":";
+                err += __LINE__;
+                err += "\n";
+            }
+            spStr.save( &pl );
+            pl.close();
+        }
+        for( int i = 0; i < sts->teamAnzahl; i++ )
+        {
+            TeamStr tStr( &d );
+            Text tmpPf = pfad.getText();
+            tmpPf += "/team/";
+            tmpPf += tStr.id;
+            tmpPf += ".t";
+            Datei pl;
+            pl.setDatei( tmpPf.getText() );
+            pl.erstellen();
+            if( !pl.open( Datei::Style::schreiben ) )
+            {
+                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+                err += tmpPf;
+                err += ". Fehler Code: " __FILE__ ":";
+                err += __LINE__;
+                err += "\n";
+            }
+            tStr.save( &pl );
+            pl.close();
+        }
+        sts->release();
+        d.close();
+    }
+    else
+    {
+        err = "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
+        err += pf;
+        err += ". Fehler Code: " __FILE__ ":";
+        err += __LINE__;
+        pf = pfad.getText();
+        pf += "/empty.file";
+        DateiPfadErstellen( pf );
+        DateiRemove( pf );
+    }
+    if( !err.getLength() )
+        return 1;
+    else
+        return 0;
+}
+
+bool Editor::saveSitzung()
+{
+    Text pf = pfad.getText();
+    pf.remove( pf.getLength() - 6, pf.getLength() );
+    pf += "map/server/data_tmp.map";
+    Datei d;
+    d.setDatei( pf.getText() );
+    if( d.open( Datei::Style::schreiben ) )
+    {
+        pf = pfad.getText();
+        pf += "/resource";
+        Datei res;
+        res.setDatei( pf );
+        RCArray<Text> *resList = res.getDateiListe();
+        if( resList )
+        {
+            int anz = resList->getEintragAnzahl();
+            d.schreibe( (char*)&anz, 4 );
+            for( auto resPf = resList->getArray(); resPf.set && resPf.var; resPf++ )
+            {
+                Text tmp = pf.getText();
+                tmp += "/";
+                tmp += resPf.var->getText();
+                Datei r;
+                r.setDatei( tmp );
+                if( r.open( Datei::Style::lesen ) )
+                {
+                    int id = (int)*resPf.var;
+                    d.schreibe( (char*)&id, 4 );
+                    char b = 0;
+                    r.lese( &b, 1 );
+                    char *buffer = new char[ b + 1 ];
+                    buffer[ (int)b ] = 0;
+                    r.lese( buffer, b );
+                    d.schreibe( &b, 1 );
+                    d.schreibe( buffer, b );
+                    r.close();
+                }
+                else
+                {
+                    err = "Fehler beim Lesen von ";
+                    err += tmp.getText();
+                    err += ". Fehler Code: " __FILE__ ":";
+                    err += __LINE__;
+                    d.close();
+                    d.remove();
+                    resList->release();
+                    return 0;
+                }
+            }
+            resList->release();
+        }
+        else
+            d.schreibe( "\0\0\0\0", 4 );
+        pf = pfad.getText();
+        pf += "/size";
+        Datei s;
+        s.setDatei( pf.getText() );
+        if( s.open( Datei::Style::lesen ) )
+        {
+            __int64 size = 0;
+            s.lese( (char*)&size, 8 );
+            d.schreibe( (char*)&size, 8 );
+            s.close();
+        }
+        else
+        {
+            err = "Fehler beim Lesen von ";
+            err += pf.getText();
+            err = ". Fehler Code: " __FILE__ ":";
+            err += __LINE__;
+            d.close();
+            d.remove();
+            return 0;
+        }
+        pf = pfad.getText();
+        pf += "/object";
+        Datei obj;
+        obj.setDatei( pf );
+        RCArray<Text> *objList = obj.getDateiListe();
+        if( objList )
+        {
+            int anz = objList->getEintragAnzahl();
+            d.schreibe( (char*)&anz, 4 );
+            for( auto objPf = objList->getArray(); objPf.set && objPf.var; objPf++ )
+            {
+                Text tmp = pf.getText();
+                tmp += "/";
+                tmp += objPf.var->getText();
+                Datei r;
+                r.setDatei( tmp );
+                if( r.open( Datei::Style::lesen ) )
+                {
+                    ObjektStr objStr( &r );
+                    objStr.save( &d );
+                    r.close();
+                }
+                else
+                {
+                    err = "Fehler beim Lesen von ";
+                    err += tmp.getText();
+                    err = ". Fehler Code: " __FILE__ ":";
+                    err += __LINE__;
+                    d.close();
+                    d.remove();
+                    objList->release();
+                    return 0;
+                }
+            }
+            objList->release();
+        }
+        else
+            d.schreibe( "\0\0\0\0", 4 );
+        pf = pfad.getText();
+        pf += "/player";
+        Datei pl;
+        pl.setDatei( pf );
+        RCArray<Text> *plList = pl.getDateiListe();
+        if( !plList )
+        {
+            err = "Fehler beim Lesen von ";
+            err += pf.getText();
+            err = ". Fehler Code: " __FILE__ ":";
+            err += __LINE__;
+            d.close();
+            d.remove();
+            return 0;
+        }
+        for( auto plPf = plList->getArray(); plPf.set && plPf.var; plPf++ )
+        {
+            Text tmp = pf.getText();
+            tmp += "/";
+            tmp += plPf.var->getText();
+            Datei r;
+            r.setDatei( tmp );
+            if( r.open( Datei::Style::lesen ) )
+            {
+                SpielerStr spStr( &r );
+                spStr.save( &d );
+                r.close();
+            }
+            else
+            {
+                err = "Fehler beim Lesen von ";
+                err += tmp.getText();
+                err = ". Fehler Code: " __FILE__ ":";
+                err += __LINE__;
+                d.close();
+                d.remove();
+                plList->release();
+                return 0;
+            }
+        }
+        plList->release();
+        pf = pfad.getText();
+        pf += "/team";
+        Datei tm;
+        tm.setDatei( pf );
+        RCArray<Text> *tmList = tm.getDateiListe();
+        if( !tmList )
+        {
+            err = "Fehler beim Lesen von ";
+            err += pf.getText();
+            err = ". Fehler Code: " __FILE__ ":";
+            err += __LINE__;
+            d.close();
+            d.remove();
+            return 0;
+        }
+        for( auto tmPf = tmList->getArray(); tmPf.set && tmPf.var; tmPf++ )
+        {
+            Text tmp = pf.getText();
+            tmp += "/";
+            tmp += tmPf.var->getText();
+            Datei r;
+            r.setDatei( tmp );
+            if( r.open( Datei::Style::lesen ) )
+            {
+                TeamStr tStr( &r );
+                tStr.save( &d );
+                r.close();
+            }
+            else
+            {
+                err = "Fehler beim Lesen von ";
+                err += tmp.getText();
+                err = ". Fehler Code: " __FILE__ ":";
+                err += __LINE__;
+                d.close();
+                d.remove();
+                tmList->release();
+                return 0;
+            }
+        }
+        tmList->release();
+        pf = pfad.getText();
+        pf.remove( pf.getLength() - 6, pf.getLength() );
+        pf += "map/server/data.map";
+        d.close();
+        if( !DateiRemove( pf ) || !d.umbenennen( pf ) )
+        {
+            err = "Fehler beim Übernehmen der Änderungen. Fehler Code: " __FILE__ ":";
+            err += __LINE__;
+            return 0;
+        }
+    }
+    else
+    {
+        err = "Fehler beim Speichern der Änderungen (Server). Fehler Code: " __FILE__ ":";
+        err += __LINE__;
+        return 0;
+    }
+    pf = pfad.getText();
+    pf.remove( pf.getLength() - 6, pf.getLength() );
+    pf += "map/client/map/data/data.map";
+    Datei d2;
+    d2.setDatei( pf.getText() );
+    if( d2.open( Datei::Style::schreiben ) && d.open( Datei::Style::lesen ) )
+    {
+        __int64 size = d.getSize();
+        char *buffer = new char[ 2048 ];
+        while( size > 0 )
+        {
+            int len = (int)( size > 2048 ? 2048 : size );
+            d.lese( buffer, len );
+            d2.schreibe( buffer, len );
+            size -= len;
+        }
+        delete[] buffer;
+        d.close();
+        d2.close();
+    }
+    else
+    {
+        err = "Fehler beim Speichern der Änderungen (Client). Fehler Code: " __FILE__ ":";
+        err += __LINE__;
+        return 0;
+    }
+    DateiRemove( pfad.getText() );
+    return 1;
+}

Asteroids/Editor.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "ESEditorV.h"
+#include <Text.h>
+
+using namespace Framework;
+
+
+class Editor : public ESEditorV
+{
+private:
+    Text pfad;
+    Text err;
+    int ref;
+
+public:
+    // Konstruktor
+    Editor();
+    // Destruktor
+    ~Editor();
+    // nicht constant
+    void setPfad( char *pfad ) override;
+    void open() override;
+    bool nachricht( SKlient *k ) override;
+    // constant
+    char *getLetzterFehler() const override;
+    // Reference Counting 
+    ESEditorV *getThis() override;
+    ESEditorV *release() override;
+
+private:
+    bool createSitzung();
+    bool saveSitzung();
+};

Asteroids/Karte.cpp

@@ -0,0 +1,133 @@
+#include "Karte.h"
+
+// Inhalt der Karte Klasse aus Karte.h
+// Konstruktor
+Karte::Karte()
+{
+	size = Vec2< int >( 0, 0 );
+	ressources = new RCArray< RessourceStr >();
+	objekte = new RCArray< ObjektStr >();
+	spieler = new RCArray< SpielerStr >();
+	teams = new RCArray< TeamStr >();
+	sts = 0;
+	ref = 1;
+}
+
+// Destruktor
+Karte::~Karte()
+{
+	ressources->release();
+	objekte->release();
+	spieler->release();
+	teams->release();
+	if( sts )
+		sts->release();
+}
+
+// nicht constant
+void Karte::ladeDaten( Datei *zDatei, SSDatenbankV *zDb, SpielerTeamStruktur *zSts, char *tmpPfad, int kId )
+{
+	sts = zSts->getThis();
+	int ressourceAnz = 0;
+	zDatei->lese( (char*)&ressourceAnz, 4 );
+	for( int i = 0; i < ressourceAnz; i++ )
+        ressources->add( new RessourceStr( zDatei, zDb, tmpPfad, kId ) );
+	zDatei->lese( (char*)&size.x, 4 );
+	zDatei->lese( (char*)&size.y, 4 );
+	int objektAnzahl = 0;
+	zDatei->lese( (char*)&objektAnzahl, 4 );
+	for( int i = 0; i < objektAnzahl; i++ )
+		objekte->add( new ObjektStr( zDatei ) );
+	for( int i = 0; i < zSts->spielerAnzahl; i++ )
+		spieler->add( new SpielerStr( zDatei ) );
+	for( int i = 0; i < zSts->teamAnzahl; i++ )
+		teams->add( new TeamStr( zDatei ) );
+}
+
+// constant
+Vec2< int > Karte::getSize() const
+{
+	return size;
+}
+
+Spieler *Karte::createSpieler( int sNum ) const
+{
+	if( !sts || sNum < 0 || sNum >= sts->spielerAnzahl )
+		return 0;
+    for( auto s = spieler->getArray(); s.set; s++ )
+    {
+        if( s.var->id == sNum + 1 )
+        {
+            Spieler *ret = new Spieler( s.var );
+            for( auto i = &ressources->getArray(); i && i->set && i->var; i = i->next )
+            {
+                if( i->var->getId() == s.var->m2d )
+                    ret->setModelData( i->var->zReccourceM2()->getThis() );
+            }
+            ret->setSpielerFarbe( sts->spielerFarbe->hat( sNum ) ? sts->spielerFarbe->get( sNum ) : 0 );
+            return ret;
+        }
+    }
+    return 0;
+}
+
+Team *Karte::createTeam( int tNum ) const
+{
+	if( !sts || tNum < 0 || tNum >= sts->teamAnzahl )
+		return 0;
+    Team *ret = 0;
+    for( auto t = teams->getArray(); t.set; t++ )
+        if( t.var->id == tNum + 1 )
+            ret = new Team( sts->teamFarbe->get( tNum ), sts->teamName->z( tNum )->getText(), t.var );
+	return ret;
+}
+
+SpielObjekt *Karte::createObjekt( int oNum ) const
+{
+	if( oNum < 0 || oNum > objekte->getEintragAnzahl() )
+		return 0;
+    for( auto o = objekte->getArray(); o.set; o++ )
+    {
+        if( o.var->id == oNum + 1 )
+        {
+            SpielObjekt *ret = new SpielObjekt( o.var );
+            for( auto i = &ressources->getArray(); i && i->set && i->var; i = i->next )
+            {
+                if( i->var->getId() == o.var->m2d )
+                    ret->setModelData( i->var->zReccourceM2()->getThis() );
+            }
+            return ret;
+        }
+    }
+    return 0;
+}
+
+int Karte::getMaxTeamAnzahl() const
+{
+	return sts ? sts->teamAnzahl : 0;
+}
+
+int Karte::getMaxSpielerAnzahl() const
+{
+	return sts ? sts->spielerAnzahl : 0;
+}
+
+int Karte::getObjektAnzahl() const
+{
+	return objekte->getEintragAnzahl();
+}
+
+// Reference Counting
+Karte *Karte::getThis()
+{
+	ref++;
+	return this;
+}
+
+Karte *Karte::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Karte.h

@@ -0,0 +1,43 @@
+#ifndef Karte_H
+#define Karte_H
+
+#include <Datei.h>
+#include <Vec2.h>
+#include "STS.h"
+#include "Team.h"
+#include "SpielObjekt.h"
+
+using namespace Framework;
+
+class Karte
+{
+private:
+	Vec2< int > size;
+	RCArray< RessourceStr > *ressources;
+	RCArray< ObjektStr > *objekte;
+	RCArray< SpielerStr > *spieler;
+	RCArray< TeamStr > *teams;
+	SpielerTeamStruktur *sts;
+	int ref;
+
+public:
+	// Konstruktor
+	Karte();
+	// Destruktor
+	~Karte();
+	// nicht constant
+    void ladeDaten( Datei *zDatei, SSDatenbankV *zDb, SpielerTeamStruktur *zSts, char *tmpPfad, int kId );
+	// constant
+	Vec2< int > getSize() const;
+	Spieler *createSpieler( int sNum ) const;
+	Team *createTeam( int tNum ) const;
+	SpielObjekt *createObjekt( int oNum ) const;
+	int getMaxTeamAnzahl() const;
+	int getMaxSpielerAnzahl() const;
+	int getObjektAnzahl() const;
+	// Reference Counting
+	Karte *getThis();
+	Karte *release();
+};
+
+#endif

Asteroids/KartenLeser.cpp

@@ -0,0 +1,137 @@
+#include "KartenLeser.h"
+#include <Datei.h>
+#include "Karte.h"
+
+// Inhalt der KartenLeser Klasse aus KartenLeser.h
+// Kontruktor
+KartenLeser::KartenLeser( int karteId, SSDatenbankV *db, char *tmpPfad )
+{
+    this->karteId = karteId;
+    this->db = db;
+    pfad = new Text( tmpPfad );
+    ref = 1;
+}
+
+// Destruktor
+KartenLeser::~KartenLeser()
+{
+    if( db )
+        db->release();
+    if( pfad )
+        pfad->release();
+}
+
+// nicht constant
+bool KartenLeser::ladeSpielerTeamStruktur( SpielerTeamStruktur *zSts )
+{
+    if( !pfad )
+        return 0;
+    Text *pf = new Text( pfad->getText() );
+    pf->append( "sts.ltgd" );
+    Datei *datei = new Datei();
+    datei->setDatei( pf );
+    if( !datei->existiert() || datei->istOrdner() )
+    {
+        datei->release();
+        return 0;
+    }
+    datei->open( Datei::Style::lesen );
+    datei->lese( (char*)&zSts->spielerAnzahl, 4 );
+    datei->lese( (char*)&zSts->teamAnzahl, 4 );
+    if( zSts->spielerFarbe )
+        zSts->spielerFarbe->release();
+    zSts->spielerFarbe = new Array< int >();
+    for( int i = 0; i < zSts->spielerAnzahl; i++ )
+    {
+        int farbe = 0;
+        datei->lese( (char*)&farbe, 4 );
+        zSts->spielerFarbe->set( farbe, i );
+    }
+    if( zSts->teamFarbe )
+        zSts->teamFarbe->release();
+    zSts->teamFarbe = new Array< int >();
+    for( int i = 0; i < zSts->teamAnzahl; i++ )
+    {
+        int farbe = 0;
+        datei->lese( (char*)&farbe, 4 );
+        zSts->teamFarbe->set( farbe, i );
+    }
+    if( zSts->teamName )
+        zSts->teamName->release();
+    zSts->teamName = new RCArray< Text >();
+    for( int i = 0; i < zSts->teamAnzahl; i++ )
+    {
+        char len = 0;
+        datei->lese( &len, 1 );
+        char *txt = new char[ len + 1 ];
+        txt[ (int)len ] = 0;
+        datei->lese( txt, len );
+        Text *name = new Text( txt );
+        delete[] txt;
+        zSts->teamName->set( name, i );
+    }
+    if( zSts->teamSize )
+        zSts->teamSize->release();
+    zSts->teamSize = new Array< int >();
+    for( int i = 0; i < zSts->teamAnzahl; i++ )
+    {
+        int size = 0;
+        datei->lese( (char*)&size, 4 );
+        zSts->teamSize->set( size, i );
+    }
+    datei->close();
+    datei->release();
+    return 1;
+}
+
+Karte *KartenLeser::ladeKarte( SpielerTeamStruktur *zSts )
+{
+    if( !pfad )
+        return 0;
+    Text *pf = new Text( pfad->getText() );
+    pf->append( "data.map" );
+    Datei *datei = new Datei();
+    datei->setDatei( pf );
+    if( !datei->existiert() || datei->istOrdner() )
+    {
+        datei->release();
+        return 0;
+    }
+    datei->open( Datei::Style::lesen );
+    Karte *ret = new Karte();
+    ret->ladeDaten( datei, db, zSts, pfad->getText(), karteId );
+    datei->close();
+    datei->release();
+    return ret;
+}
+
+// constant
+int KartenLeser::getKarteId() const
+{
+    return karteId;
+}
+
+Text *KartenLeser::getPfad() const
+{
+    return pfad ? pfad->getThis() : 0;
+}
+
+Text *KartenLeser::zPfad() const
+{
+    return pfad;
+}
+
+// Reference Counting
+KartenLeser *KartenLeser::getThis()
+{
+    ref++;
+    return this;
+}
+
+KartenLeser *KartenLeser::release()
+{
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
+}

Asteroids/KartenLeser.h

@@ -0,0 +1,34 @@
+#ifndef KartenLeser_H
+#define KartenLeser_H
+
+#include "SSDatenbankV.h"
+#include "STS.h"
+
+class Karte;
+
+class KartenLeser
+{
+private:
+	SSDatenbankV *db;
+	Text *pfad;
+	int karteId;
+	int ref;
+
+public:
+	// Kontruktor
+    KartenLeser( int karteId, SSDatenbankV *db, char *tmpPfad );
+	// Destruktor
+	~KartenLeser();
+	// nicht constant
+	bool ladeSpielerTeamStruktur( SpielerTeamStruktur *zSts );
+	Karte *ladeKarte( SpielerTeamStruktur *zSts );
+	// constant
+	int getKarteId() const;
+	Text *getPfad() const;
+	Text *zPfad() const;
+	// Reference Counting
+	KartenLeser *getThis();
+	KartenLeser *release();
+};
+
+#endif

Asteroids/Klient.cpp

@@ -0,0 +1,300 @@
+#include "Spieler.h"
+#include "SSKlient.h"
+#include <Text.h>
+
+// Inhalt der Klient Klasse aus Klient.h
+// Konstruktor
+Klient::Klient( SSKlientV *klient )
+{
+	this->klient = klient;
+	ref = 1;
+}
+
+// Destruktor
+Klient::~Klient()
+{
+	if( klient )
+		klient->release();
+}
+
+// nicht constant
+void Klient::offline()
+{
+	klient = klient->release();
+}
+
+void Klient::online( SSKlientV *zKlient )
+{
+	if( klient )
+		klient = klient->release();
+	klient = zKlient->getThis();
+}
+
+void Klient::sendeInit( RCArray< Spieler > *zSpieler, int spielZeit )
+{
+	if( !klient )
+		return;
+	short len = (short)( 6 + zSpieler->getEintragAnzahl() * 8 );
+	char *bytes = new char[ len ];
+	*(int*)bytes = spielZeit;
+	*(char*)( bytes + 4 ) = 6;
+	*(char*)( bytes + 5 ) = (char)zSpieler->getEintragAnzahl();
+	for( int i = 0; i < zSpieler->getEintragAnzahl(); i++ )
+	{
+		*(int*)( bytes + 6 + i * 8 ) = zSpieler->z( i )->getSpielerNummer();
+		*(int*)( bytes + 10 + i * 8 ) = zSpieler->z( i )->getAccountId();
+	}
+	klient->spielNachricht( len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeSpielerNummer( int sNum, int spielZeit )
+{
+	if( !klient )
+		return;
+	short len = 9;
+	char *bytes = new char[ len ];
+	*(int*)bytes = spielZeit;
+	*(char*)( bytes + 4 ) = 9;
+	*(int*)( bytes + 5 ) = sNum;
+	klient->spielNachricht( len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeStart( int spielZeit )
+{
+	if( !klient )
+		return;
+	short len = 5;
+	char *bytes = new char[ len ];
+	*(int*)bytes = spielZeit;
+	*(char*)( bytes + 4 ) = 0xA;
+	klient->spielNachricht( len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeTastaturStatus( int spielerId, TastaturStatus ts, bool aktiv, int spielZeit )
+{
+	if( !klient )
+		return;
+	short len = 9;
+	char *bytes = new char[ len ];
+	*(int*)bytes = spielZeit;
+	*(char*)( bytes + 4 ) = (char)( (char)ts * 2 + (char)!aktiv );
+	*(int*)( bytes + 5 ) = spielerId;
+	klient->spielNachricht( len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeSkillNachricht( int sNum, char art, int spielZeit )
+{
+	if( !klient )
+		return;
+	short len = 10;
+	char *bytes = new char[ len ];
+	*(int*)bytes = spielZeit;
+	*(char*)( bytes + 4 ) = 0xC;
+	*(int*)( bytes + 5 ) = sNum;
+	*(char*)( bytes + 9 ) = art;
+	klient->spielNachricht( len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeSchuss( int id, int sNum, Vec2< double > pos, Vec2< double > speed, double intensity, int spielZeit )
+{
+	if( !klient )
+		return;
+	short len = 53;
+	char *bytes = new char[ len ];
+	*(int*)bytes = spielZeit;
+	*(char*)( bytes + 4 ) = 0xD;
+	*(int*)( bytes + 5 ) = id;
+	*(int*)( bytes + 9 ) = sNum;
+	*(double*)( bytes + 13 ) = pos.x;
+	*(double*)( bytes + 21 ) = pos.y;
+	*(double*)( bytes + 29 ) = speed.x;
+	*(double*)( bytes + 37 ) = speed.y;
+	*(double*)( bytes + 45 ) = intensity;
+	klient->spielNachricht( len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeTreffer( int id, int sNum, int spielZeit )
+{
+	if( !klient )
+		return;
+	short len = 13;
+	char *bytes = new char[ len ];
+	*(int*)bytes = spielZeit;
+	*(char*)( bytes + 4 ) = 0xE;
+	*(int*)( bytes + 5 ) = id;
+	*(int*)( bytes + 9 ) = sNum;
+	klient->spielNachricht( len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeWiederbelebung( int sNum, int spielZeit )
+{
+	if( !klient )
+		return;
+	short len = 9;
+	char *bytes = new char[ len ];
+	*(int*)bytes = spielZeit;
+	*(char*)( bytes + 4 ) = 0xF;
+	*(int*)( bytes + 5 ) = sNum;
+	klient->spielNachricht( len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeTod( int sNum, int killSNum, int spielZeit )
+{
+	if( !klient )
+		return;
+	short len = 13;
+	char *bytes = new char[ len ];
+	*(int*)bytes = spielZeit;
+	*(char*)( bytes + 4 ) = 0x10;
+	*(int*)( bytes + 5 ) = sNum;
+	*(int*)( bytes + 9 ) = killSNum;
+	klient->spielNachricht( len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeSpielEnde( char gewonnen, int spielZeit )
+{
+	if( !klient )
+		return;
+	short len = 6;
+	char *bytes = new char[ len ];
+	*(int*)bytes = spielZeit;
+	*(char*)( bytes + 4 ) = 0xB;
+	*(char*)( bytes + 5 ) = gewonnen;
+	klient->spielNachricht( len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeChatNachricht( char *txt, int spielZeit )
+{
+	if( !klient )
+		return;
+	short len = (short)( 5 + textLength( txt ) );
+	char *bytes = new char[ len ];
+	*(int*)bytes = spielZeit;
+	*(char*)( bytes + 4 ) = 0x8;
+	for( int i = 5; i < len; i++ )
+		bytes[ i ] = txt[ i - 5 ];
+	klient->spielNachricht( len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeStatistikChatNachricht( int vonAccount, char *txt )
+{
+	if( !klient )
+		return;
+	short len = (short)( 5 + textLength( txt ) );
+	char *bytes = new char[ len ];
+	*(char*)( bytes ) = 3;
+	*(int*)( bytes + 1 ) = vonAccount;
+	for( int i = 5; i < len; i++ )
+		bytes[ i ] = txt[ i - 5 ];
+	klient->statistikNachricht( len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeStatistikSpielerOffline( int account )
+{
+	if( !klient )
+		return;
+	char *bytes = new char[ 5 ];
+	*(char*)( bytes ) = 4;
+	*(int*)( bytes + 1 ) = account;
+	klient->statistikNachricht( 5, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeSpielerStatistik( SpielerStatistik *zS )
+{
+	if( !zS || !klient )
+		return;
+	char snl = (char)zS->zSpielerName()->getLength();
+	char tnl = (char)zS->zTeamName()->getLength();
+	int len = 55 + snl + tnl;
+	char *bytes = new char[ len ];
+	bytes[ 0 ] = 0;
+	*(int*)( bytes + 1 ) = zS->getSpielerNummer();
+	*(char*)( bytes + 5 ) = (char)zS->zSpielerName()->getLength();
+	for( int i = 0; i < snl; i++ )
+		bytes[ i + 6 ] = zS->zSpielerName()->getText()[ i ];
+	*(char*)( bytes + 6 + snl ) = tnl;
+	for( int i = 0; i < tnl; i++ )
+		bytes[ i + 7 + snl ] = zS->zTeamName()->getText()[ i ];
+	*(int*)( bytes + 7 + snl + tnl ) = zS->getSpielerFarbe();
+	*(int*)( bytes + 11 + snl + tnl ) = zS->getTeamFarbe();
+	*(int*)( bytes + 15 + snl + tnl ) = zS->getSchadenBekommen();
+	*(int*)( bytes + 19 + snl + tnl ) = zS->getSchadenGemacht();
+	*(int*)( bytes + 23 + snl + tnl ) = zS->getTreibstoffVerbraucht();
+	*(int*)( bytes + 27 + snl + tnl ) = zS->getShots();
+	*(int*)( bytes + 31 + snl + tnl ) = zS->getTreffer();
+	*(int*)( bytes + 35 + snl + tnl ) = zS->getPunkte();
+	*(int*)( bytes + 39 + snl + tnl ) = zS->getKills();
+	*(int*)( bytes + 43 + snl + tnl ) = zS->getTode();
+	*(int*)( bytes + 47 + snl + tnl ) = zS->getZeitAmLeben();
+	*(int*)( bytes + 51 + snl + tnl ) = zS->getZeitTod();
+	klient->statistikNachricht( (short)len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeTeamStatistik( TeamStatistik *zS )
+{
+	if( !zS || !klient )
+		return;
+	char tnl = (char)zS->zTeamName()->getLength();
+	int len = 43 + tnl;
+	char *bytes = new char[ len ];
+	bytes[ 0 ] = 1;
+	*(int*)( bytes + 1 ) = zS->getTeamNummer();
+	*(char*)( bytes + 5 ) = tnl;
+	for( int i = 0; i < tnl; i++ )
+		bytes[ i + 6 ] = zS->zTeamName()->getText()[ i ];
+	*(int*)( bytes + 6 + tnl ) = zS->getTeamFarbe();
+	*(int*)( bytes + 10 + tnl ) = zS->getSchadenBekommen();
+	*(int*)( bytes + 14 + tnl ) = zS->getSchadenGemacht();
+	*(int*)( bytes + 18 + tnl ) = zS->getTreibstoffVerbraucht();
+	*(int*)( bytes + 22 + tnl ) = zS->getShots();
+	*(int*)( bytes + 26 + tnl ) = zS->getTreffer();
+	*(int*)( bytes + 30 + tnl ) = zS->getPunkte();
+	*(int*)( bytes + 34 + tnl ) = zS->getKills();
+	*(int*)( bytes + 38 + tnl ) = zS->getTode();
+	*( bytes + 42 + tnl ) = (char)zS->hatGewonnen();
+	klient->statistikNachricht( (short)len, bytes );
+	delete[] bytes;
+}
+
+void Klient::sendeStatistikLadenFertig()
+{
+	if( !klient )
+		return;
+	char byte = 2;
+	klient->statistikNachricht( 1, &byte );
+}
+
+// constant
+bool Klient::istOnline() const
+{
+	return klient != 0;
+}
+
+// reference Counting
+Klient *Klient::getThis()
+{
+	ref++;
+	return this;
+}
+
+Klient *Klient::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Laser.cpp

@@ -0,0 +1,71 @@
+#include "Laser.h"
+#include "Karte.h"
+
+// Inhalt der Laser Klasse aus Laser.h
+// Konstruktor
+Laser::Laser( int id, Vec2< double > pos, Vec2< double > speed, int sNum, double intensity )
+{
+	this->id = id;
+	this->pos = pos;
+	this->speed = speed;
+	this->sNum = sNum;
+	this->intensity = intensity;
+	ref = 1;
+}
+
+// nicht constant
+void Laser::tick( double tickVal, Karte *zMap )
+{
+	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;
+	intensity -= tickVal * 2;
+}
+
+// constant
+int Laser::getId() const
+{
+	return id;
+}
+
+int Laser::getSpieler() const
+{
+	return sNum;
+}
+
+Vec2< double > Laser::getPos() const
+{
+	return pos;
+}
+
+Vec2< double > Laser::getSpeed() const
+{
+	return speed;
+}
+
+double Laser::getIntensity() const
+{
+	return intensity;
+}
+
+// Reference Counting
+Laser *Laser::getThis()
+{
+	ref++;
+	return this;
+}
+
+Laser *Laser::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Laser.h

@@ -0,0 +1,35 @@
+#ifndef Laser_H
+#define Laser_H
+
+#include <Vec2.h>
+using namespace Framework;
+
+class Karte;
+
+class Laser
+{
+private:
+	int ref;
+	int id;
+	Vec2< double > pos;
+	Vec2< double > speed;
+	double intensity;
+	int sNum;
+
+public:
+	// Konstruktor
+	Laser( int id, Vec2< double > pos, Vec2< double > speed, int sNum, double intensity );
+	// nicht constant
+	void tick( double tickVal, Karte *zMap );
+	// constant
+	int getId() const;
+	int getSpieler() const;
+	Vec2< double > getPos() const;
+	Vec2< double > getSpeed() const;
+	double getIntensity() const;
+	// Reference Counting
+	Laser *getThis();
+	Laser *release();
+};
+
+#endif

Asteroids/SSDatenbankV.h

@@ -0,0 +1,34 @@
+#ifndef SSDatenbankV_H
+#define SSDatenbankV_H
+
+#include <Text.h>
+#include <Array.h>
+#include <Zeit.h>
+
+using namespace Framework;
+
+class SSDatenbankV
+{
+private:
+
+public:
+	virtual ~SSDatenbankV()
+	{}
+	// nicht constant
+	virtual int getAccountId( int clientId ) = 0;
+	virtual Text *getSpielArtName( int spielId ) = 0;
+	virtual Text *getKarteName( int karteId ) = 0;
+	virtual int getSpielArtId( int karteId ) = 0;
+	virtual Text *getAccountRufName( int accountId ) = 0;
+	virtual bool setSpielStatusBeendet( int spielId, int status ) = 0;
+	virtual bool setSpielSpielerStatus( int spielId, int accountId, int punkte, int status ) = 0;
+	virtual bool addSpielerStatistik( int accountId, int spielId ) = 0;
+    virtual Text *getSpielPfad( int karteId ) = 0;
+	// constant
+
+	// Reference Counting
+	virtual SSDatenbankV *getThis() = 0;
+	virtual SSDatenbankV *release() = 0;
+};
+
+#endif

Asteroids/SSKlient.h

@@ -0,0 +1,52 @@
+#ifndef Klient_H
+#define Klient_H
+
+#include "SSKlientV.h"
+#include <Array.h>
+#include <Vec2.h>
+#include "Spieler.h"
+#include "SpielerStatistik.h"
+#include "TeamStatistik.h"
+
+using namespace Framework;
+
+class Spieler;
+
+class Klient
+{
+private:
+	SSKlientV *klient;
+	int ref;
+
+public:
+	// Konstruktor
+	Klient( SSKlientV *klient );
+	// Destruktor
+	~Klient();
+	// nicht constant
+	void offline();
+	void online( SSKlientV *zKlient );
+	void sendeInit( RCArray< Spieler > *zSpieler, int spielZeit );
+	void sendeSpielerNummer( int sNum, int spielZeit );
+	void sendeStart( int spielZeit );
+	void sendeTastaturStatus( int spielerId, TastaturStatus ts, bool aktiv, int spielZeit );
+	void sendeSkillNachricht( int sNum, char art, int spielZeit );
+	void sendeSchuss( int id, int sNum, Vec2< double > pos, Vec2< double > speed, double intensity, int spielZeit );
+	void sendeTreffer( int id, int sNum, int spielZeit );
+	void sendeWiederbelebung( int sNum, int spielZeit );
+	void sendeTod( int sNum, int killSNum, int spielZeit );
+	void sendeSpielEnde( char gewonnen, int spielZeit );
+	void sendeChatNachricht( char *txt, int spielZeit );
+	void sendeStatistikChatNachricht( int vonAccount, char *txt );
+	void sendeStatistikSpielerOffline( int account );
+	void sendeSpielerStatistik( SpielerStatistik *zS );
+	void sendeTeamStatistik( TeamStatistik *zS );
+	void sendeStatistikLadenFertig();
+	// constant
+	bool istOnline() const;
+	// reference Counting
+	Klient *getThis();
+	Klient *release();
+};
+
+#endif

Asteroids/SSKlientV.h

@@ -0,0 +1,29 @@
+#ifndef SSKlientV_H
+#define SSKlientV_H
+
+#include <Thread.h>
+
+using namespace Framework;
+
+class SSKlientV : public Thread
+{
+private:
+
+public:
+	// nicht constant 
+	virtual void nichtTrennen() = 0;
+	virtual double ping() = 0;
+	virtual void spielNachricht( short len, char *bytes ) = 0;
+	virtual void statistikNachricht( short len, char *bytes ) = 0;
+	virtual void trenne() = 0;
+	virtual void thread() = 0;
+	virtual void errorZuKlientEmpfang( const char *nachricht ) = 0; // sendet eine Fehlernachricht zum Klient
+	virtual void errorZuKlientSende( const char *nachricht ) = 0;
+	// const
+	virtual int getAccountId() const = 0;
+	// Reference Counting
+	virtual SSKlientV *getThis() = 0;
+	virtual SSKlientV *release() = 0;
+};
+
+#endif

Asteroids/STS.cpp

@@ -0,0 +1,35 @@
+#include "STS.h"
+
+// Inhalt der SpielerTeamStruktur Struktur aus Strukturen.h
+SpielerTeamStruktur::SpielerTeamStruktur()
+{
+	spielerAnzahl = 0;
+	teamAnzahl = 0;
+	spielerFarbe = new Array< int >();
+	teamFarbe = new Array< int >();
+	teamName = new RCArray< Text >();
+	teamSize = new Array< int >();
+	ref = 1;
+}
+
+SpielerTeamStruktur::~SpielerTeamStruktur()
+{
+	spielerFarbe->release();
+	teamFarbe->release();
+	teamName->release();
+	teamSize->release();
+}
+
+SpielerTeamStruktur *SpielerTeamStruktur::getThis()
+{
+	ref++;
+	return this;
+}
+
+SpielerTeamStruktur *SpielerTeamStruktur::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/STS.h

@@ -0,0 +1,24 @@
+#ifndef STS_H
+#define STS_H
+
+#include <Array.h>
+#include <Text.h>
+
+using namespace Framework;
+
+struct SpielerTeamStruktur
+{
+	SpielerTeamStruktur();
+	~SpielerTeamStruktur();
+	int spielerAnzahl;
+	int teamAnzahl;
+	Array< int > *spielerFarbe;
+	Array< int > *teamFarbe;
+	RCArray< Text > *teamName;
+	Array< int > *teamSize;
+	int ref;
+	SpielerTeamStruktur *getThis();
+	SpielerTeamStruktur *release();
+};
+
+#endif

Asteroids/Spiel.cpp

@@ -0,0 +1,559 @@
+#include "Spiel.h"
+#include <time.h>
+#include <DateiSystem.h>
+#include "Define.h"
+#include "SSKlient.h"
+#include "KartenLeser.h"
+#include "Statistik.h"
+#include "Team.h"
+#include "Laser.h"
+#ifdef WIN32
+#include <random>
+#else
+#include <math.h>
+#include <unistd.h>
+#include <stdlib.h>
+#define Sleep( x )    usleep( (x) * 1000 )
+#endif
+
+// Inhalt der Spiel Klasse aus Spiel.h
+// Konstruktor
+Spiel::Spiel()
+{
+	zAccounts = 0;
+	zKlients = 0;
+	stat = new Statistik();
+	teams = new RCArray< Team >();
+	teamAnzahl = 0;
+	spieler = new RCArray< Spieler >();
+	shots = new RCArray< Laser >();
+	objekte = new RCArray< SpielObjekt >();
+	psqldb = 0;
+	spielId = 0;
+	karteId = 0;
+	spielerAnzahl = 0;
+	karte = 0;
+	InitializeCriticalSection( &cs );
+	sts = 0;
+	log = 0;
+	isRunning = 0;
+	spielZeit = 0;
+	ende = 1;
+	nextSchussId = 1;
+	ref = 1;
+}
+
+// Destruktor
+Spiel::~Spiel()
+{
+	teams->release();
+	stat->release();
+	spieler->release();
+	objekte->release();
+	if( psqldb )
+		psqldb->release();
+	if( karte )
+		karte->release();
+	if( sts )
+		sts->release();
+	DeleteCriticalSection( &cs );
+}
+
+// privat
+int Spiel::getTeamVonSpieler( int sNum )
+{
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		Spieler *tmp = spieler->z( i );
+		if( tmp && tmp->getSpielerNummer() == sNum )
+			return tmp->zTeam() ? tmp->zTeam()->id : 0;
+	}
+	return 0;
+}
+
+// nicht constant
+void Spiel::setPSQLK( SSDatenbankV *psqldb )
+{
+	if( this->psqldb )
+		this->psqldb->release();
+	this->psqldb = psqldb;
+	stat->setPSQLDB( psqldb->getThis() );
+}
+
+void Spiel::setSpielId( int id )
+{
+	spielId = id;
+	stat->setSpielId( id );
+}
+
+void Spiel::setKarteId( int karteId )
+{
+	this->karteId = karteId;
+	stat->setKarteId( karteId );
+}
+
+void Spiel::setTempPfad( char *pfad )
+{
+    mapPfad = pfad;
+    mapPfad += "/";
+}
+
+void Spiel::setAccounts( int anzahl, Array< int > *zAccounts )
+{
+	this->zAccounts = zAccounts->getThis();
+	spielerAnzahl = anzahl;
+}
+
+void Spiel::setKlients( int anzahl, RCArray< SSKlientV > *zKlients )
+{
+	this->zKlients = zKlients->getThis();
+}
+
+void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
+{
+	if( !sts )
+	{
+		sts = new SpielerTeamStruktur();
+		KartenLeser *reader = new KartenLeser( karteId, psqldb->getThis(), mapPfad );
+		reader->ladeSpielerTeamStruktur( sts );
+		if( karte )
+			karte->release();
+		karte = reader->ladeKarte( sts );
+		reader->release();
+		for( int i = 0; i < sts->teamAnzahl; i++ )
+			teams->set( karte->createTeam( i ), i );
+		stat->setTeamNamen( sts->teamName->getThis() );
+		int objektAnzahl = karte->getObjektAnzahl();
+		for( int i = 0; i < objektAnzahl; i++ )
+			objekte->set( karte->createObjekt( i ), i );
+	}
+	for( int i = 0; i < anzahl; i++ )
+	{
+		Spieler *tmp = karte->createSpieler( spielerNummern->get( i ) );
+		if( tmp )
+		{
+			int team = 0;
+			int von = 0;
+			int bis = 0;
+			for( int j = 0; j < sts->teamAnzahl; j++ )
+			{
+				bis = von + ( sts->teamSize->hat( j ) ? sts->teamSize->get( j ) : 0 );
+				if( tmp->getSpielerNummer() >= von && tmp->getSpielerNummer() < bis )
+				{
+					team = j;
+					break;
+				}
+				von = bis;
+			}
+			tmp->setTeam( teams->get( team ) );
+			teams->z( team )->spieler->add( tmp );
+		}
+		spieler->set( tmp, i );
+	}
+	for( int i = 0; i < anzahl; i++ )
+		spieler->z( i )->setAccountId( zAccounts->hat( i ) ? zAccounts->get( i ) : 0 );
+	for( int i = 0; i < anzahl; i++ )
+		spieler->z( i )->setKlient( new Klient( zKlients->get( i ) ) );
+	stat->setSpieler( spielerAnzahl, spieler );
+	zAccounts = zAccounts->release();
+	zKlients = zKlients->release();
+	teamAnzahl = 0;
+	for( int i = 0; i < sts->teamAnzahl; i++ )
+		if( teams->z( i )->spieler->getEintragAnzahl() )
+			teamAnzahl++;
+}
+
+void Spiel::klientOffline( int accountId )
+{
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		if( spieler->z( i )->getAccountId() == accountId )
+			spieler->z( i )->offline();
+	}
+}
+
+void Spiel::klientOnline( int accountId, SSKlientV *zKlient )
+{
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		if( spieler->z( i )->getAccountId() == accountId )
+		{
+			EnterCriticalSection( &cs );
+			Spieler *s = spieler->z( i );
+			s->online( zKlient );
+			Klient *tmp = spieler->z( i )->zKlient();
+			tmp->sendeSpielerNummer( s->getSpielerNummer(), 0 );
+			//--------------------------
+			LeaveCriticalSection( &cs );
+		}
+	}
+}
+
+void Spiel::nachricht( int accountId, int len, char *bytes )
+{
+	if( !isRunning || ende )
+		return;
+	EnterCriticalSection( &cs );
+	if( ende )
+	{
+		LeaveCriticalSection( &cs );
+		return;
+	}
+	char *msgBeg = bytes;
+	int msgLen = len;
+	int msgAccount = accountId;
+	bool saveMSG = 1;
+	len--;
+	switch( *bytes )
+	{
+	case 0:
+	case 1:
+	case 2:
+	case 3:
+	case 4:
+	case 5:
+	case 6:
+	case 7:
+		for( int i = 0; i < spielerAnzahl; i++ )
+		{
+			Spieler *tmp = spieler->z( i );
+			if( tmp && tmp->getAccountId() == accountId )
+			{
+				if( !tmp->istAmLeben() )
+					break;
+				if( !tmp->setTastataturStatus( (TastaturStatus)( (int)( *bytes ) / 2 ), ( (int)( *bytes ) % 2 ) == 0 ) )
+				{
+					saveMSG = 0;
+					break;
+				}
+				if( *bytes != 6 && *bytes != 7 )
+				{
+					for( int j = 0; j < spielerAnzahl; j++ )
+					{
+						Spieler *s = spieler->z( j );
+						if( s && s->zKlient() )
+							s->zKlient()->sendeTastaturStatus( tmp->getSpielerNummer(), (TastaturStatus)( (int)( *bytes ) / 2 ), ( (int)( *bytes ) % 2 ) == 0, spielZeit );
+					}
+				}
+				break;
+			}
+		}
+		break;
+	case 8: // chat Nachricht
+		if( 1 )
+		{
+			bytes++;
+			Text *txt = psqldb->getAccountRufName( accountId );
+			txt->append( ": " );
+			txt->append( bytes, len );
+			for( int i = 0; i < spielerAnzahl; i++ )
+			{
+				Spieler *tmp = spieler->z( i );
+				if( tmp && tmp->zKlient() )
+					tmp->zKlient()->sendeChatNachricht( txt->getText(), spielZeit );
+			}
+			txt->release();
+			len = 0;
+		}
+		break;
+	case 9: // Skill verwendung
+		if( 1 )
+		{
+			bytes++;
+			char art = *bytes;
+			len--;
+			for( int i = 0; i < spielerAnzahl; i++ )
+			{
+				Spieler *tmp = spieler->z( i );
+				if( tmp && tmp->getAccountId() == accountId )
+				{
+					if( !tmp->istAmLeben() )
+						break;
+					if( !tmp->setSkill( art ) )
+					{
+						saveMSG = 0;
+						break;
+					}
+					for( int j = 0; j < spielerAnzahl; j++ )
+					{
+						Spieler *s = spieler->z( j );
+						if( s && s->zKlient() )
+							s->zKlient()->sendeSkillNachricht( tmp->getSpielerNummer(), art, spielZeit );
+					}
+					break;
+				}
+			}
+			break;
+		}
+		break;
+	default:
+		saveMSG = 0;
+	}
+	if( len )
+	{
+		// error
+	}
+	if( log && log->istOffen() && saveMSG )
+	{
+		char c = 1;
+		log->schreibe( &c, 1 );
+		int spielerNum = 0;
+		for( int i = 0; i < spielerAnzahl; i++ )
+		{
+			Spieler *tmp = spieler->z( i );
+			if( tmp && tmp->getAccountId() == msgAccount )
+			{
+				spielerNum = tmp->getSpielerNummer();
+				break;
+			}
+		}
+		log->schreibe( (char*)&spielerNum, 4 );
+		short l = (short)msgLen;
+		log->schreibe( (char*)&l, 2 );
+		log->schreibe( msgBeg, l );
+	}
+	LeaveCriticalSection( &cs );
+}
+
+void Spiel::tick( double zeit )
+{
+	// Objekte Updaten
+	int objektAnzahl = objekte->getEintragAnzahl();
+	for( int i = 0; i < objektAnzahl; i++ )
+		objekte->z( i )->tick();
+	// Spieler Updaten
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		Spieler *tmp = spieler->z( i );
+		if( tmp )
+		{
+			if( tmp->tick( zeit, karte ) == 1 )
+			{ // Wiederbelebung
+				for( int j = 0; j < spielerAnzahl; j++ )
+				{
+					Spieler *s = spieler->z( j );
+					if( s )
+						s->zKlient()->sendeWiederbelebung( tmp->getSpielerNummer(), spielZeit );
+				}
+			}
+		}
+	}
+	// Schüsse Updaten
+	int anz = shots->getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+	{
+		if( shots->z( i ) )
+			shots->z( i )->tick( zeit, karte );
+	}
+	// Schüsse Collision
+	for( int i = 0; i < anz; i++ )
+	{
+		Laser *tmp = shots->z( i );
+		if( tmp )
+		{
+			if( tmp->getIntensity() <= 0 )
+			{ // Schuss existiert nicht mehr
+				for( int j = 0; j < spielerAnzahl; j++ )
+				{
+					Spieler *s = spieler->z( j );
+					if( s )
+						s->zKlient()->sendeTreffer( tmp->getId(), -1, spielZeit );
+				}
+				shots->remove( i );
+				anz--;
+				i--;
+			}
+			else
+			{ // Schuss existiert noch
+				int team = getTeamVonSpieler( tmp->getSpieler() );
+				for( int j = 0; j < spielerAnzahl; j++ )
+				{
+					Spieler *s = spieler->z( j );
+					if( s && s->zTeam() && s->zTeam()->id != team && ( s->istTreffer( tmp->getPos() ) ||
+						s->istTreffer( tmp->getPos() + karte->getSize() ) || s->istTreffer( tmp->getPos() - karte->getSize() ) ) )
+					{ // Treffer
+						bool kill = s->nimmSchaden( tmp->getIntensity() * ( (tmp->getSpeed() - s->getSpeed() ).getLength() / 200 ) );
+						for( int k = 0; k < spielerAnzahl; k++ )
+						{
+							Spieler *sp = spieler->z( k );
+							if( sp )
+								sp->zKlient()->sendeTreffer( tmp->getId(), s->getSpielerNummer(), spielZeit );
+							if( sp && sp->getSpielerNummer() == tmp->getSpieler() )
+								sp->machSchaden( tmp->getIntensity() * ( (tmp->getSpeed() - s->getSpeed() ).getLength() / 200 ), kill );
+							if( kill && sp )
+								sp->zKlient()->sendeTod( s->getSpielerNummer(), tmp->getSpieler(), spielZeit );
+						}
+						if( kill )
+						{
+							if( teams->z( team - 1 ) )
+								teams->z( team - 1 )->punkte++;
+							if( teams->z( team - 1 )->punkte == teams->z( team - 1 )->maxPunkte )
+								ende = 1;
+						}
+						shots->remove( i );
+						anz--;
+						i--;
+						break;
+					}
+				}
+			}
+		}
+	}
+	// Neue Schüsse hinzufügen
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		Spieler *tmp = spieler->z( i );
+		if( tmp )
+		{
+			Laser *nL = tmp->getLaser( nextSchussId++ );
+			if( nL )
+			{
+				shots->add( nL );
+				for( int j = 0; j < spielerAnzahl; j++ )
+				{
+					if( spieler->z( j ) && spieler->z( j )->zKlient() )
+						spieler->z( j )->zKlient()->sendeSchuss( nL->getId(), nL->getSpieler(), nL->getPos(), nL->getSpeed(), nL->getIntensity(), spielZeit );
+				}
+			}
+		}
+	}
+}
+
+void Spiel::run()
+{
+	log = new Datei();
+	Text *pfad = new Text( "../spiel log/" );
+	pfad->append( spielId );
+	pfad->append( "/verlauf.ksggl" );
+	log->setDatei( pfad );
+	log->remove();
+	log->erstellen();
+	log->open( Datei::Style::schreiben );
+	time_t t;
+	time( &t );
+	srand( (unsigned int)t );
+	log->schreibe( (char*)&spielerAnzahl, 4 );
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		Spieler *tmp = spieler->z( i );
+		if( tmp && tmp->zKlient() )
+		{
+			tmp->zKlient()->sendeInit( spieler, 0 );
+			log->schreibe( (char*)&i, 4 );
+			int sNum = tmp->getSpielerNummer();
+			log->schreibe( (char*)&sNum, 4 );
+			tmp->zKlient()->sendeSpielerNummer( sNum, 0 );
+			int team = tmp->zTeam()->id;
+			log->schreibe( (char*)&team, 4 );
+			int farbe = tmp->getSpielerFarbe();
+			log->schreibe( (char*)&farbe, 4 );
+			farbe = tmp->zTeam()->farbe;
+			log->schreibe( (char*)&farbe, 4 );
+			Text *name = psqldb->getAccountRufName( tmp->getAccountId() );
+			char len = (char)( name ? name->getLength() : 0 );
+			log->schreibe( &len, 1 );
+			if( len )
+				log->schreibe( name->getText(), len );
+			if( name )
+				name->release();
+			name = sts->teamName->z( team );
+			len = (char)( name ? name->getLength() : 0 );
+			log->schreibe( &len, 1 );
+			if( len )
+				log->schreibe( name->getText(), len );
+		}
+	}
+	Array< char > spielerStatus;
+	ZeitMesser *zeit = new ZeitMesser();
+	zeit->messungStart();
+	isRunning = 1;
+	ende = 0;
+	double ausgleich = 0;
+	double sZ = 0;
+	spielZeit = 0;
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		Spieler *tmp = spieler->z( i );
+		if( tmp && tmp->zKlient() )
+			tmp->zKlient()->sendeStart( 0 );
+	}
+	double rZeit = 0;
+	while( !ende )
+	{
+		zeit->messungEnde();
+		zeit->messungStart();
+		double z = zeit->getSekunden();
+		ausgleich += 1.0 / 25 - z;
+		if( ausgleich > 0 )
+			Sleep( (int)( ausgleich * 1000 ) );
+		rZeit += z;
+		while( sZ + TICK < rZeit && !ende )
+		{
+			EnterCriticalSection( &cs );
+			sZ += TICK;
+			spielZeit++;
+			char c = 0;
+			log->schreibe( &c, 1 );
+			tick( TICK );
+			LeaveCriticalSection( &cs );
+		}
+	}
+	zeit->messungEnde();
+	zeit->release();
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		if( spieler->z( i ) && spieler->z( i )->zKlient() )
+		{
+			if( spieler->z( i )->zTeam()->punkte < spieler->z( i )->zTeam()->maxPunkte )
+			{
+				spielerStatus.set( 1, i ); // Datenbank Verloren
+				spieler->z( i )->zKlient()->sendeSpielEnde( 0, 0 );
+			}
+			else
+			{
+				spielerStatus.set( 2, i ); // Datenbank Gewonnen
+				spieler->z( i )->zKlient()->sendeSpielEnde( 1, 0 );
+			}
+		}
+		if( spieler->z( i ) && ( !spieler->z( i )->zKlient() || !spieler->z( i )->istOnline() ) )
+			spielerStatus.set( 3, i );
+	}
+	if( teamAnzahl == 1 )
+		psqldb->setSpielStatusBeendet( spielId, 6 );
+	else
+		psqldb->setSpielStatusBeendet( spielId, 5 );
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		Spieler *tmp = spieler->z( i );
+		if( tmp )
+		{
+			psqldb->setSpielSpielerStatus( spielId, tmp->getAccountId(), tmp->getPunkte(), spielerStatus.get( i ) );
+			if( teamAnzahl > 1 )
+				psqldb->addSpielerStatistik( tmp->getAccountId(), spielId );
+		}
+	}
+	log->close();
+	log = log->release();
+	isRunning = 0;
+}
+
+// constant
+StatistikV *Spiel::getStatistik() const
+{
+	return stat->getThis();
+}
+
+// Reference Counting 
+SpielKlasse *Spiel::getThis()
+{
+	ref++;
+	return this;
+}
+
+SpielKlasse *Spiel::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Spiel.h

@@ -0,0 +1,67 @@
+#ifndef Spiel_H
+#define Spiel_H
+
+#include "SpielKlasse.h"
+#include <Datei.h>
+#include "STS.h"
+#include "Spieler.h"
+#include "Karte.h"
+#include "SpielObjekt.h"
+
+class Statistik;
+class StatistikV;
+
+class Spiel : public SpielKlasse
+{
+private:
+	Statistik *stat;
+	RCArray< Team > *teams;
+	int teamAnzahl;
+	Array< int > *zAccounts;
+	RCArray< SSKlientV > *zKlients;
+	RCArray< Spieler > *spieler;
+	RCArray< Laser > *shots;
+	RCArray< SpielObjekt > *objekte;
+	SSDatenbankV *psqldb;
+	int spielId;
+	int karteId;
+	int spielerAnzahl;
+	Karte *karte;
+	CRITICAL_SECTION cs;
+	SpielerTeamStruktur *sts;
+	Datei *log;
+    Text mapPfad;
+	bool isRunning;
+	int spielZeit;
+	bool ende;
+	int nextSchussId;
+	int ref;
+	// privat
+	int getTeamVonSpieler( int sNum );
+
+public:
+	// Konstruktor
+	Spiel();
+	// Destruktor
+	~Spiel();
+	// nicht constant
+	virtual void setPSQLK( SSDatenbankV *psqldb ); // call 1
+	virtual void setSpielId( int id ); // call 2
+	virtual void setKarteId( int karteId ); // call 3
+    virtual void setTempPfad( char *pfad ); // call 3.5
+	virtual void setAccounts( int anzahl, Array< int > *zAccounts ); // call 4
+	virtual void setKlients( int anzahl, RCArray< SSKlientV > *zKlients ); // call 5
+	virtual void setSpielerNummern( int anzahl, Array< int > *spielerNummern ); // call 6
+	virtual void klientOffline( int accountId );
+	virtual void klientOnline( int accountId, SSKlientV *zKlient );
+	virtual void nachricht( int accountId, int len, char *bytes );
+	void tick( double zeit );
+	virtual void run(); // call 7
+	// constant
+	virtual StatistikV *getStatistik() const;
+	// Reference Counting 
+	virtual SpielKlasse *getThis();
+	virtual SpielKlasse *release();
+};
+
+#endif

Asteroids/SpielKlasse.h

@@ -0,0 +1,38 @@
+#ifndef SpielKlasse_H
+#define SpielKlasse_H
+
+#include "SSKlientV.h"
+#include "SSDatenbankV.h"
+#include "StatistikKlasse.h"
+#include <Thread.h>
+
+using namespace Framework;
+
+class SpielKlasse
+{
+private:
+
+public:
+	virtual ~SpielKlasse()
+	{
+	}
+	// nicht constant
+	virtual void setPSQLK( SSDatenbankV *psqldb ) = 0;
+	virtual void setSpielId( int id ) = 0;
+    virtual void setKarteId( int karteId ) = 0;
+    virtual void setTempPfad( char *pfad ) = 0;
+	virtual void setAccounts( int anzahl, Array< int > *zAccounts ) = 0;
+	virtual void setKlients( int anzahl, RCArray< SSKlientV > *zKlients ) = 0;
+	virtual void setSpielerNummern( int anzahl, Array< int > *spielerNummern ) = 0;
+	virtual void klientOffline( int accountId ) = 0;
+	virtual void klientOnline( int accountId, SSKlientV *zKlient ) = 0;
+	virtual void nachricht( int accountId, int len, char *bytes ) = 0;
+	virtual void run() = 0;
+	// constant
+	virtual StatistikV *getStatistik() const = 0;
+	// Reference Counting 
+	virtual SpielKlasse *getThis() = 0;
+	virtual SpielKlasse *release() = 0;
+};
+
+#endif

Asteroids/SpielObjekt.cpp

@@ -0,0 +1,94 @@
+#include "SpielObjekt.h"
+#include "Define.h"
+
+// Inhalt der SpielObjekt Klasse aus SpielObjekt.h
+// Konstruktor
+SpielObjekt::SpielObjekt( ObjektStr *zStr )
+{
+	pos = zStr->pos;
+	id = zStr->id;
+	mdl = new Model2D();
+	style = zStr->style;
+	stability = zStr->maxStability;
+	energie = zStr->maxEnergie;
+	maxStability = zStr->maxStability;
+	maxEnergie = zStr->maxEnergie;
+	energieRadius = zStr->energieRadius;
+	reparatur = zStr->reparatur;
+	akkuLeistung = zStr->akkuLeistung;
+	team = 0;
+	ref = 1;
+}
+
+// Destruktor
+SpielObjekt::~SpielObjekt()
+{
+	mdl->release();
+	if( team )
+		team->release();
+}
+
+// nicht constant
+void SpielObjekt::setModelData( Model2DData *data )
+{
+	mdl->setModel( data );
+}
+
+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 )
+	{
+		stability += reparatur * TICK;
+		if( stability > maxStability )
+			stability = maxStability;
+	}
+	if( !akkuAbk )
+	{
+		if( !team )
+		{
+			energie -= akkuLeistung * TICK;
+			if( energie < 0 )
+				energie = 0;
+		}
+		else
+		{
+			energie += akkuLeistung * TICK;
+			if( energie > maxEnergie )
+				energie = maxEnergie;
+		}
+	}
+}
+
+// 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/SpielObjekt.h

@@ -0,0 +1,46 @@
+#ifndef SpielObjekt_H
+#define SpielObjekt_H
+
+#include <Vec2.h>
+#include <Model2D.h>
+#include "Team.h"
+#include "Strukturen.h"
+
+using namespace Framework;
+
+class SpielObjekt
+{
+private:
+	Vec2< double > pos;
+	int id;
+	Model2D *mdl;
+	int style;
+	double stability;
+	double energie;
+	int maxStability;
+	int maxEnergie;
+	int energieRadius;
+	double reparatur;
+	double akkuLeistung;
+	double repAbk;
+	double akkuAbk;
+	Team *team;
+	int ref;
+
+public:
+	// Konstruktor
+	SpielObjekt( ObjektStr *zStr );
+	// Destruktor
+	~SpielObjekt();
+	// nicht constant
+	void setModelData( Model2DData *data );
+	void setTeam( Team *team );
+	void tick();
+	// constant
+	Team *zTeam() const;
+	// Reference Counting
+	SpielObjekt *getThis();
+	SpielObjekt *release();
+};
+
+#endif

Asteroids/Spieler.cpp

@@ -0,0 +1,625 @@
+#include "Spieler.h"
+
+#include "Team.h"
+#include "Laser.h"
+#include "Karte.h"
+#include "SSKlient.h"
+#include <iostream>
+
+// Inhalt der Spieler Klasse aus Spieler.h
+// Konstruktor
+Spieler::Spieler( SpielerStr *zStr )
+{
+    accountId = 0;
+    sNum = zStr->id;
+    farbe = 0;
+    ship = new Model2D();
+    team = 0;
+    klient = 0;
+    for( int i = 0; i < T_MAX; i++ )
+        tastatur[ i ] = 0;
+    amLeben = 1;
+    schussAbk = 0;
+    energieAbk = 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;
+    beschleunigungStart = zStr->beschleunigung;
+    energie = zStr->maxEnergie;
+    stability = zStr->maxStability;
+    reparatur = zStr->reparatur;
+    laserIntensity = zStr->laserIntensity;
+    laserEffizienz = zStr->laserEffizienz;
+    akkuLeistung = zStr->akkuLeistung;
+    akkuLeistungStart = zStr->akkuLeistung;
+    maxEnergie = zStr->maxEnergie;
+    maxStability = zStr->maxStability;
+    laserTempo = zStr->laserTempo;
+    netzwerk = zStr->netzwerk;
+    wendigkeit = zStr->wendigkeit;
+    wendigkeitStart = zStr->wendigkeit;
+    antriebEffizienz = zStr->antriebEffizienz;
+    skillPunkte = zStr->skillPunkte;
+    schadenBekommen = 0;
+    schadenGemacht = 0;
+    treibstoffVerbraucht = 0;
+    shots = 0;
+    treffer = 0;
+    punkte = 0;
+    kills = 0;
+    tode = 0;
+    zeitAmLeben = 0;
+    zeitTod = 0;
+    rSpeed = 0;
+    ship->setPosition( pos );
+    ship->setDrehung( (float)rotation );
+}
+
+// Destruktor
+Spieler::~Spieler()
+{
+    ship->release();
+    if( team )
+        team->release();
+    if( klient )
+        klient->release();
+}
+
+// nicht constant
+void Spieler::offline()
+{
+    klient->offline();
+}
+
+void Spieler::online( SSKlientV *zKlient )
+{
+    klient->online( zKlient );
+}
+
+void Spieler::setModelData( Model2DData *data )
+{
+    for( auto i = data->polygons->getArray(); i.set; i++ )
+    {
+        if( i.var.name->istGleich( "engine_l" ) )
+        {
+            stL = *i.var.schwerpunkt;
+            Vertex l, r;
+            for( int j = 0; j < 4; j++ )
+            {
+                if( i.var.tKordinaten->get( j ).y == 1.f )
+                {
+                    if( i.var.tKordinaten->get( j ).x == 0.f )
+                        l = i.var.vertex->get( j );
+                    if( i.var.tKordinaten->get( j ).x == 1.f )
+                        r = i.var.vertex->get( j );
+                }
+            }
+            kL = ( ( l + ( r - l ) * 0.5 ) - stL );
+        }
+        if( i.var.name->istGleich( "engine_r" ) )
+        {
+            stR = *i.var.schwerpunkt;
+            Vertex l, r;
+            for( int j = 0; j < 4; j++ )
+            {
+                if( i.var.tKordinaten->get( j ).y == 1.f )
+                {
+                    if( i.var.tKordinaten->get( j ).x == 0.f )
+                        l = i.var.vertex->get( j );
+                    if( i.var.tKordinaten->get( j ).x == 1.f )
+                        r = i.var.vertex->get( j );
+                }
+            }
+            kR = ( ( l + ( r - l ) * 0.5 ) - stR );
+        }
+        if( i.var.name->istGleich( "engine_m" ) )
+        {
+            stM = *i.var.schwerpunkt;
+            Vertex l, r;
+            for( int j = 0; j < 4; j++ )
+            {
+                if( i.var.tKordinaten->get( j ).y == 1.f )
+                {
+                    if( i.var.tKordinaten->get( j ).x == 0.f )
+                        l = i.var.vertex->get( j );
+                    if( i.var.tKordinaten->get( j ).x == 1.f )
+                        r = i.var.vertex->get( j );
+                }
+            }
+            kM = ( ( l + ( r - l ) * 0.5 ) - stM );
+        }
+    }
+    kL.normalize();
+    kR.normalize();
+    kM.normalize();
+    ship->setModel( data );
+}
+
+void Spieler::setAccountId( int id )
+{
+    accountId = id;
+}
+
+void Spieler::setTeam( Team *team )
+{
+    if( this->team )
+        this->team->release();
+    this->team = team;
+}
+
+void Spieler::setSpielerFarbe( int farbe )
+{
+    this->farbe = farbe;
+}
+
+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::setKlient( Klient *klient )
+{
+    if( this->klient )
+        this->klient->release();
+    this->klient = klient;
+}
+
+bool Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv )
+{
+    if( tastatur[ ts ] == aktiv || !amLeben )
+        return 0;
+    tastatur[ ts ] = aktiv;
+    return 1;
+}
+
+int Spieler::tick( double zeit, Karte *zMap )
+{
+    if( !team )
+        return 0;
+    reinkAbk -= zeit;
+    if( reinkAbk < 0 )
+        reinkAbk = 0;
+    if( !reinkAbk && !amLeben )
+    { // Wiederbelebung
+        pos = startPos;
+        reinkAbk = maxReinkAbk * 2;
+        energie = maxEnergie + team->maxEnergie;
+        stability = maxStability + team->maxStability;
+        schussAbk = 0;
+        energieAbk = 0;
+        repAbk = 0;
+        speed = Vec2< double >( 0, 0 );
+        rotation = 0;
+        rSpeed = 0;
+        ship->setPosition( pos );
+        ship->setDrehung( (float)rotation );
+        for( int i = 0; i < T_MAX; i++ )
+            tastatur[ i ] = 0;
+        amLeben = 1;
+        return 1;
+    }
+    if( amLeben )
+    {
+        schussAbk -= zeit;
+        energieAbk -= zeit;
+        if( schussAbk < 0 )
+            schussAbk = 0;
+        if( energieAbk < 0 )
+            energieAbk = 0;
+        repAbk -= zeit;
+        if( repAbk < 0 )
+            repAbk = 0;
+        if( tastatur[ T_GAS ] )
+        {
+            Vertex hp;
+            Vertex mv;
+            float r;
+            double treibstoff = 3 * ( ( beschleunigung + team->beschleunigung ) / 5 )
+                * zeit * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
+            treibstoffVerbraucht += treibstoff;
+            double factor = 1;
+            if( treibstoff > energie )
+                factor = energie / treibstoff;
+            if( ship->zModel()->calcHitPoint( stM, kM * (float)( beschleunigung + team->beschleunigung ), ( char* )"ship", hp, mv, r ) )
+            {
+                speed += ( Vec2<double> )mv.rotation( (float)rotation ) * (float)zeit * factor;
+            }
+            energie -= treibstoff * factor;
+        }
+        double movementAngle = atan2( speed.y, speed.x );
+        bool xg0 = speed.x > 0;
+        bool yg0 = speed.y > 0;
+        if( speed.x != 0 )
+            speed.x += 5.0f * cos( movementAngle + PI ) * zeit;
+        if( speed.y != 0 )
+            speed.y += 5.0f * sin( movementAngle + PI ) * zeit;
+        if( !xg0 && speed.x > 0 )
+            speed.x = 0;
+        if( !yg0 && speed.y > 0 )
+            speed.y = 0;
+        if( rSpeed > 0 )
+        {
+            rSpeed -= (float)( zeit * 0.5 );
+            if( rSpeed < 0 )
+                rSpeed = 0;
+        }
+        if( rSpeed < 0 )
+        {
+            rSpeed += (float)( zeit * 0.5 );
+            if( rSpeed > 0 )
+                rSpeed = 0;
+        }
+        if( tastatur[ T_ROT_R ] )
+        {
+            Vertex hp;
+            Vertex mv;
+            float r;
+            double treibstoff = 1.5 * ( ( wendigkeit + team->wendigkeit ) / 5 )
+                * zeit * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
+            treibstoffVerbraucht += treibstoff;
+            double factor = 1;
+            if( treibstoff > energie )
+                factor = energie / treibstoff;
+            if( ship->zModel()->calcHitPoint( stL, kL * (float)( wendigkeit + team->wendigkeit ), ( char* )"ship", hp, mv, r ) )
+            {
+                rSpeed += r * (float)zeit * (float)factor;
+                speed += ( Vec2<double> )mv.rotation( (float)rotation ) * (float)zeit * factor;
+            }
+            energie -= treibstoff * factor;
+        }
+        if( tastatur[ T_ROT_L ] )
+        {
+            Vertex hp;
+            Vertex mv;
+            float r;
+            double treibstoff = 1.5 * ( ( wendigkeit + team->wendigkeit ) / 5 )
+                * zeit * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
+            treibstoffVerbraucht += treibstoff;
+            double factor = 1;
+            if( treibstoff > energie )
+                factor = energie / treibstoff;
+            if( ship->zModel()->calcHitPoint( stR, kR * (float)( wendigkeit + team->wendigkeit ), ( char* )"ship", hp, mv, r ) )
+            {
+                rSpeed += r * (float)zeit * (float)factor;
+                speed += ( Vec2<double> )mv.rotation( (float)rotation ) * zeit * factor;
+            }
+            energie -= treibstoff * factor;
+        }
+        rotation += rSpeed * (float)zeit;
+        ship->setDrehung( (float)rotation );
+        if( speed.x || speed.y )
+        {
+            pos += speed * zeit;
+            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;
+            ship->setPosition( pos );
+        }
+        if( !energieAbk )
+        {
+            energie += ( akkuLeistung + team->akkuLeistung ) * zeit;
+            if( energie > ( maxEnergie + team->maxEnergie ) )
+                energie = ( maxEnergie + team->maxEnergie );
+        }
+        if( !repAbk )
+        {
+            stability += ( reparatur + team->reparatur ) * zeit;
+            if( stability > ( maxStability + team->maxStability ) )
+                stability = ( maxStability + team->maxStability );
+        }
+        zeitAmLeben += zeit;
+    }
+    else
+        zeitTod += zeit;
+    return 0;
+}
+
+bool Spieler::setSkill( int art )
+{
+    if( !skillPunkte )
+        return 0;
+    skillPunkte--;
+    switch( art )
+    {
+    case 0: // Max Stabilität
+        maxStability += 10;
+        stability += 10;
+        team->maxStability = team->getMaxStabilityBonus();
+        break;
+    case 1: // Max Energie
+        maxEnergie += 10;
+        team->maxEnergie = team->getMaxEnergieBonus();
+        break;
+    case 2: // Reparatur
+        reparatur += 0.15;
+        team->reparatur = team->getReperaturBonus();
+        break;
+    case 3: // Laser Intensität
+        laserIntensity += 3;
+        team->laserIntensity = team->getLaserIntensityBonus();
+        break;
+    case 4: // Laser Effizienz
+        laserEffizienz += 1;
+        team->laserEffizienz = team->getLaserEffizienzBonus();
+        break;
+    case 5: // Laser Tempo
+        laserTempo += 20;
+        team->laserTempo = team->getLaserTempoBonus();
+        break;
+    case 6: // Beschleunigung
+        beschleunigung += 1;
+        team->beschleunigung = team->getBeschleunigungBonus();
+        break;
+    case 7: // Wendigkeit
+        wendigkeit += 0.25;
+        team->wendigkeit = team->getWendigkeitBonus();
+        break;
+    case 8: // Netzwerk
+        netzwerk += 1;
+        team->maxStability = team->getMaxStabilityBonus();
+        team->maxEnergie = team->getMaxEnergieBonus();
+        team->reparatur = team->getReperaturBonus();
+        team->laserIntensity = team->getLaserIntensityBonus();
+        team->laserEffizienz = team->getLaserEffizienzBonus();
+        team->laserTempo = team->getLaserTempoBonus();
+        team->beschleunigung = team->getBeschleunigungBonus();
+        team->wendigkeit = team->getWendigkeitBonus();
+        team->akkuLeistung = team->getAkkuLeistungBonus();
+        team->antriebEffizienz = team->getAntriebEffizienzBonus();
+        break;
+    case 9: // Akkuleistung
+        akkuLeistung += 0.12;
+        team->akkuLeistung = team->getAkkuLeistungBonus();
+        break;
+    case 10: // Akkuleistung
+        antriebEffizienz += 10;
+        team->antriebEffizienz = team->getAntriebEffizienzBonus();
+        break;
+    }
+    return 1;
+}
+
+Laser *Spieler::getLaser( int sId )
+{
+    if( !amLeben || !tastatur[ T_FEUER ] || schussAbk || !team )
+        return 0;
+    double kosten = ( ( laserIntensity + team->laserIntensity ) / 2 + ( laserTempo + team->laserTempo ) / 13 ) * ( 1 / ( ( laserEffizienz + team->laserEffizienz ) / 25 ) );
+    if( kosten < 1 )
+        kosten = 1;
+    if( kosten > energie )
+        return 0;
+    energie -= kosten;
+    schussAbk = 1;
+    energieAbk = 1.5;
+    shots++;
+    Vec2< double > sSpeed = ( Vec2<double>( cos( rotation ), sin( rotation ) ) * ( laserTempo + team->laserTempo ) );
+    sSpeed += speed;
+    return new Laser( sId, pos, sSpeed, sNum, laserIntensity + team->laserIntensity );
+}
+
+bool Spieler::nimmSchaden( double intensity )
+{
+    std::cout << "Schaden: " << intensity << " ";
+    stability -= intensity;
+    std::cout << "Stabilität: " << stability << "\n";
+    schadenBekommen += intensity;
+    repAbk = 2;
+    if( stability <= 0 )
+    {
+        amLeben = 0;
+        tode++;
+        stability = 0;
+        reinkAbk += maxReinkAbk;
+        maxReinkAbk++;
+        punkte--;
+    }
+    return stability == 0;
+}
+
+void Spieler::machSchaden( double intensity, bool kill )
+{
+    schadenGemacht += intensity;
+    treffer++;
+    if( kill )
+    {
+        skillPunkte += 2;
+        kills++;
+        punkte++;
+        maxReinkAbk--;
+        if( maxReinkAbk < 5 )
+            maxReinkAbk = 5;
+    }
+}
+
+// constant
+int Spieler::getAccountId() const
+{
+    return accountId;
+}
+
+bool Spieler::istOnline() const
+{
+    return klient ? klient->istOnline() : 0;
+}
+
+Klient *Spieler::zKlient() const
+{
+    return klient;
+}
+
+bool Spieler::istTreffer( Vec2< float > pos ) const
+{
+    if( !amLeben )
+        return 0;
+    return ship->istPunktInnen( pos );
+}
+
+// Raumschiff Eigenschaften
+Vec2< double > Spieler::getPos() const
+{
+    return pos;
+}
+
+Vec2< double > Spieler::getSpeed() const
+{
+    return speed;
+}
+
+double Spieler::getRotation() const
+{
+    return rotation;
+}
+
+double Spieler::getTeamMaxEnergieBonus() const
+{
+    return maxEnergie / 100 * netzwerk;
+}
+
+double Spieler::getTeamMaxStabilityBonus() const
+{
+    return maxStability / 100 * netzwerk;
+}
+
+double Spieler::getTeamReparaturBonus() const
+{
+    return reparatur / 100 * netzwerk;
+}
+
+double Spieler::getTeamLaserIntensityBonus() const
+{
+    return laserIntensity / 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;
+}
+
+double Spieler::getTeamAntriebEffizienzBonus() const
+{
+    return antriebEffizienz / 100 * netzwerk;
+}
+
+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::getShots() const
+{
+    return shots;
+}
+
+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;
+}
+
+// Reference Counting
+Spieler *Spieler::getThis()
+{
+    ref++;
+    return this;
+}
+
+Spieler *Spieler::release()
+{
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
+}

Asteroids/Spieler.h

@@ -0,0 +1,145 @@
+#ifndef Spieler_H
+#define Spieler_H
+
+#include <Bild.h>
+#include <Model2D.h>
+#include "Strukturen.h"
+
+class Team;
+class Laser;
+class Karte;
+class Klient;
+class SSKlientV;
+
+using namespace Framework;
+
+enum TastaturStatus
+{
+	T_GAS,
+	T_ROT_L,
+	T_ROT_R,
+	T_FEUER,
+	T_MAX
+};
+
+class Spieler
+{
+private:
+    // antrieb
+    Vertex stL;
+    Vertex kL;
+    Vertex stR;
+    Vertex kR;
+    Vertex stM;
+    Vertex kM;
+    float rSpeed;
+
+	int accountId;
+	int sNum;
+	int farbe;
+	Model2D *ship;
+	Team *team;
+	Klient *klient;
+	bool tastatur[ T_MAX ];
+	bool amLeben;
+	double schussAbk;
+    double energieAbk;
+	double repAbk;
+	double reinkAbk;
+	int maxReinkAbk;
+	int ref;
+	// Raumschiff Eigenschaften
+	Vec2< double > startPos;
+	Vec2< double > pos;
+	Vec2< double > speed;
+	double rotation;
+	double beschleunigung;
+    double beschleunigungStart;
+	double energie;
+	double stability;
+	double reparatur;
+	double laserIntensity;
+	double laserEffizienz;
+	double akkuLeistung;
+    double akkuLeistungStart;
+	double maxEnergie;
+	double maxStability;
+	double laserTempo;
+	double netzwerk;
+	double wendigkeit;
+    double wendigkeitStart;
+    double antriebEffizienz;
+	int skillPunkte;
+	// Statistik Werte
+	double schadenBekommen;
+	double schadenGemacht;
+	double treibstoffVerbraucht;
+	int shots;
+	int treffer;
+	int punkte;
+	int kills;
+	int tode;
+	double zeitAmLeben;
+	double zeitTod;
+
+public:
+	// Konstruktor
+	Spieler( SpielerStr *zStr );
+	// Destruktor
+	~Spieler();
+	// nicht constant
+	void offline();
+	void online( SSKlientV *zKlient );
+	void setModelData( Model2DData *data );
+	void setAccountId( int id );
+	void setTeam( Team *team );
+	void setSpielerFarbe( int farbe );
+	void setGeschwindigkeit( double xSpeed, double ySpeed );
+	void setPosition( Vec2< double > p );
+	void setKlient( Klient *klient );
+	bool setTastataturStatus( TastaturStatus ts, bool aktiv );
+	int tick( double zeit, Karte *zMap );
+	bool setSkill( int art );
+	Laser *getLaser( int sId );
+	bool nimmSchaden( double intensity );
+	void machSchaden( double intensity, bool kill );
+	// constant
+	int getAccountId() const;
+	bool istOnline() const;
+	Klient *zKlient() const;
+	bool istTreffer( Vec2< float > pos ) const;
+	// Raumschiff Eigenschaften
+	Vec2< double > getPos() const;
+	Vec2< double > getSpeed() const;
+	double getRotation() const;
+	double getTeamMaxEnergieBonus() const;
+	double getTeamMaxStabilityBonus() const;
+	double getTeamReparaturBonus() const;
+	double getTeamLaserIntensityBonus() const;
+	double getTeamLaserEffizienzBonus() const;
+	double getTeamAkkuLeistungBonus() const;
+	double getTeamLaserTempoBonus() const;
+	double getTeamBeschleunigungBonus() const;
+	double getTeamWendigkeitBonus() const;
+    double getTeamAntriebEffizienzBonus() 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 getShots() const;
+	int getTreffer() const;
+	int getPunkte() const;
+	int getKills() const;
+	int getTode() const;
+	int getZeitAmLeben() const;
+	int getZeitTod() const;
+	// Reference Counting
+	Spieler *getThis();
+	Spieler *release();
+};
+
+#endif

Asteroids/SpielerStatistik.cpp

@@ -0,0 +1,167 @@
+#include "SpielerStatistik.h"
+
+// Inhalt der SpielerStatistik Klasse aus SpielerStatistik.h
+// Konstruktor
+SpielerStatistik::SpielerStatistik()
+{
+	spielerNummer = 0;
+	spielerName = new Text();
+	teamName = new Text();
+	spielerFarbe = 0;
+	teamFarbe = 0;
+	schadenBekommen = 0;
+	schadenGemacht = 0;
+	treibstoffVerbraucht = 0;
+	shots = 0;
+	treffer = 0;
+	punkte = 0;
+	kills = 0;
+	tode = 0;
+	zeitAmLeben = 0;
+	zeitTod = 0;
+	ref = 1;
+}
+
+// Destruktor
+SpielerStatistik::~SpielerStatistik()
+{
+	spielerName->release();
+	teamName->release();
+}
+
+// nicht constant
+void SpielerStatistik::initValues( InitDatei *dat )
+{
+	if( dat->wertExistiert( "SpielerNummer" ) )
+		spielerNummer = *dat->zWert( "SpielerNummer" );
+	if( dat->wertExistiert( "SpielerName" ) )
+		*spielerName = dat->zWert( "SpielerName" )->getText();
+	if( dat->wertExistiert( "TeamName" ) )
+		*teamName = dat->zWert( "TeamName" )->getText();
+	if( dat->wertExistiert( "SpielerFarbe" ) )
+		spielerFarbe = *dat->zWert( "SpielerFarbe" );
+	if( dat->wertExistiert( "TeamFarbe" ) )
+		teamFarbe = *dat->zWert( "TeamFarbe" );
+	if( dat->wertExistiert( "SchadenBekommen" ) )
+		schadenBekommen = *dat->zWert( "SchadenBekommen" );
+	if( dat->wertExistiert( "SchadenGemacht" ) )
+		schadenGemacht = *dat->zWert( "SchadenGemacht" );
+	if( dat->wertExistiert( "TreibstoffVerbraucht" ) )
+		treibstoffVerbraucht = *dat->zWert( "TreibstoffVerbraucht" );
+	if( dat->wertExistiert( "Schüsse" ) )
+		shots = *dat->zWert( "Schüsse" );
+	if( dat->wertExistiert( "Treffer" ) )
+		treffer = *dat->zWert( "Treffer" );
+	if( dat->wertExistiert( "Punkte" ) )
+		punkte = *dat->zWert( "Punkte" );
+	if( dat->wertExistiert( "Kills" ) )
+		kills = *dat->zWert( "Kills" );
+	if( dat->wertExistiert( "Tode" ) )
+		tode = *dat->zWert( "Tode" );
+	if( dat->wertExistiert( "ZeitAmLeben" ) )
+		zeitAmLeben = *dat->zWert( "ZeitAmLeben" );
+	if( dat->wertExistiert( "ZeitTod" ) )
+		zeitTod = *dat->zWert( "ZeitTod" );
+	dat->release();
+}
+
+// constant
+int SpielerStatistik::getSpielerNummer() const
+{
+	return spielerNummer;
+}
+
+Text *SpielerStatistik::getSpielerName() const
+{
+	return spielerName ? spielerName->getThis() : 0;
+}
+
+Text *SpielerStatistik::zSpielerName() const
+{
+	return spielerName;
+}
+
+Text *SpielerStatistik::getTeamName() const
+{
+	return teamName ? teamName->getThis() : 0;
+}
+
+Text *SpielerStatistik::zTeamName() const
+{
+	return teamName;
+}
+
+int SpielerStatistik::getSpielerFarbe() const
+{
+	return spielerFarbe;
+}
+
+int SpielerStatistik::getTeamFarbe() const
+{
+	return teamFarbe;
+}
+
+int SpielerStatistik::getSchadenBekommen() const
+{
+	return schadenBekommen;
+}
+
+int SpielerStatistik::getSchadenGemacht() const
+{
+	return schadenGemacht;
+}
+
+int SpielerStatistik::getTreibstoffVerbraucht() const
+{
+	return treibstoffVerbraucht;
+}
+
+int SpielerStatistik::getShots() const
+{
+	return shots;
+}
+
+int SpielerStatistik::getTreffer() const
+{
+	return treffer;
+}
+
+int SpielerStatistik::getPunkte() const
+{
+	return punkte;
+}
+
+int SpielerStatistik::getZeitAmLeben() const
+{
+	return zeitAmLeben;
+}
+
+int SpielerStatistik::getZeitTod() const
+{
+	return zeitTod;
+}
+
+int SpielerStatistik::getKills() const
+{
+	return kills;
+}
+
+int SpielerStatistik::getTode() const
+{
+	return tode;
+}
+
+// Reference Counting
+SpielerStatistik *SpielerStatistik::getThis()
+{
+	ref++;
+	return this;
+}
+
+SpielerStatistik *SpielerStatistik::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/SpielerStatistik.h

@@ -0,0 +1,59 @@
+#ifndef SpielerStatistik_H
+#define SpielerStatistik_H
+
+#include <Text.h>
+#include <InitDatei.h>
+
+using namespace Framework;
+
+class SpielerStatistik
+{
+private:
+	int spielerNummer;
+	Text *spielerName;
+	Text *teamName;
+	int spielerFarbe;
+	int teamFarbe;
+	int schadenBekommen;
+	int schadenGemacht;
+	int treibstoffVerbraucht;
+	int shots;
+	int treffer;
+	int punkte;
+	int kills;
+	int tode;
+	int zeitAmLeben;
+	int zeitTod;
+	int ref;
+
+public:
+	// Konstruktor
+	SpielerStatistik();
+	// Destruktor
+	~SpielerStatistik();
+	// nicht constant
+	void initValues( InitDatei *dat );
+	// constant
+	int getSpielerNummer() const;
+	Text *getSpielerName() const;
+	Text *zSpielerName() const;
+	Text *getTeamName() const;
+	Text *zTeamName() const;
+	int getSpielerFarbe() const;
+	int getTeamFarbe() const;
+	int getSchadenBekommen() const;
+	int getSchadenGemacht() const;
+	int getTreibstoffVerbraucht() const;
+	int getShots() const;
+	int getTreffer() const;
+	int getPunkte() const;
+	int getZeitAmLeben() const;
+	int getZeitTod() const;
+	int getKills() const;
+	int getTode() const;
+	// Reference Counting
+	SpielerStatistik *getThis();
+	SpielerStatistik *release();
+};
+
+#endif

Asteroids/Statistik.cpp

@@ -0,0 +1,339 @@
+#include <DateiSystem.h>
+#include <Datei.h>
+#include "Spieler.h"
+#include "Team.h"
+#include "SSKlient.h"
+#ifndef WIN32
+#define Sleep( x )    usleep( (x) * 1000 )
+#endif
+#include "Statistik.h"
+
+// Inhalt der Statistik Klasse aus Statistik.h
+// Konstruktor
+Statistik::Statistik()
+{
+	spielId = 0;
+	karteId = 0;
+	db = 0;
+	spielerAnzahl = 0;
+	spieler = new RCArray< Spieler >();
+	erstellt = 0;
+	sOnline = new Array< bool >();
+	sBereit = new Array< bool >();
+	gss = new RCArray< SpielerStatistik >();
+	gts = new RCArray< TeamStatistik >();
+	teamNamen = 0;
+	gewinnerTeam = 0;
+	ref = 1;
+}
+
+// Destruktor
+Statistik::~Statistik()
+{
+	if( db )
+		db->release();
+	spieler->release();
+	sOnline->release();
+	sBereit->release();
+	gss->release();
+	gts->release();
+	if( teamNamen )
+		teamNamen->release();
+}
+
+// privat
+void Statistik::sendeStatistik( int index )
+{ // Sendet Statistik an Spieler index
+	if( !sOnline->hat( index ) || !sOnline->get( index ) )
+		return;
+	Klient *zk = spieler->z( index )->zKlient();
+	if( !zk )
+		return;
+	int anz = gss->getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+		zk->sendeSpielerStatistik( gss->z( i ) );
+	anz = gts->getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+		zk->sendeTeamStatistik( gts->z( i ) );
+	zk->sendeStatistikLadenFertig();
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		if( !sOnline->hat( i ) || !sOnline->get( i ) )
+			zk->sendeStatistikSpielerOffline( spieler->z( i )->getAccountId() );
+	}
+}
+
+// nicht constant
+void Statistik::setSpielId( int id )
+{
+	spielId = id;
+}
+
+void Statistik::setKarteId( int id )
+{
+	karteId = id;
+}
+
+void Statistik::setPSQLDB( SSDatenbankV *db )
+{
+	if( this->db )
+		this->db->release();
+	this->db = db;
+}
+
+void Statistik::setTeamNamen( RCArray< Text > *namen )
+{
+	if( teamNamen )
+		teamNamen->release();
+	teamNamen = namen;
+}
+
+void Statistik::spielEnde( int team )
+{
+	gewinnerTeam = team;
+}
+
+void Statistik::setSpieler( int anzahl, RCArray< Spieler > *zSpieler )
+{
+	spielerAnzahl = anzahl;
+	for( int i = 0; i < anzahl; i++ )
+	{
+		spieler->set( zSpieler->get( i ), i );
+		sOnline->set( 0, i );
+		sBereit->set( 0, i );
+	}
+}
+
+void Statistik::klientOffline( int accountId )
+{
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		if( spieler->z( i )->getAccountId() == accountId )
+		{
+			sOnline->set( 0, i );
+			sBereit->set( 0, i );
+		}
+		else if( sOnline->hat( i ) && sOnline->get( i ) && spieler->z( i )->zKlient() )
+			spieler->z( i )->zKlient()->sendeStatistikSpielerOffline( accountId );
+	}
+}
+
+void Statistik::statistikAnfrage( int accountId, short len, char *bytes )
+{
+	len--;
+	switch( *bytes )
+	{
+	case 0: // Spieler ist Bereit
+		for( int i = 0; i < spielerAnzahl; i++ )
+		{
+			if( !erstellt )
+			{
+				if( spieler->z( i )->getAccountId() == accountId )
+					sBereit->set( 1, i );
+			}
+			else if( spieler->z( i )->getAccountId() == accountId )
+			{
+				sendeStatistik( i );
+				break;
+			}
+		}
+		break;
+	case 1: // Chat Nachricht
+		bytes++;
+		char *txt = new char[ len + 1 ];
+		txt[ len ] = 0;
+		for( int i = 0; i < len; i++ )
+			txt[ i ] = bytes[ i ];
+		for( int i = 0; i < spielerAnzahl; i++ )
+		{
+			if( sOnline->hat( i ) && sOnline->get( i ) && spieler->z( i )->zKlient() )
+				spieler->z( i )->zKlient()->sendeStatistikChatNachricht( accountId, txt );
+		}
+		delete[] txt;
+		break;
+	}
+}
+
+void Statistik::run()
+{
+	for( int i = 0; i < spielerAnzahl; i++ )
+		sOnline->set( spieler->z( i )->istOnline(), i );
+	// Statistik erstellen
+	// gesammt Spieler
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		if( spieler->z( i ) )
+		{
+			Spieler *tmp = spieler->z( i );
+			InitDatei *d = new InitDatei();
+			Text w;
+			w = tmp->getSpielerNummer();
+			if( w.getLength() )
+				d->addWert( "SpielerNummer", w.getText() );
+			Text *sn = db->getAccountRufName( tmp->getAccountId() );
+			if( sn && sn->getLength() )
+				d->addWert( "SpielerName", sn->getText() );
+			if( sn )
+				sn->release();
+			d->addWert( "TeamName", tmp->zTeam()->name );
+			w = tmp->getSpielerFarbe();
+			if( w.getLength() )
+				d->addWert( "SpielerFarbe", w.getText() );
+			w = tmp->zTeam()->farbe;
+			if( w.getLength() )
+				d->addWert( "TeamFarbe", w.getText() );
+			w = tmp->getSchadenBekommen();
+			if( w.getLength() )
+				d->addWert( "SchadenBekommen", w.getText() );
+			w = tmp->getSchadenGemacht();
+			if( w.getLength() )
+				d->addWert( "SchadenGemacht", w.getText() );
+			w = tmp->getTreibstoffVerbraucht();
+			if( w.getLength() )
+				d->addWert( "TreibstoffVerbraucht", w.getText() );
+			w = tmp->getShots();
+			if( w.getLength() )
+				d->addWert( "Schüsse", w.getText() );
+			w = tmp->getTreffer();
+			if( w.getLength() )
+				d->addWert( "Treffer", w.getText() );
+			w = tmp->getPunkte();
+			if( w.getLength() )
+				d->addWert( "Punkte", w.getText() );
+			w = tmp->getKills();
+			if( w.getLength() )
+				d->addWert( "Kills", w.getText() );
+			w = tmp->getTode();
+			if( w.getLength() )
+				d->addWert( "Tode", w.getText() );
+			w = tmp->getZeitAmLeben();
+			if( w.getLength() )
+				d->addWert( "ZeitAmLeben", w.getText() );
+			w = tmp->getZeitTod();
+			if( w.getLength() )
+				d->addWert( "ZeitTod", w.getText() );
+			SpielerStatistik *gss = new SpielerStatistik();
+			gss->initValues( d );
+			this->gss->add( gss );
+		}
+	}
+	// Gesamt Team
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		Spieler *tmp = spieler->z( i );
+		if( tmp )
+		{
+			int anz = gts->getEintragAnzahl();
+			bool gefunden = 0;
+			for( int j = 0; j < anz; j++ )
+			{
+				if( gts->z( j ) && gts->z( j )->getTeamNummer() == tmp->zTeam()->id )
+				{
+					gefunden = 1;
+					break;
+				}
+			}
+			if( gefunden )
+				continue;
+			InitDatei *d = new InitDatei();
+			Text w;
+			w = tmp->zTeam()->id;
+			if( w.getLength() )
+				d->addWert( "TeamNummer", w.getText() );
+			d->addWert( "TeamName", tmp->zTeam()->name );
+			w = tmp->zTeam()->farbe;
+			if( w.getLength() )
+				d->addWert( "TeamFarbe", w.getText() );
+			int schadenBekommen = 0;
+			int schadenGemacht = 0;
+			int treibstoffVerbraucht = 0;
+			int shots = 0;
+			int treffer = 0;
+			int punkte = 0;
+			int kills = 0;
+			int tode = 0;
+			for( int j = 0; j < spielerAnzahl; j++ )
+			{
+				Spieler *s = spieler->z( j );
+				if( s && s->zTeam()->id == tmp->zTeam()->id )
+				{
+					schadenBekommen += s->getSchadenBekommen();
+					schadenGemacht += s->getSchadenGemacht();
+					treibstoffVerbraucht += s->getTreibstoffVerbraucht();
+					shots += s->getShots();
+					treffer += s->getTreffer();
+					punkte += s->getPunkte();
+					kills += s->getKills();
+					tode += s->getTode();
+				}
+			}
+			w = schadenBekommen;
+			if( w.getLength() )
+				d->addWert( "SchadenBekommen", w.getText() );
+			w = schadenGemacht;
+			if( w.getLength() )
+				d->addWert( "SchadenGemacht", w.getText() );
+			w = treibstoffVerbraucht;
+			if( w.getLength() )
+				d->addWert( "TreibstoffVerbraucht", w.getText() );
+			w = shots;
+			if( w.getLength() )
+				d->addWert( "Schüsse", w.getText() );
+			w = treffer;
+			if( w.getLength() )
+				d->addWert( "Treffer", w.getText() );
+			w = punkte;
+			if( w.getLength() )
+				d->addWert( "Punkte", w.getText() );
+			w = kills;
+			if( w.getLength() )
+				d->addWert( "Kills", w.getText() );
+			w = tode;
+			if( w.getLength() )
+				d->addWert( "Tode", w.getText() );
+			w = (int)( gewinnerTeam == tmp->zTeam()->id );
+			if( w.getLength() )
+				d->addWert( "Gewonnen", w.getText() );
+			TeamStatistik *gts = new TeamStatistik();
+			gts->initValues( d );
+			this->gts->add( gts );
+		}
+	}
+	erstellt = 1;
+	// Statistik senden
+	for( int i = 0; i < spielerAnzahl; i++ )
+	{
+		if( sBereit->hat( i ) && sBereit->get( i ) )
+			sendeStatistik( i );
+	}
+	// Statistik speichern
+	Text *pfad = new Text( "../spiel log/" );
+	pfad->append( spielId );
+	pfad->append( "/fertig" );
+	DateiPfadErstellen( pfad );
+	// warten bis alle verlassen haben
+	while( 1 )
+	{
+		Sleep( 1000 );
+		int online = 0;
+		for( int i = 0; i < spielerAnzahl; i++ )
+			online += sOnline->hat( i ) && sOnline->get( i );
+		if( !online )
+			break;
+	}
+}
+
+// Reference Counting
+StatistikV *Statistik::getThis()
+{
+	ref++;
+	return this;
+}
+
+StatistikV *Statistik::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Statistik.h

@@ -0,0 +1,49 @@
+#ifndef Statistik_H
+#define Statistik_H
+
+#include "StatistikKlasse.h"
+#include "Spieler.h"
+#include "SSDatenbankV.h"
+#include "SpielerStatistik.h"
+#include "TeamStatistik.h"
+
+class Statistik : public StatistikV
+{
+private:
+	int spielId;
+	int karteId;
+	SSDatenbankV *db;
+	int spielerAnzahl;
+	RCArray< Spieler > *spieler;
+	bool erstellt;
+	Array< bool > *sOnline;
+	Array< bool > *sBereit;
+	RCArray< SpielerStatistik > *gss;
+	RCArray< TeamStatistik > *gts;
+	RCArray< Text > *teamNamen;
+	int gewinnerTeam;
+	int ref;
+
+	void sendeStatistik( int index );
+
+public:
+	// Konstruktor
+	Statistik();
+	// Destruktor
+	~Statistik();
+	// nicht constant
+	void setSpielId( int id );
+	void setKarteId( int id );
+	void setPSQLDB( SSDatenbankV *db );
+	void setTeamNamen( RCArray< Text > *namen );
+	void spielEnde( int team );
+	void setSpieler( int anzahl, RCArray< Spieler > *zSpieler );
+	virtual void klientOffline( int accountId );
+	virtual void statistikAnfrage( int accountId, short len, char *bytes );
+	virtual void run();
+	// Reference Counting
+	virtual StatistikV *getThis();
+	virtual StatistikV *release();
+};
+
+#endif

Asteroids/StatistikKlasse.h

@@ -0,0 +1,23 @@
+#ifndef StatistikKlasse_H
+#define StatistikKlasse_H
+
+class StatistikV
+{
+private:
+
+public:
+	virtual ~StatistikV()
+	{
+	}
+	// nicht constant
+	virtual void klientOffline( int accountId ) = 0;
+	virtual void statistikAnfrage( int accountId, short len, char *bytes ) = 0;
+	virtual void run() = 0;
+	// constant
+
+	// Reference Counting
+	virtual StatistikV *getThis() = 0;
+	virtual StatistikV *release() = 0;
+};
+
+#endif

Asteroids/Strukturen.cpp

@@ -0,0 +1,260 @@
+#include "Strukturen.h"
+#include <M2Datei.h>
+#include <DateiSystem.h>
+#include <Text.h>
+
+// Inhalt der RessourceStr Klasse aus Strukturen.h
+// Konstruktor
+RessourceStr::RessourceStr( Datei *zDatei, SSDatenbankV *zDb, char *tmpPfad, int kId )
+{
+	zDatei->lese( (char*)&id, 4 );
+	char len = 0;
+	zDatei->lese( &len, 1 );
+	Text txt;
+	txt.fillText( '0', len + 1 );
+	zDatei->lese( txt, len );
+	txt.getText()[ (int)len ] = 0;
+	pfad = 0;
+	if( txt.positionVon( "spiel:" ) == 0 )
+	{
+        pfad = zDb->getSpielPfad( kId );
+        if( pfad )
+            pfad->append( "/" );
+		if( pfad )
+			pfad->append( txt.getTeilText( 7 ) );
+	}
+	if( txt.positionVon( "map:" ) == 0 )
+	{
+		pfad = new Text( tmpPfad );
+		if( pfad )
+			pfad->append( txt.getTeilText( 5 ) );
+	}
+	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();
+	}
+	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 ObjektStr Klasse aus Strukturen.h
+// Konstruktor
+ObjektStr::ObjektStr( Datei *zDatei )
+{
+    if( 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*)&maxStability, 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;
+}
+
+void ObjektStr::save( Datei *zDatei ) const
+{
+    zDatei->schreibe( (char*)&pos.x, 4 );
+    zDatei->schreibe( (char*)&pos.y, 4 );
+    zDatei->schreibe( (char*)&id, 4 );
+    zDatei->schreibe( (char*)&m2d, 4 );
+    zDatei->schreibe( (char*)&bild, 4 );
+    zDatei->schreibe( (char*)&style, 4 );
+    zDatei->schreibe( (char*)&maxStability, 4 );
+    zDatei->schreibe( (char*)&maxEnergie, 4 );
+    zDatei->schreibe( (char*)&energieRadius, 4 );
+    zDatei->schreibe( (char*)&reparatur, 8 );
+    zDatei->schreibe( (char*)&akkuLeistung, 8 );
+    zDatei->schreibe( (char*)&team, 1 );
+}
+
+// Reference Counting
+ObjektStr *ObjektStr::getThis()
+{
+	ref++;
+	return this;
+}
+
+ObjektStr *ObjektStr::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}
+
+
+// Inhalt der SpielerStr Klasse aus Strukturen.h
+// Konstruktor
+SpielerStr::SpielerStr( Datei *zDatei )
+{
+    if( 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*)&maxStability, 4 );
+        zDatei->lese( (char*)&maxEnergie, 4 );
+        zDatei->lese( (char*)&reparatur, 8 );
+        zDatei->lese( (char*)&akkuLeistung, 8 );
+        zDatei->lese( (char*)&laserIntensity, 4 );
+        zDatei->lese( (char*)&laserEffizienz, 4 );
+        zDatei->lese( (char*)&laserTempo, 4 );
+        zDatei->lese( (char*)&wendigkeit, 8 );
+        zDatei->lese( (char*)&antriebEffizienz, 8 );
+        zDatei->lese( (char*)&netzwerk, 4 );
+        zDatei->lese( (char*)&skillPunkte, 4 );
+        zDatei->lese( (char*)&m2d, 4 );
+        zDatei->lese( (char*)&bild, 4 );
+    }
+    ref = 1;
+}
+
+void SpielerStr::save( Datei *zDatei ) const
+{
+    zDatei->schreibe( (char*)&id, 4 );
+    zDatei->schreibe( (char*)&pos.x, 4 );
+    zDatei->schreibe( (char*)&pos.y, 4 );
+    zDatei->schreibe( (char*)&rot, 8 );
+    zDatei->schreibe( (char*)&beschleunigung, 8 );
+    zDatei->schreibe( (char*)&maxStability, 4 );
+    zDatei->schreibe( (char*)&maxEnergie, 4 );
+    zDatei->schreibe( (char*)&reparatur, 8 );
+    zDatei->schreibe( (char*)&akkuLeistung, 8 );
+    zDatei->schreibe( (char*)&laserIntensity, 4 );
+    zDatei->schreibe( (char*)&laserEffizienz, 4 );
+    zDatei->schreibe( (char*)&laserTempo, 4 );
+    zDatei->schreibe( (char*)&wendigkeit, 8 );
+    zDatei->schreibe( (char*)&antriebEffizienz, 8 );
+    zDatei->schreibe( (char*)&netzwerk, 4 );
+    zDatei->schreibe( (char*)&skillPunkte, 4 );
+    zDatei->schreibe( (char*)&m2d, 4 );
+    zDatei->schreibe( (char*)&bild, 4 );
+}
+
+// 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 )
+{
+    if( zDatei )
+    {
+        zDatei->lese( (char*)&id, 4 );
+        zDatei->lese( (char*)&maxPunkte, 4 );
+        zDatei->lese( (char*)&beschleunigung, 8 );
+        zDatei->lese( (char*)&maxStability, 4 );
+        zDatei->lese( (char*)&maxEnergie, 4 );
+        zDatei->lese( (char*)&reparatur, 8 );
+        zDatei->lese( (char*)&akkuLeistung, 8 );
+        zDatei->lese( (char*)&laserIntensity, 4 );
+        zDatei->lese( (char*)&laserEffizienz, 4 );
+        zDatei->lese( (char*)&laserTempo, 4 );
+        zDatei->lese( (char*)&wendigkeit, 8 );
+        zDatei->lese( (char*)&antriebEffizienz, 8 );
+        zDatei->lese( (char*)&punkte, 4 );
+    }
+	ref = 1;
+}
+
+void TeamStr::save( Datei *zDatei ) const
+{
+    zDatei->schreibe( (char*)&id, 4 );
+    zDatei->schreibe( (char*)&maxPunkte, 4 );
+    zDatei->schreibe( (char*)&beschleunigung, 8 );
+    zDatei->schreibe( (char*)&maxStability, 4 );
+    zDatei->schreibe( (char*)&maxEnergie, 4 );
+    zDatei->schreibe( (char*)&reparatur, 8 );
+    zDatei->schreibe( (char*)&akkuLeistung, 8 );
+    zDatei->schreibe( (char*)&laserIntensity, 4 );
+    zDatei->schreibe( (char*)&laserEffizienz, 4 );
+    zDatei->schreibe( (char*)&laserTempo, 4 );
+    zDatei->schreibe( (char*)&wendigkeit, 8 );
+    zDatei->schreibe( (char*)&antriebEffizienz, 8 );
+    zDatei->schreibe( (char*)&punkte, 4 );
+}
+
+// Reference Counting
+TeamStr *TeamStr::getThis()
+{
+	ref++;
+	return this;
+}
+
+TeamStr *TeamStr::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Strukturen.h

@@ -0,0 +1,120 @@
+#ifndef Strukturen_H
+#define Strukturen_H
+
+#include <Model2D.h>
+#include <Bild.h>
+#include <Datei.h>
+#include "SSDatenbankV.h"
+
+using namespace Framework;
+
+class RessourceStr
+{
+private:
+	int id;
+	int ref;
+	Model2DData *m2d;
+	Bild *bild;
+	Text *pfad;
+
+public:
+	// Konstruktor
+    RessourceStr( Datei *zDatei, SSDatenbankV *zDb, char *tmpPfad, int kId );
+	// Destruktor
+	~RessourceStr();
+	// constant
+	int getId() const;
+	Model2DData *zReccourceM2() const;
+	Bild *zReccourceTxt() const;
+	// Reference Counting
+	RessourceStr *getThis();
+	RessourceStr *release();
+};
+
+class ObjektStr
+{
+private:
+	int ref;
+
+public:
+	Punkt pos;
+	int id;
+	int m2d;
+	int bild;
+	int style;
+	int maxStability;
+	int maxEnergie;
+	int energieRadius;
+	double reparatur;
+	double akkuLeistung;
+	char team;
+
+	// Konstruktor
+	ObjektStr( Datei *zDatei );
+    void save( Datei *zDatei ) const;
+	// Reference Counting
+	ObjektStr *getThis();
+	ObjektStr *release();
+};
+
+class SpielerStr
+{
+private:
+	int ref;
+
+public:
+	int id;
+	Punkt pos;
+	double rot;
+	double beschleunigung;
+	int maxStability;
+	int maxEnergie;
+	double reparatur;
+	double akkuLeistung;
+	int laserIntensity;
+	int laserEffizienz;
+	int laserTempo;
+	double wendigkeit;
+    double antriebEffizienz;
+	int netzwerk;
+	int skillPunkte;
+	int m2d;
+	int bild;
+
+	// Konstruktor
+	SpielerStr( Datei *zDatei );
+    void save( Datei *zDatei ) const;
+	// Reference Counting
+	SpielerStr *getThis();
+	SpielerStr *release();
+};
+
+class TeamStr
+{
+private:
+	int ref;
+
+public:
+	int id;
+	int maxPunkte;
+	double beschleunigung;
+	int maxStability;
+	int maxEnergie;
+	double reparatur;
+	double akkuLeistung;
+	int laserIntensity;
+	int laserEffizienz;
+	int laserTempo;
+	double wendigkeit;
+    double antriebEffizienz;
+	int punkte;
+
+	// Konstruktor
+	TeamStr( Datei *zDatei );
+    void save( Datei *zDatei ) const;
+	// Reference Counting
+	TeamStr *getThis();
+	TeamStr *release();
+};
+
+#endif

Asteroids/Team.cpp

@@ -0,0 +1,143 @@
+#include "Team.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;
+	maxStabilityS = zStr->maxStability;
+	reparaturS = zStr->reparatur;
+	laserIntensityS = zStr->laserIntensity;
+	laserEffizienzS = zStr->laserEffizienz;
+	akkuLeistungS = zStr->akkuLeistung;
+	laserTempoS = zStr->laserTempo;
+	beschleunigungS = zStr->beschleunigung;
+	wendigkeitS = zStr->wendigkeit;
+    antriebEffizienzS = zStr->antriebEffizienz;
+	reset();
+	ref = 1;
+}
+
+// Destruktor
+Team::~Team()
+{
+	spieler->release();
+}
+
+// nicht constant
+void Team::reset()
+{
+	spieler->leeren();
+	maxEnergie = maxEnergieS;
+	maxStability = maxStabilityS;
+	reparatur = reparaturS;
+	laserIntensity = laserIntensityS;
+	laserEffizienz = laserEffizienzS;
+	akkuLeistung = akkuLeistungS;
+	laserTempo = laserTempoS;
+	beschleunigung = beschleunigungS;
+	wendigkeit = wendigkeitS;
+    antriebEffizienz = antriebEffizienzS;
+}
+
+// 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::getMaxStabilityBonus() const
+{
+	double ret = maxStabilityS;
+	for( auto *i = &spieler->getArray(); i && i->set; i = i->next )
+		ret += i->var->getTeamMaxStabilityBonus();
+	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::getLaserIntensityBonus() const
+{
+	double ret = laserIntensityS;
+	for( auto *i = &spieler->getArray(); i && i->set; i = i->next )
+		ret += i->var->getTeamLaserIntensityBonus();
+	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;
+}
+
+double Team::getAntriebEffizienzBonus() const
+{
+    double ret = antriebEffizienzS;
+    for( auto *i = &spieler->getArray(); i && i->set; i = i->next )
+        ret += i->var->getTeamAntriebEffizienzBonus();
+    return ret;
+}
+
+// Reference Counting
+Team *Team::getThis()
+{
+	ref++;
+	return this;
+}
+
+Team *Team::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/Team.h

@@ -0,0 +1,63 @@
+#ifndef Team_H
+#define Team_H
+
+#include <Text.h>
+#include "Spieler.h"
+#include "Strukturen.h"
+
+class Team
+{
+private:
+	double maxEnergieS;
+	double maxStabilityS;
+	double reparaturS;
+	double laserIntensityS;
+	double laserEffizienzS;
+	double akkuLeistungS;
+	double laserTempoS;
+	double beschleunigungS;
+	double wendigkeitS;
+    double antriebEffizienzS;
+	int ref;
+
+public:
+	// variablen
+	int id;
+	int farbe;
+	Text name;
+	RCArray< Spieler > *spieler;
+	int punkte;
+	int maxPunkte;
+	double maxEnergie;
+	double maxStability;
+	double reparatur;
+	double laserIntensity;
+	double laserEffizienz;
+	double akkuLeistung;
+	double laserTempo;
+	double beschleunigung;
+	double wendigkeit;
+    double antriebEffizienz;
+	// Konstruktor
+	Team( int f, char *n, TeamStr *zStr );
+	// Destruktor
+	~Team();
+	// nicht constant
+	void reset();
+	// constant
+	double getMaxEnergieBonus() const;
+	double getMaxStabilityBonus() const;
+	double getReperaturBonus() const;
+	double getLaserIntensityBonus() const;
+	double getLaserEffizienzBonus() const;
+	double getAkkuLeistungBonus() const;
+	double getLaserTempoBonus() const;
+	double getBeschleunigungBonus() const;
+	double getWendigkeitBonus() const;
+    double getAntriebEffizienzBonus() const;
+	// Reference Counting
+	Team *getThis();
+	Team *release();
+};
+
+#endif

Asteroids/TeamStatistik.cpp

@@ -0,0 +1,137 @@
+#include "TeamStatistik.h"
+
+// Inhalt der TeamStatistik Klasse aus TeamStatistik.h
+// Konstruktor
+TeamStatistik::TeamStatistik()
+{
+	teamNummer = 0;
+	teamName = new Text();
+	teamFarbe = 0;
+	schadenBekommen = 0;
+	schadenGemacht = 0;
+	treibstoffVerbraucht = 0;
+	shots = 0;
+	treffer = 0;
+	punkte = 0;
+	kills = 0;
+	tode = 0;
+	gewonnen = 0;
+	ref = 1;
+}
+
+// Destruktor
+TeamStatistik::~TeamStatistik()
+{
+	teamName->release();
+}
+
+// nicht constant
+void TeamStatistik::initValues( InitDatei *dat )
+{
+	if( dat->wertExistiert( "TeamNummer" ) )
+		teamNummer = *dat->zWert( "TeamNummer" );
+	if( dat->wertExistiert( "TeamName" ) )
+		*teamName = dat->zWert( "TeamName" )->getText();
+	if( dat->wertExistiert( "TeamFarbe" ) )
+		teamFarbe = *dat->zWert( "TeamFarbe" );
+	if( dat->wertExistiert( "SchadenBekommen" ) )
+		schadenBekommen = *dat->zWert( "SchadenBekommen" );
+	if( dat->wertExistiert( "SchadenGemacht" ) )
+		schadenGemacht = *dat->zWert( "SchadenGemacht" );
+	if( dat->wertExistiert( "TreibstoffVerbraucht" ) )
+		treibstoffVerbraucht = *dat->zWert( "TreibstoffVerbraucht" );
+	if( dat->wertExistiert( "Schüsse" ) )
+		shots = *dat->zWert( "Schüsse" );
+	if( dat->wertExistiert( "Treffer" ) )
+		treffer = *dat->zWert( "Treffer" );
+	if( dat->wertExistiert( "Punkte" ) )
+		punkte = *dat->zWert( "Punkte" );
+	if( dat->wertExistiert( "Kills" ) )
+		kills = *dat->zWert( "Kills" );
+	if( dat->wertExistiert( "Tode" ) )
+		tode = *dat->zWert( "Tode" );
+	if( dat->wertExistiert( "Gewonnen" ) )
+		gewonnen = (int)*dat->zWert( "Tode" ) != 0;
+	dat->release();
+}
+
+// constant
+int TeamStatistik::getTeamNummer() const
+{
+	return teamNummer;
+}
+
+Text *TeamStatistik::getTeamName() const
+{
+	return teamName ? teamName->getThis() : 0;
+}
+
+Text *TeamStatistik::zTeamName() const
+{
+	return teamName;
+}
+
+int TeamStatistik::getTeamFarbe() const
+{
+	return teamFarbe;
+}
+
+int TeamStatistik::getSchadenBekommen() const
+{
+	return schadenBekommen;
+}
+
+int TeamStatistik::getSchadenGemacht() const
+{
+	return schadenGemacht;
+}
+
+int TeamStatistik::getTreibstoffVerbraucht() const
+{
+	return treibstoffVerbraucht;
+}
+
+int TeamStatistik::getShots() const
+{
+	return shots;
+}
+
+int TeamStatistik::getTreffer() const
+{
+	return treffer;
+}
+
+int TeamStatistik::getPunkte() const
+{
+	return punkte;
+}
+
+int TeamStatistik::getKills() const
+{
+	return kills;
+}
+
+int TeamStatistik::getTode() const
+{
+	return tode;
+}
+
+bool TeamStatistik::hatGewonnen() const
+{
+	return gewonnen;
+}
+
+// Reference Counting
+TeamStatistik *TeamStatistik::getThis()
+{
+	ref++;
+	return this;
+}
+
+TeamStatistik *TeamStatistik::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

Asteroids/TeamStatistik.h

@@ -0,0 +1,52 @@
+#ifndef TeamStatistik_H
+#define TeamStatistik_H
+
+#include <Text.h>
+#include <InitDatei.h>
+
+using namespace Framework;
+
+class TeamStatistik
+{
+private:
+	int teamNummer;
+	Text *teamName;
+	int teamFarbe;
+	int schadenBekommen;
+	int schadenGemacht;
+	int treibstoffVerbraucht;
+	int shots;
+	int treffer;
+	int punkte;
+	int kills;
+	int tode;
+	bool gewonnen;
+	int ref;
+
+public:
+	// Konstruktor
+	TeamStatistik();
+	// Destruktor
+	~TeamStatistik();
+	// nicht constant
+	void initValues( InitDatei *dat );
+	// constant
+	int getTeamNummer() const;
+	Text *getTeamName() const;
+	Text *zTeamName() const;
+	int getTeamFarbe() const;
+	int getSchadenBekommen() const;
+	int getSchadenGemacht() const;
+	int getTreibstoffVerbraucht() const;
+	int getShots() const;
+	int getTreffer() const;
+	int getPunkte() const;
+	int getKills() const;
+	int getTode() const;
+	bool hatGewonnen() const;
+	// Reference Counting
+	TeamStatistik *getThis();
+	TeamStatistik *release();
+};
+
+#endif

build.bat

@@ -0,0 +1,2 @@
+"D:\Visual Studio 2017\MSBuild\15.0\Bin\MSBuild.exe" "Asteroids Linux/Asteroids Linux.vcxproj" /t:rebuild /p:configuration=debug /p:platform=x64
+"D:\Visual Studio 2017\MSBuild\15.0\Bin\MSBuild.exe" "Asteroids Linux/Asteroids Linux.vcxproj" /t:rebuild /p:configuration=release /p:platform=x64