NoEdge/Danbias
NoEdge
/
Danbias
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'GameLogic' of https://github.com/dean11/Danbias into GameLogic 

Conflicts:
	Code/Game/DanBiasGame/GameClientState/GameState.cpp
	Code/Game/GameLogic/Game.cpp
This commit is contained in:
Erik Persson 2014-01-31 09:17:54 +01:00
parent c30db71e94 cec022b381
commit 31feccf284
128 changed files with 4233 additions and 3641 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Bin/Level.txt Normal file
View File

Binary file not shown.

0
Bin/Script/PLACEHOLDER
View File

2
Bin/Settings/ServerInit.ini
View File

@ -1,2 +0,0 @@
port 15151
clients 200

4
Bin/Settings/serversearchpath.ini
View File

@ -1,4 +0,0 @@
ServerInit ..\Settings\ServerInit.ini
More a
more b
more c

BIN
Bin/map Normal file
View File

Binary file not shown.

BIN
Bin/map.txt Normal file
View File

Binary file not shown.

33
Code/DanBias.sln
View File

@ -31,12 +31,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Game", "Game", "{20720CA7-7
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GameLogic", "Game\GameLogic\GameLogic.vcxproj", "{B1195BB9-B3A5-47F0-906C-8DEA384D1520}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DanBiasServer", "Game\DanBiasServer\DanBiasServer.vcxproj", "{52380DAA-0F4A-4D97-8E57-98DF39319CAF}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DanBiasLauncher", "Game\DanBiasLauncher\DanBiasLauncher.vcxproj", "{8690FDDF-C5B7-4C42-A337-BD5243F29B85}"
ProjectSection(ProjectDependencies) = postProject
{52380DAA-0F4A-4D97-8E57-98DF39319CAF} = {52380DAA-0F4A-4D97-8E57-98DF39319CAF}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "NetworkAPI", "Network\NetworkAPI\NetworkAPI.vcxproj", "{460D625F-2AC9-4559-B809-0BA89CEAEDF4}"
EndProject
@ -46,6 +41,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DanBiasServerLauncher", "Ga
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Physics lab", "Physics lab\Physics lab.vcxproj", "{5128BD77-6472-4C4A-BE6F-724AD0E589C2}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GameServer", "Game\GameServer\GameServer.vcxproj", "{143BD516-20A1-4890-A3E4-F8BFD02220E7}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "aDanBiasGameLauncher", "Game\aDanBiasGameLauncher\aDanBiasGameLauncher.vcxproj", "{666FEA52-975F-41CD-B224-B19AF3C0ABBA}"
EndProject
Global
@ -214,18 +211,6 @@ Global
{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Release|Win32.Build.0 = Release|Win32
{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Release|x64.ActiveCfg = Release|x64
{B1195BB9-B3A5-47F0-906C-8DEA384D1520}.Release|x64.Build.0 = Release|x64
{52380DAA-0F4A-4D97-8E57-98DF39319CAF}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
{52380DAA-0F4A-4D97-8E57-98DF39319CAF}.Debug|Mixed Platforms.Build.0 = Debug|Win32
{52380DAA-0F4A-4D97-8E57-98DF39319CAF}.Debug|Win32.ActiveCfg = Debug|Win32
{52380DAA-0F4A-4D97-8E57-98DF39319CAF}.Debug|Win32.Build.0 = Debug|Win32
{52380DAA-0F4A-4D97-8E57-98DF39319CAF}.Debug|x64.ActiveCfg = Debug|x64
{52380DAA-0F4A-4D97-8E57-98DF39319CAF}.Debug|x64.Build.0 = Debug|x64
{52380DAA-0F4A-4D97-8E57-98DF39319CAF}.Release|Mixed Platforms.ActiveCfg = Release|Win32
{52380DAA-0F4A-4D97-8E57-98DF39319CAF}.Release|Mixed Platforms.Build.0 = Release|Win32
{52380DAA-0F4A-4D97-8E57-98DF39319CAF}.Release|Win32.ActiveCfg = Release|Win32
{52380DAA-0F4A-4D97-8E57-98DF39319CAF}.Release|Win32.Build.0 = Release|Win32
{52380DAA-0F4A-4D97-8E57-98DF39319CAF}.Release|x64.ActiveCfg = Release|x64
{52380DAA-0F4A-4D97-8E57-98DF39319CAF}.Release|x64.Build.0 = Release|x64
{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Debug|Mixed Platforms.Build.0 = Debug|Win32
{8690FDDF-C5B7-4C42-A337-BD5243F29B85}.Debug|Win32.ActiveCfg = Debug|Win32
@ -286,6 +271,18 @@ Global
{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Release|Win32.Build.0 = Release|Win32
{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Release|x64.ActiveCfg = Release|x64
{5128BD77-6472-4C4A-BE6F-724AD0E589C2}.Release|x64.Build.0 = Release|x64
{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Debug|Mixed Platforms.Build.0 = Debug|Win32
{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Debug|Win32.ActiveCfg = Debug|Win32
{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Debug|Win32.Build.0 = Debug|Win32
{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Debug|x64.ActiveCfg = Debug|x64
{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Debug|x64.Build.0 = Debug|x64
{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Release|Mixed Platforms.ActiveCfg = Release|Win32
{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Release|Mixed Platforms.Build.0 = Release|Win32
{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Release|Win32.ActiveCfg = Release|Win32
{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Release|Win32.Build.0 = Release|Win32
{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Release|x64.ActiveCfg = Release|x64
{143BD516-20A1-4890-A3E4-F8BFD02220E7}.Release|x64.Build.0 = Release|x64
{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Debug|Mixed Platforms.Build.0 = Debug|Win32
{666FEA52-975F-41CD-B224-B19AF3C0ABBA}.Debug|Win32.ActiveCfg = Debug|Win32
@ -309,10 +306,10 @@ Global
{460D625F-2AC9-4559-B809-0BA89CEAEDF4} = {C27B926E-B3EF-4990-8822-47580E43A0BE}
{2A1BC987-AF42-4500-802D-89CD32FC1309} = {20720CA7-795C-45AD-A302-9383A6DD503A}
{B1195BB9-B3A5-47F0-906C-8DEA384D1520} = {20720CA7-795C-45AD-A302-9383A6DD503A}
{52380DAA-0F4A-4D97-8E57-98DF39319CAF} = {20720CA7-795C-45AD-A302-9383A6DD503A}
{8690FDDF-C5B7-4C42-A337-BD5243F29B85} = {20720CA7-795C-45AD-A302-9383A6DD503A}
{DA2AA800-ED64-4649-8B3B-E7F1E3968B78} = {20720CA7-795C-45AD-A302-9383A6DD503A}
{060B1890-CBF3-4808-BA99-A4776222093B} = {20720CA7-795C-45AD-A302-9383A6DD503A}
{143BD516-20A1-4890-A3E4-F8BFD02220E7} = {20720CA7-795C-45AD-A302-9383A6DD503A}
{666FEA52-975F-41CD-B224-B19AF3C0ABBA} = {20720CA7-795C-45AD-A302-9383A6DD503A}
EndGlobalSection
EndGlobal

450
Code/Dokumentation/GameServer.uxf
View File

@ -1,11 +1,11 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<diagram program="umlet" version="12.2">
<diagram program="umlet" version="12.1">
<zoom_level>10</zoom_level>
<element>
<id>UMLClass</id>
<coordinates>
<x>530</x>
<y>320</y>
<x>610</x>
<y>340</y>
<w>100</w>
<h>30</h>
</coordinates>
@ -16,20 +16,8 @@
<element>
<id>UMLClass</id>
<coordinates>
<x>530</x>
<y>250</y>
<w>100</w>
<h>30</h>
</coordinates>
<panel_attributes>MainLobby
</panel_attributes>
<additional_attributes/>
</element>
<element>
<id>UMLClass</id>
<coordinates>
<x>510</x>
<y>500</y>
<x>580</x>
<y>480</y>
<w>160</w>
<h>80</h>
</coordinates>
@ -41,89 +29,34 @@
<additional_attributes/>
</element>
<element>
<id>UMLClass</id>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>620</x>
<y>340</y>
<w>60</w>
<h>160</h>
</coordinates>
<panel_attributes>lt=-&gt;&gt;&gt;&gt;</panel_attributes>
<additional_attributes>30;140;40;30</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>710</x>
<y>320</y>
<y>480</y>
<w>100</w>
<h>30</h>
</coordinates>
<panel_attributes>LobbyClient</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>550</x>
<y>250</y>
<w>50</w>
<h>90</h>
</coordinates>
<panel_attributes>lt=-&gt;&gt;&gt;&gt;</panel_attributes>
<additional_attributes>30;70;30;30</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>550</x>
<y>420</y>
<w>50</w>
<h>100</h>
</coordinates>
<panel_attributes>lt=-&gt;&gt;&gt;&gt;</panel_attributes>
<additional_attributes>30;80;30;30</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>600</x>
<y>300</y>
<w>130</w>
<h>50</h>
</coordinates>
<panel_attributes>lt=&gt;&gt;&gt;-</panel_attributes>
<additional_attributes>110;30;30;30</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>600</x>
<y>230</y>
<w>180</w>
<h>110</h>
</coordinates>
<panel_attributes>lt=&gt;&gt;&gt;-</panel_attributes>
<additional_attributes>160;90;160;30;30;30</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>640</x>
<y>410</y>
<w>140</w>
<h>140</h>
</coordinates>
<panel_attributes>lt=&gt;&gt;&gt;-</panel_attributes>
<additional_attributes>120;30;120;120;30;120</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>610</x>
<y>140</y>
<w>400</w>
<h>150</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;.</panel_attributes>
<additional_attributes>380;130;170;130;170;30;30;30</additional_attributes>
<panel_attributes>lt=&gt;&gt;&gt;&gt;-</panel_attributes>
<additional_attributes>80;30;30;30</additional_attributes>
</element>
<element>
<id>UMLClass</id>
<coordinates>
<x>520</x>
<y>160</y>
<x>600</x>
<y>180</y>
<w>120</w>
<h>30</h>
<h>120</h>
</coordinates>
<panel_attributes>GameServer</panel_attributes>
<additional_attributes/>
@ -131,42 +64,19 @@
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>550</x>
<y>160</y>
<x>630</x>
<y>270</y>
<w>50</w>
<h>110</h>
<h>90</h>
</coordinates>
<panel_attributes>lt=&gt;&gt;&gt;&gt;-</panel_attributes>
<additional_attributes>30;90;30;30</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>750</x>
<y>260</y>
<w>260</w>
<h>80</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;.</panel_attributes>
<additional_attributes>240;30;30;30;30;60</additional_attributes>
</element>
<element>
<type>com.umlet.element.Package</type>
<coordinates>
<x>990</x>
<y>250</y>
<w>120</w>
<h>50</h>
</coordinates>
<panel_attributes>NetworkAPI
bg=#a21aff</panel_attributes>
<additional_attributes/>
<additional_attributes>30;70;30;30</additional_attributes>
</element>
<element>
<id>UMLClass</id>
<coordinates>
<x>510</x>
<y>20</y>
<x>590</x>
<y>100</y>
<w>130</w>
<h>40</h>
</coordinates>
@ -177,22 +87,22 @@ DanBiasServerAPI</panel_attributes>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>550</x>
<y>30</y>
<x>630</x>
<y>110</y>
<w>50</w>
<h>150</h>
<h>90</h>
</coordinates>
<panel_attributes>lt=&gt;&gt;&gt;&gt;-
</panel_attributes>
<additional_attributes>30;130;30;30</additional_attributes>
<additional_attributes>30;70;30;30</additional_attributes>
</element>
<element>
<id>UMLClass</id>
<coordinates>
<x>300</x>
<y>320</y>
<x>1060</x>
<y>330</y>
<w>120</w>
<h>30</h>
<h>50</h>
</coordinates>
<panel_attributes>NetworkSession</panel_attributes>
<additional_attributes/>
@ -200,41 +110,41 @@ DanBiasServerAPI</panel_attributes>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>330</x>
<y>230</y>
<w>220</w>
<h>110</h>
<x>690</x>
<y>220</y>
<w>390</w>
<h>50</h>
</coordinates>
<panel_attributes>lt=-&gt;&gt;&gt;&gt;&gt;</panel_attributes>
<additional_attributes>200;30;30;30;30;90</additional_attributes>
<panel_attributes>lt=-&lt;&lt;&lt;&lt;</panel_attributes>
<additional_attributes>30;30;370;30</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>390</x>
<y>300</y>
<w>160</w>
<x>680</x>
<y>320</y>
<w>400</w>
<h>50</h>
</coordinates>
<panel_attributes>lt=-&gt;&gt;&gt;&gt;&gt;</panel_attributes>
<additional_attributes>140;30;30;30</additional_attributes>
<additional_attributes>30;30;380;30</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>330</x>
<y>320</y>
<w>200</w>
<h>210</h>
<x>690</x>
<y>340</y>
<w>390</w>
<h>160</h>
</coordinates>
<panel_attributes>lt=-&gt;&gt;&gt;&gt;&gt;</panel_attributes>
<additional_attributes>180;190;30;190;30;30</additional_attributes>
<additional_attributes>30;140;40;40;370;30</additional_attributes>
</element>
<element>
<type>com.umlet.element.Package</type>
<coordinates>
<x>990</x>
<y>370</y>
<x>460</x>
<y>640</y>
<w>120</w>
<h>50</h>
</coordinates>
@ -245,164 +155,19 @@ bg=blue</panel_attributes>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>750</x>
<y>320</y>
<w>260</w>
<h>90</h>
<x>370</x>
<y>530</y>
<w>350</w>
<h>290</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;.</panel_attributes>
<additional_attributes>240;70;30;70;30;30</additional_attributes>
</element>
<element>
<type>com.umlet.element.Package</type>
<coordinates>
<x>990</x>
<y>310</y>
<w>120</w>
<h>40</h>
</coordinates>
<panel_attributes>PhysicsAPI
bg=blue
--
</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>780</x>
<y>300</y>
<w>230</w>
<h>50</h>
</coordinates>
<panel_attributes>lt=.&lt;&lt;</panel_attributes>
<additional_attributes>210;30;30;30</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>640</x>
<y>380</y>
<w>370</w>
<h>190</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;.</panel_attributes>
<additional_attributes>350;30;190;30;190;170;30;170</additional_attributes>
<additional_attributes>90;150;30;270;330;240;240;30</additional_attributes>
</element>
<element>
<id>UMLClass</id>
<coordinates>
<x>320</x>
<y>120</y>
<w>130</w>
<h>90</h>
</coordinates>
<panel_attributes>ServerInitReader
--
Helper to load ini files to server
elementstyle=wordwrap
</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>420</x>
<y>140</y>
<w>120</w>
<h>50</h>
</coordinates>
<panel_attributes>lt=&gt;&gt;.
</panel_attributes>
<additional_attributes>100;30;30;30</additional_attributes>
</element>
<element>
<id>UMLClass</id>
<coordinates>
<x>510</x>
<y>400</y>
<w>160</w>
<h>50</h>
</coordinates>
<panel_attributes>GameSessionManager
--
/Creates game sessions/</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>550</x>
<y>320</y>
<w>50</w>
<h>100</h>
</coordinates>
<panel_attributes>lt=&gt;&gt;-</panel_attributes>
<additional_attributes>30;30;30;80</additional_attributes>
</element>
<element>
<type>com.umlet.element.Package</type>
<coordinates>
<x>990</x>
<y>430</y>
<w>120</w>
<h>40</h>
</coordinates>
<panel_attributes>ProtocolManager
bg=#aaaaa</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>310</x>
<y>320</y>
<w>770</w>
<h>300</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;.</panel_attributes>
<additional_attributes>750;150;750;280;30;280;30;30</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>1080</x>
<y>260</y>
<w>70</w>
<h>210</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;.</panel_attributes>
<additional_attributes>30;190;50;190;50;30;30;30</additional_attributes>
</element>
<element>
<id>UMLClass</id>
<coordinates>
<x>160</x>
<y>310</y>
<w>120</w>
<h>40</h>
</coordinates>
<panel_attributes>/&lt;&lt;interface&gt;&gt;/
INetworkSession</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>250</x>
<y>300</y>
<w>70</w>
<h>50</h>
</coordinates>
<panel_attributes>lt=-&gt;&gt;&gt;&gt;&gt;</panel_attributes>
<additional_attributes>50;30;30;30</additional_attributes>
</element>
<element>
<id>UMLClass</id>
<coordinates>
<x>710</x>
<y>410</y>
<x>790</x>
<y>500</y>
<w>100</w>
<h>30</h>
</coordinates>
@ -412,28 +177,91 @@ INetworkSession</panel_attributes>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>730</x>
<y>320</y>
<w>50</w>
<h>110</h>
<x>670</x>
<y>530</y>
<w>150</w>
<h>180</h>
</coordinates>
<panel_attributes>lt=&gt;&gt;&gt;-</panel_attributes>
<additional_attributes>30;30;30;90</additional_attributes>
<panel_attributes>lt=&lt;&lt;.</panel_attributes>
<additional_attributes>130;160;30;30</additional_attributes>
</element>
<element>
<type>com.umlet.element.Package</type>
<coordinates>
<x>800</x>
<y>670</y>
<w>120</w>
<h>40</h>
</coordinates>
<panel_attributes>GameProtocols
bg=#aaaaa</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Package</type>
<coordinates>
<x>1040</x>
<y>200</y>
<w>160</w>
<h>190</h>
</coordinates>
<panel_attributes>NetworkAPI
bg=#a21aff</panel_attributes>
<additional_attributes/>
</element>
<element>
<id>UMLClass</id>
<coordinates>
<x>150</x>
<y>420</y>
<w>160</w>
<h>50</h>
<x>1060</x>
<y>280</y>
<w>120</w>
<h>40</h>
</coordinates>
<panel_attributes>MapManager
--
Manages all map stuff.
elementstyle=wordwrap
</panel_attributes>
<panel_attributes>NetworkClient</panel_attributes>
<additional_attributes/>
</element>
<element>
<id>UMLClass</id>
<coordinates>
<x>1060</x>
<y>230</y>
<w>120</w>
<h>40</h>
</coordinates>
<panel_attributes>NetworkServer</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>690</x>
<y>240</y>
<w>390</w>
<h>80</h>
</coordinates>
<panel_attributes>lt=-&gt;</panel_attributes>
<additional_attributes>30;30;200;30;200;60;370;60</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>690</x>
<y>260</y>
<w>390</w>
<h>100</h>
</coordinates>
<panel_attributes>lt=-&lt;&lt;&lt;&lt;</panel_attributes>
<additional_attributes>30;30;180;30;180;80;370;80</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>860</x>
<y>270</y>
<w>380</w>
<h>260</h>
</coordinates>
<panel_attributes>lt=&gt;&gt;&gt;-</panel_attributes>
<additional_attributes>320;30;360;30;360;230;30;240</additional_attributes>
</element>
</diagram>

400
Code/Dokumentation/LevelLoader.uxf
View File

@ -2,21 +2,67 @@
<diagram program="umlet" version="12.0">
<zoom_level>8</zoom_level>
<element>
<type>com.umlet.element.Package</type>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>552</x>
<y>320</y>
<w>584</w>
<h>368</h>
<x>632</x>
<y>232</y>
<w>88</w>
<h>176</h>
</coordinates>
<panel_attributes>LevelLoader</panel_attributes>
<panel_attributes>lt=.
&lt;Uses</panel_attributes>
<additional_attributes>24;24;24;64;72;64;72;160</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>136</x>
<y>232</y>
<w>40</w>
<h>168</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;.</panel_attributes>
<additional_attributes>24;24;24;152</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>448</x>
<y>496</y>
<w>40</w>
<h>88</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes>
<additional_attributes>24;72;24;24</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>432</x>
<y>232</y>
<w>40</w>
<h>168</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;.</panel_attributes>
<additional_attributes>24;24;24;152</additional_attributes>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>608</x>
<y>216</y>
<w>128</w>
<h>40</h>
</coordinates>
<panel_attributes>Resource Loader
&lt;&lt;Dennis&gt;&gt;&lt;&lt;Singleton&gt;</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>440</x>
<y>88</y>
<x>232</x>
<y>112</y>
<w>128</w>
<h>40</h>
</coordinates>
@ -25,26 +71,26 @@
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<type>com.umlet.element.Class</type>
<coordinates>
<x>768</x>
<y>472</y>
<w>136</w>
<h>104</h>
<x>120</x>
<y>232</y>
<w>80</w>
<h>24</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes>
<additional_attributes>120;24;120;88;24;88</additional_attributes>
<panel_attributes>Defines</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>560</x>
<y>544</y>
<x>352</x>
<y>568</y>
<w>232</w>
<h>136</h>
</coordinates>
<panel_attributes>&lt;&lt;Interface&gt;&gt;
Parser
LevelParser
--
Functions:
vector&lt;struct&gt; Parse();
@ -53,164 +99,39 @@ Privates:
enum headerType;
const int FileHeaderSize;
const int FileVersion;
</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>624</x>
<y>208</y>
<w>80</w>
<h>24</h>
</coordinates>
<panel_attributes>LevelLoader
</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>640</x>
<y>208</y>
<w>40</w>
<h>168</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;.</panel_attributes>
<additional_attributes>24;24;24;152</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>384</x>
<y>176</y>
<w>256</w>
<h>56</h>
</coordinates>
<panel_attributes>lt=-&gt;&gt;&gt;&gt;
m1=1..1
m2=1..1
&lt;Knows about</panel_attributes>
<additional_attributes>240;40;24;40</additional_attributes>
</element>
<element>
<type>com.umlet.element.Package</type>
<coordinates>
<x>248</x>
<y>320</y>
<w>248</w>
<x>336</x>
<y>88</y>
<w>136</w>
<h>160</h>
</coordinates>
<panel_attributes>Defines</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>800</x>
<y>360</y>
<w>208</w>
<h>136</h>
</coordinates>
<panel_attributes>&lt;&lt;Interface&gt;&gt;
Loader
--
Functions:
wchar* LoadFile(string fileName);
Model* LoadModel(string modelName);
Model* LoadModel(int modelID);
-
Privates:</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>328</x>
<y>208</y>
<w>80</w>
<h>24</h>
</coordinates>
<panel_attributes>Defines</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>256</x>
<y>360</y>
<w>232</w>
<h>104</h>
</coordinates>
<panel_attributes>Defines.h
&lt;&lt;Header file&gt;&gt;
--
Enum ObjectType(static, dynamic, specials);
.
Struct static;
Struct dynamic;
Struct specials</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>680</x>
<y>176</y>
<w>152</w>
<h>56</h>
</coordinates>
<panel_attributes>lt=-
<panel_attributes>lt=lt=-&gt;&gt;&gt;&gt;
m1=1..1
m2=1..1
Uses&gt;</panel_attributes>
<additional_attributes>24;40;136;40</additional_attributes>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>816</x>
<y>192</y>
<w>128</w>
<h>40</h>
</coordinates>
<panel_attributes>Resource Loader
&lt;&lt;Dennis&gt;&gt;&lt;&lt;Singleton&gt;</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>928</x>
<y>560</y>
<w>200</w>
<h>120</h>
</coordinates>
<panel_attributes>Collection of functions
&lt;&lt;lots of functions&gt;&gt;
--
functions for creating the right structs</panel_attributes>
<additional_attributes/>
<additional_attributes>24;40;80;40;120;40;120;144</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>768</x>
<y>576</y>
<w>176</w>
<h>56</h>
</coordinates>
<panel_attributes>lt=-
m1=1..1
m2=1..1
Uses&gt;</panel_attributes>
<additional_attributes>24;40;160;40</additional_attributes>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>560</x>
<y>360</y>
<y>496</y>
<w>136</w>
<h>104</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes>
<additional_attributes>120;24;120;88;24;88</additional_attributes>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>352</x>
<y>384</y>
<w>232</w>
<h>136</h>
</coordinates>
@ -229,49 +150,128 @@ Privates:
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>344</x>
<y>208</y>
<w>40</w>
<h>168</h>
<x>560</x>
<y>600</y>
<w>176</w>
<h>56</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;.</panel_attributes>
<additional_attributes>24;24;24;152</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>840</x>
<y>208</y>
<w>88</w>
<h>168</h>
</coordinates>
<panel_attributes>lt=.
&lt;Uses</panel_attributes>
<additional_attributes>24;24;24;64;72;64;72;152</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>656</x>
<y>472</y>
<w>40</w>
<h>88</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes>
<additional_attributes>24;72;24;24</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>544</x>
<y>64</y>
<w>136</w>
<h>160</h>
</coordinates>
<panel_attributes>lt=lt=-&gt;&gt;&gt;&gt;
<panel_attributes>lt=-
m1=1..1
m2=1..1
Uses&gt;</panel_attributes>
<additional_attributes>24;40;80;40;120;40;120;144</additional_attributes>
<additional_attributes>24;40;160;40</additional_attributes>
</element>
<element>
<type>com.umlet.element.Package</type>
<coordinates>
<x>344</x>
<y>344</y>
<w>584</w>
<h>368</h>
</coordinates>
<panel_attributes>LevelLoader</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>472</x>
<y>200</y>
<w>152</w>
<h>56</h>
</coordinates>
<panel_attributes>lt=-
m1=1..1
m2=1..1
Uses&gt;</panel_attributes>
<additional_attributes>24;40;136;40</additional_attributes>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>416</x>
<y>232</y>
<w>80</w>
<h>24</h>
</coordinates>
<panel_attributes>LevelLoader
</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>48</x>
<y>384</y>
<w>232</w>
<h>104</h>
</coordinates>
<panel_attributes>ObjectDefines.h
&lt;&lt;Header file&gt;&gt;
--
Enum ObjectType(static, dynamic, specials);
.
Struct static;
Struct dynamic;
Struct specials</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>720</x>
<y>584</y>
<w>200</w>
<h>120</h>
</coordinates>
<panel_attributes>Collection of functions
&lt;&lt;lots of functions&gt;&gt;
--
functions for creating the right structs</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Package</type>
<coordinates>
<x>40</x>
<y>344</y>
<w>248</w>
<h>160</h>
</coordinates>
<panel_attributes>Defines</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>592</x>
<y>392</y>
<w>208</w>
<h>128</h>
</coordinates>
<panel_attributes>&lt;&lt;Interface&gt;&gt;
Loader
--
Functions:
wchar* LoadFile(string fileName);
//Model* LoadHitBoxes(string modelName);
//Model* LoadHitBoxes(int modelID);
-
Privates:</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>176</x>
<y>200</y>
<w>256</w>
<h>56</h>
</coordinates>
<panel_attributes>lt=-&gt;&gt;&gt;&gt;
m1=1..1
m2=1..1
&lt;Knows about</panel_attributes>
<additional_attributes>240;40;24;40</additional_attributes>
</element>
</diagram>

15
Code/Game/DanBiasGame/DanBiasGame.vcxproj
View File

@ -72,7 +72,7 @@
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
<LibraryPath>$(SolutionDir)..\External\Lib\;$(SolutionDir)..\Bin\DLL;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Network/NetworkAPI;$(IncludePath);C:\Program Files %28x86%29\Visual Leak Detector\include</IncludePath>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Network/NetworkAPI;$(IncludePath);C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)Game\GameServer\</IncludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
@ -80,7 +80,7 @@
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
<LibraryPath>$(SolutionDir)..\External\Lib\;$(SolutionDir)..\Bin\DLL;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Network/NetworkAPI;$(IncludePath);C:\Program Files %28x86%29\Visual Leak Detector\include</IncludePath>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Network/NetworkAPI;$(IncludePath);C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)Game\GameServer\</IncludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
@ -88,7 +88,7 @@
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
<LibraryPath>$(SolutionDir)..\External\Lib\;$(SolutionDir)..\Bin\DLL;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Network/NetworkAPI;$(IncludePath);C:\Program Files %28x86%29\Visual Leak Detector\include</IncludePath>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Network/NetworkAPI;$(IncludePath);C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)Game\GameServer\</IncludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
@ -96,7 +96,7 @@
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
<LibraryPath>$(SolutionDir)..\External\Lib\;$(SolutionDir)..\Bin\DLL;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Network/NetworkAPI;$(IncludePath);C:\Program Files %28x86%29\Visual Leak Detector\include</IncludePath>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Network/NetworkAPI;$(IncludePath);C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)Game\GameServer\</IncludePath>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
@ -190,6 +190,9 @@
<ProjectReference Include="..\..\OysterMath\OysterMath.vcxproj">
<Project>{f10cbc03-9809-4cba-95d8-327c287b18ee}</Project>
</ProjectReference>
<ProjectReference Include="..\GameServer\GameServer.vcxproj">
<Project>{143bd516-20a1-4890-a3e4-f8bfd02220e7}</Project>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<ClCompile Include="GameClientState\Camera.cpp" />
@ -201,8 +204,10 @@
<ClCompile Include="DLLMain.cpp" />
<ClCompile Include="GameClientState\GameClientState.cpp" />
<ClCompile Include="GameClientState\GameState.cpp" />
<ClCompile Include="GameClientState\LanMenuState.cpp" />
<ClCompile Include="GameClientState\LobbyState.cpp" />
<ClCompile Include="GameClientState\C_Object.cpp" />
<ClCompile Include="GameClientState\LoginState.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="GameClientRecieverFunc.h" />
@ -213,6 +218,8 @@
<ClInclude Include="GameClientState\C_obj\C_UIobject.h" />
<ClInclude Include="GameClientState\GameClientState.h" />
<ClInclude Include="GameClientState\GameState.h" />
<ClInclude Include="GameClientState\LanMenuState.h" />
<ClInclude Include="GameClientState\LoginState.h" />
<ClInclude Include="Include\DanBiasGame.h" />
<ClInclude Include="GameClientState\LobbyState.h" />
<ClInclude Include="GameClientState\C_Object.h" />

36
Code/Game/DanBiasGame/DanBiasGame_Impl.cpp
View File

@ -5,8 +5,11 @@
#include "GameClientState/GameClientState.h"
#include "GameClientState\GameState.h"
#include "GameClientState\LobbyState.h"
#include "GameClientState\LoginState.h"
#include "GameClientState\LanMenuState.h"
#include <Protocols.h>
#include "NetworkClient.h"
#include <GameServerAPI.h>
#include "../WindowManager/WindowShell.h"
#include "L_inputClass.h"
@ -37,6 +40,7 @@ namespace DanBias
InputClass* inputObj;
Utility::WinTimer* timer;
GameRecieverObject* recieverObj;
bool serverOwner;
} data;
#pragma endregion
@ -61,22 +65,15 @@ namespace DanBias
return DanBiasClientReturn_Error;
m_data->recieverObj = new GameRecieverObject;
m_data->serverOwner = false;
m_data->recieverObj->nwClient = new Oyster::Network::NetworkClient(m_data->recieverObj, Oyster::Network::NetworkProtocolCallbackType_Object);
m_data->recieverObj->nwClient->Connect(desc.port, desc.IP);
if (!m_data->recieverObj->nwClient->IsConnected())
{
// failed to connect
return DanBiasClientReturn_Error;
}
// Start in lobby state
m_data->recieverObj->gameClientState = new Client::LobbyState();
if(!m_data->recieverObj->gameClientState->Init(m_data->recieverObj->nwClient))
m_data->recieverObj->gameClientState = new Client::LoginState();
if(!m_data->recieverObj->gameClientState->Init(m_data->recieverObj))
return DanBiasClientReturn_Error;
m_data->timer = new Utility::WinTimer(); //why dynamic memory?
m_data->timer->reset();
m_data->timer = new Utility::WinTimer(); //why dynamic memory?
m_data->timer->reset();
return DanBiasClientReturn_Sucess;
}
@ -134,8 +131,14 @@ namespace DanBias
HRESULT DanBiasGame::Update(float deltaTime)
{
m_data->recieverObj->Update();
m_data->inputObj->Update();
if(m_data->serverOwner)
{
DanBias::GameServerAPI::ServerUpdate();
}
DanBias::Client::GameClientState::ClientState state = DanBias::Client::GameClientState::ClientState_Same;
state = m_data->recieverObj->gameClientState->Update(deltaTime, m_data->inputObj);
@ -147,6 +150,8 @@ namespace DanBias
switch (state)
{
case Client::GameClientState::ClientState_LobbyCreated:
m_data->serverOwner = true;
case Client::GameClientState::ClientState_Lobby:
m_data->recieverObj->gameClientState = new Client::LobbyState();
break;
@ -157,7 +162,7 @@ namespace DanBias
return E_FAIL;
break;
}
m_data->recieverObj->gameClientState->Init(m_data->recieverObj->nwClient); // send game client
m_data->recieverObj->gameClientState->Init(m_data->recieverObj); // send game client
}
return S_OK;
@ -184,10 +189,9 @@ namespace DanBias
{
m_data->recieverObj->gameClientState->Release();
delete m_data->recieverObj->gameClientState;
m_data->recieverObj->nwClient->Disconnect();
delete m_data->recieverObj->nwClient;
delete m_data->timer;
m_data->recieverObj->Disconnect();
delete m_data->recieverObj;
delete m_data->timer;
delete m_data->inputObj;
delete m_data;

2
Code/Game/DanBiasGame/DanBiasMaincpp.cpp
View File

@ -7,7 +7,7 @@
//--------------------------------------------------------------------------------------
#define NOMINMAX
#include <Windows.h>
#include <
#include "DllInterfaces/GFXAPI.h"
//#include "IGame.h"

73
Code/Game/DanBiasGame/GameClientRecieverFunc.h
View File

@ -1,24 +1,32 @@
#ifndef DANBIAS_CLIENTRECIEVEROBJECT_H
#define DANBIAS_CLIENTRECIEVEROBJECT_H
//WTF!? No headers included???
namespace DanBias
{
inline bool IsLobbyProtocol(short ID) { return (ID >= protocol_LobbyMIN && ID <= protocol_LobbyMAX); }
inline bool IsGeneralProtocol(short ID) { return (ID >= protocol_GeneralMIN && ID <= protocol_GeneralMAX); }
inline bool IsGameplayProtocol(short ID) { return (ID >= protocol_GameplayMIN && ID <= protocol_GameplayMAX); }
struct GameRecieverObject :public Oyster::Network::ProtocolRecieverObject
struct GameRecieverObject :public Oyster::Network::NetworkClient
{
Oyster::Network::NetworkClient* nwClient;
Client::GameClientState* gameClientState;
// receiver function for server messages
// parsing protocols and sending it to the gameState
void ParseGamePlayEvent(Oyster::Network::CustomNetProtocol& p)
void NetworkCallback(Oyster::Network::CustomNetProtocol& p) override
{
int pType = p[0].value.netInt;
switch (pType)
{
case protocol_General_Status:
{
GameLogic::Protocol_General_Status::States state;
state = (GameLogic::Protocol_General_Status::States)p[1].value.netShort;
if( state == GameLogic::Protocol_General_Status::States_disconected)
{
// server disconnected
DanBiasGame::Release();
}
}
break;
case protocol_Gameplay_PlayerMovement:
{
Client::GameClientState::KeyInput* protocolData = new Client::GameClientState::KeyInput;
@ -33,6 +41,19 @@ struct GameRecieverObject :public Oyster::Network::ProtocolRecieverObject
protocolData = NULL;
}
break;
//case protocol_Gameplay_PlayerPosition:
// {
// Client::GameClientState::PlayerPos* protocolData = new Client::GameClientState::PlayerPos;
// for(int i = 0; i< 3; i++)
// {
// protocolData->playerPos[i] = p[i].value.netFloat;
// }
// if(dynamic_cast<Client::GameState*>(gameClientState))
// ((Client::GameState*)gameClientState)->Protocol(protocolData);
// delete protocolData;
// protocolData = NULL;
// }
// break;
case protocol_Gameplay_ObjectCreate:
{
@ -67,52 +88,22 @@ struct GameRecieverObject :public Oyster::Network::ProtocolRecieverObject
case protocol_Gameplay_ObjectPosition:
{
Client::GameClientState::ObjPos* protocolData = new Client::GameClientState::ObjPos;
protocolData->object_ID = p[1].value.netInt;
Client::GameClientState::ObjPos protocolData;
protocolData.object_ID = p[1].value.netInt;
for(int i = 0; i< 16; i++)
{
protocolData->worldPos[i] = p[i+2].value.netFloat;
protocolData.worldPos[i] = p[i+2].value.netFloat;
}
if(dynamic_cast<Client::GameState*>(gameClientState))
((Client::GameState*)gameClientState)->Protocol(protocolData);
delete protocolData;
protocolData = NULL;
((Client::GameState*)gameClientState)->Protocol(&protocolData);
}
break;
default:
break;
}
}
void ParseGeneralEvent(Oyster::Network::CustomNetProtocol& p)
{
int pType = p[0].value.netInt;
switch (pType)
{
case protocol_General_Status:
{
GameLogic::Protocol_General_Status::States state;
state = (GameLogic::Protocol_General_Status::States)p[1].value.netShort;
if( state == GameLogic::Protocol_General_Status::States_disconected)
{
// server disconnected
DanBiasGame::Release();
}
}
break;
}
}
void NetworkCallback(Oyster::Network::CustomNetProtocol& p) override
{
if( IsGameplayProtocol(p[protocol_INDEX_ID].value.netShort) )
ParseGamePlayEvent(p);
if( IsGeneralProtocol(p[protocol_INDEX_ID].value.netShort) )
ParseGeneralEvent(p);
}
};
}

2
Code/Game/DanBiasGame/GameClientState/GameClientState.h
View File

@ -51,7 +51,9 @@ public:
};
enum ClientState
{
ClientState_Login,
ClientState_Lobby,
ClientState_LobbyCreated,
ClientState_Game,
ClientState_Same,
};

27
Code/Game/DanBiasGame/GameClientState/GameState.cpp
View File

@ -5,6 +5,7 @@
#include <Protocols.h>
#include "NetworkClient.h"
#include "Camera.h"
#include <GameServerAPI.h>
using namespace DanBias::Client;
@ -48,17 +49,17 @@ bool GameState::Init(Oyster::Network::NetworkClient* nwClient)
GameState::gameStateState GameState::LoadGame()
{
Oyster::Graphics::Definitions::Pointlight plight;
plight.Pos = Oyster::Math::Float3(0,175,5);
plight.Pos = Oyster::Math::Float3(0,15,5);
plight.Color = Oyster::Math::Float3(0,1,0);
plight.Radius = 50;
plight.Bright = 2;
Oyster::Graphics::API::AddLight(plight);
plight.Pos = Oyster::Math::Float3(10,175,5);
plight.Pos = Oyster::Math::Float3(10,15,5);
plight.Color = Oyster::Math::Float3(1,0,0);
plight.Radius = 50;
plight.Bright = 2;
Oyster::Graphics::API::AddLight(plight);
plight.Pos = Oyster::Math::Float3(10,-175,5);
plight.Pos = Oyster::Math::Float3(10,-15,5);
plight.Color = Oyster::Math::Float3(0,0,1);
plight.Radius = 50;
plight.Bright = 2;
@ -81,12 +82,20 @@ bool GameState::LoadModels(std::wstring mapFile)
C_Object* obj;
translate = Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(0,0,0));
Oyster::Math3D::Float4x4 scale = Oyster::Math3D::Float4x4::identity;
<<<<<<< HEAD
scale.v[0].x = 0.2;
scale.v[1].y = 0.2;
scale.v[2].z = 0.2;
scale.v[3].w = 1;
modelData.world = translate ;//modelData.world * translate
modelData.modelPath = L"world_earth.dan";
=======
scale.v[0].x = 8;
scale.v[1].y = 8;
scale.v[2].z = 8;
modelData.world = scale; //modelData.world * translate
modelData.modelPath = L"..\\Content\\Models\\ball.dan";
>>>>>>> cec022b3814c680d5be161e7cfe0596841736c77
modelData.id = 0;
obj = new C_Player();
@ -95,9 +104,13 @@ bool GameState::LoadModels(std::wstring mapFile)
// add box model
modelData.world = Oyster::Math3D::Float4x4::identity;
<<<<<<< HEAD
translate = Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(4,320,0));
=======
translate = Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(-5,15,0));
>>>>>>> cec022b3814c680d5be161e7cfe0596841736c77
modelData.world = modelData.world * translate;
modelData.modelPath = L"box.dan";
modelData.modelPath = L"..\\Content\\Models\\box.dan";
modelData.id = 1;
obj = new C_Player();
@ -108,6 +121,7 @@ bool GameState::LoadModels(std::wstring mapFile)
// add player model
modelData.world = Oyster::Math3D::Float4x4::identity;
translate = Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(0, 15, 0));
modelData.world = modelData.world * translate;
modelData.visible = true;
modelData.modelPath = L"..\\Content\\Models\\char_white.dan";
@ -119,9 +133,6 @@ bool GameState::LoadModels(std::wstring mapFile)
return true;
}
bool GameState::InitCamera(Oyster::Math::Float3 startPos)
@ -352,7 +363,7 @@ void GameState::Protocol( ObjPos* pos )
//camera->setLook((Oyster::Math::Float3(world[8], world[9], world[10])));
if(i == 2) // playerobj
{
camera->SetPosition(Oyster::Math::Float3(world[12], world[13] + 2.2f, world[14]-1));
camera->SetPosition(Oyster::Math::Float3(world[12], world[13], world[14]));
camera->UpdateViewMatrix();
}
}

164
Code/Game/DanBiasGame/GameClientState/LanMenuState.cpp Normal file
View File

@ -0,0 +1,164 @@
#include "LanMenuState.h"
#include "C_obj/C_Player.h"
#include "C_obj/C_StaticObj.h"
#include "C_obj/C_DynamicObj.h"
#include "DllInterfaces/GFXAPI.h"
#include <GameServerAPI.h>
using namespace DanBias::Client;
struct LanMenuState::myData
{
myData(){}
Oyster::Math3D::Float4x4 view;
Oyster::Math3D::Float4x4 proj;
C_Object* object[2];
int modelCount;
// UI object
// game client*
}privData;
LanMenuState::LanMenuState()
{
}
LanMenuState::~LanMenuState()
{
}
bool LanMenuState::Init(Oyster::Network::NetworkClient* nwClient)
{
privData = new myData();
this->nwClient = nwClient;
// load models
LoadModels(L"UImodels.txt");
InitCamera(Oyster::Math::Float3(0,0,5.4f));
return true;
}
bool LanMenuState::LoadModels(std::wstring file)
{
Oyster::Graphics::Definitions::Pointlight plight;
plight.Pos = Oyster::Math::Float3(-2,3,0);
plight.Color = Oyster::Math::Float3(0,1,0);
plight.Radius = 10;
plight.Bright = 1;
Oyster::Graphics::API::AddLight(plight);
// open file
// read file
// init models
privData->modelCount = 2;
ModelInitData modelData;
modelData.world = Oyster::Math3D::Float4x4::identity;
modelData.visible = true;
modelData.modelPath = L"..\\Content\\Models\\box_2.dan";
// load models
privData->object[0] = new C_StaticObj();
privData->object[0]->Init(modelData);
Oyster::Math3D::Float4x4 translate = Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(-2,-2,-2));
modelData.world = modelData.world * translate;
privData->object[1] = new C_DynamicObj();
privData->object[1]->Init(modelData);
return true;
}
bool LanMenuState::InitCamera(Oyster::Math::Float3 startPos)
{
privData->proj = Oyster::Math3D::ProjectionMatrix_Perspective(Oyster::Math::pi/2,1024.0f/768.0f,.1f,1000);
//privData->proj = Oyster::Math3D::ProjectionMatrix_Orthographic(1024, 768, 1, 1000);
Oyster::Graphics::API::SetProjection(privData->proj);
privData->view = Oyster::Math3D::OrientationMatrix_LookAtDirection(Oyster::Math::Float3(0,0,-1),Oyster::Math::Float3(0,1,0),startPos);
privData->view = Oyster::Math3D::InverseOrientationMatrix(privData->view);
return true;
}
GameClientState::ClientState LanMenuState::Update(float deltaTime, InputClass* KeyInput)
{
// create game
if( KeyInput->IsKeyPressed(DIK_C))
{
DanBias::GameServerAPI::ServerInitDesc desc;
DanBias::GameServerAPI::ServerInitiate(desc);
DanBias::GameServerAPI::ServerStart();
// my ip
nwClient->Connect(15151, "127.0.0.1");
if (!nwClient->IsConnected())
{
// failed to connect
return ClientState_Same;
}
return ClientState_Lobby;
}
// join game
if( KeyInput->IsKeyPressed(DIK_J))
{
// game ip
nwClient->Connect(15151, "194.47.150.56");
if (!nwClient->IsConnected())
{
// failed to connect
return ClientState_Same;
}
return ClientState_Lobby;
}
return ClientState_Same;
}
bool LanMenuState::Render()
{
Oyster::Graphics::API::SetView(privData->view);
Oyster::Graphics::API::SetProjection( privData->proj);
Oyster::Graphics::API::NewFrame();
// render objects
for (int i = 0; i < privData->modelCount; i++)
{
privData->object[i]->Render();
}
// render effects
// render lights
Oyster::Graphics::API::EndFrame();
return true;
}
bool LanMenuState::Release()
{
for (int i = 0; i < privData->modelCount; i++)
{
privData->object[i]->Release();
delete privData->object[i];
privData->object[i] = NULL;
}
delete privData;
privData = NULL;
return true;
}
void LanMenuState::Protocol(ProtocolStruct* protocolStruct)
{
if((PlayerName*)protocolStruct)
PlayerJoinProtocol((PlayerName*)protocolStruct);
}
void LanMenuState::PlayerJoinProtocol(PlayerName* name)
{
}

37
Code/Game/DanBiasGame/GameClientState/LanMenuState.h Normal file
View File

@ -0,0 +1,37 @@
#ifndef LAN_MENU_STATE_H
#define LAN_MENU_STATE_H
#include "GameClientState.h"
#include "OysterMath.h"
namespace DanBias
{
namespace Client
{
class LanMenuState : public GameClientState
{
public:
LanMenuState();
virtual ~LanMenuState();
virtual bool Init(Oyster::Network::NetworkClient* nwClient);
virtual ClientState Update(float deltaTime, InputClass* KeyInput);
bool LoadModels(std::wstring file);
bool InitCamera(Oyster::Math::Float3 startPos);
virtual bool Render();
virtual bool Release();
virtual void Protocol(ProtocolStruct* protocolStruct);
void PlayerJoinProtocol(PlayerName* name);
private:
Oyster::Network::NetworkClient* nwClient;
struct myData;
myData* privData;
};
}
}
#endif

10
Code/Game/DanBiasGame/GameClientState/LobbyState.cpp
View File

@ -4,6 +4,7 @@
#include "C_obj/C_Player.h"
#include "C_obj/C_StaticObj.h"
#include "C_obj/C_DynamicObj.h"
#include <GameServerAPI.h>
using namespace DanBias::Client;
@ -31,7 +32,7 @@ LobbyState::~LobbyState(void)
bool LobbyState::Init(Oyster::Network::NetworkClient* nwClient)
{
privData = new myData();
this->nwClient = nwClient;
// load models
LoadModels(L"UImodels.txt");
InitCamera(Oyster::Math::Float3(0,0,5.4f));
@ -87,8 +88,13 @@ GameClientState::ClientState LobbyState::Update(float deltaTime, InputClass* Key
// send data to server
// check data from server
if( KeyInput->IsKeyPressed(DIK_G))
return ClientState_Game;
{
DanBias::GameServerAPI::GameStart();
return ClientState_Game;
}
return ClientState_Same;
}
bool LobbyState::Render()

2
Code/Game/DanBiasGame/GameClientState/LobbyState.h
View File

@ -3,6 +3,7 @@
#include "GameClientState.h"
#include "OysterMath.h"
#include "NetworkClient.h"
#include <string>
namespace DanBias
{
@ -12,6 +13,7 @@ namespace DanBias
class LobbyState : public GameClientState
{
private:
Oyster::Network::NetworkClient* nwClient;
struct myData;
myData* privData;
public:

166
Code/Game/DanBiasGame/GameClientState/LoginState.cpp Normal file
View File

@ -0,0 +1,166 @@
#include "LoginState.h"
#include "DllInterfaces/GFXAPI.h"
#include "OysterMath.h"
#include "C_obj/C_Player.h"
#include "C_obj/C_StaticObj.h"
#include "C_obj/C_DynamicObj.h"
#include <GameServerAPI.h>
using namespace DanBias::Client;
struct LoginState::myData
{
myData(){}
Oyster::Math3D::Float4x4 view;
Oyster::Math3D::Float4x4 proj;
C_Object* object[2];
int modelCount;
// UI object
// game client*
}privData;
LoginState::LoginState(void)
{
}
LoginState::~LoginState(void)
{
}
bool LoginState::Init(Oyster::Network::NetworkClient* nwClient)
{
privData = new myData();
this->nwClient = nwClient;
// load models
LoadModels(L"UImodels.txt");
InitCamera(Oyster::Math::Float3(0,0,5.4f));
return true;
}
bool LoginState::LoadModels(std::wstring file)
{
Oyster::Graphics::Definitions::Pointlight plight;
plight.Pos = Oyster::Math::Float3(-2,3,0);
plight.Color = Oyster::Math::Float3(0,1,0);
plight.Radius = 10;
plight.Bright = 1;
Oyster::Graphics::API::AddLight(plight);
// open file
// read file
// init models
privData->modelCount = 2;
ModelInitData modelData;
modelData.world = Oyster::Math3D::Float4x4::identity;
modelData.visible = true;
modelData.modelPath = L"..\\Content\\Models\\box_2.dan";
// load models
privData->object[0] = new C_StaticObj();
privData->object[0]->Init(modelData);
Oyster::Math3D::Float4x4 translate = Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(-2,-2,-2));
modelData.world = modelData.world * translate;
privData->object[1] = new C_DynamicObj();
privData->object[1]->Init(modelData);
return true;
}
bool LoginState::InitCamera(Oyster::Math::Float3 startPos)
{
privData->proj = Oyster::Math3D::ProjectionMatrix_Perspective(Oyster::Math::pi/2,1024.0f/768.0f,.1f,1000);
//privData->proj = Oyster::Math3D::ProjectionMatrix_Orthographic(1024, 768, 1, 1000);
Oyster::Graphics::API::SetProjection(privData->proj);
privData->view = Oyster::Math3D::OrientationMatrix_LookAtDirection(Oyster::Math::Float3(0,0,-1),Oyster::Math::Float3(0,1,0),startPos);
privData->view = Oyster::Math3D::InverseOrientationMatrix(privData->view);
return true;
}
GameClientState::ClientState LoginState::Update(float deltaTime, InputClass* KeyInput)
{
// picking
// mouse events
// different menus
// play sounds
// update animation
// send data to server
// check data from server
// create game
if( KeyInput->IsKeyPressed(DIK_C))
{
DanBias::GameServerAPI::ServerInitDesc desc;
DanBias::GameServerAPI::ServerInitiate(desc);
DanBias::GameServerAPI::ServerStart();
// my ip
nwClient->Connect(15151, "127.0.0.1");
if (!nwClient->IsConnected())
{
// failed to connect
return ClientState_Same;
}
return ClientState_LobbyCreated;
}
// join game
if( KeyInput->IsKeyPressed(DIK_J))
{
// game ip
nwClient->Connect(15151, "194.47.150.56");
if (!nwClient->IsConnected())
{
// failed to connect
return ClientState_Same;
}
return ClientState_Lobby;
}
return ClientState_Same;
}
bool LoginState::Render()
{
Oyster::Graphics::API::SetView(privData->view);
Oyster::Graphics::API::SetProjection( privData->proj);
Oyster::Graphics::API::NewFrame();
// render objects
for (int i = 0; i < privData->modelCount; i++)
{
privData->object[i]->Render();
}
// render effects
// render lights
Oyster::Graphics::API::EndFrame();
return true;
}
bool LoginState::Release()
{
for (int i = 0; i < privData->modelCount; i++)
{
privData->object[i]->Release();
delete privData->object[i];
privData->object[i] = NULL;
}
delete privData;
privData = NULL;
return true;
}
void LoginState::Protocol(ProtocolStruct* protocol)
{
if((PlayerName*)protocol)
PlayerJoinProtocol((PlayerName*)protocol);
}
void LoginState::PlayerJoinProtocol(PlayerName* name)
{
}

33
Code/Game/DanBiasGame/GameClientState/LoginState.h Normal file
View File

@ -0,0 +1,33 @@
#ifndef DANBIAS_CLIENT_LOGINSTATE_H
#define DANBIAS_CLIENT_LOGINSTATE_H
#include "GameClientState.h"
#include "OysterMath.h"
#include "NetworkClient.h"
#include <string>
namespace DanBias
{
namespace Client
{
class LoginState : public GameClientState
{
private:
Oyster::Network::NetworkClient* nwClient;
struct myData;
myData* privData;
public:
LoginState(void);
~LoginState(void);
bool Init(Oyster::Network::NetworkClient* nwClient);
bool LoadModels(std::wstring file);
bool InitCamera(Oyster::Math::Float3 startPos);
ClientState Update(float deltaTime, InputClass* KeyInput);
bool Render();
bool Release();
void Protocol(ProtocolStruct* protocol)override;
void PlayerJoinProtocol(PlayerName* name);
};};};
#endif // ! DANBIAS_CLIENT_LOGINSTATE_H

68
Code/Game/DanBiasServer/AdminInterface/AdminInterface.cpp
View File

@ -1,68 +0,0 @@
#define NOMINMAX
#include "AdminInterface.h"
#include <Thread\OysterThread.h>
#include <WindowShell.h>
#include "..\GameServer.h"
#include "..\GameSession\GameSessionManager.h"
#include "..\GameSession\GameSession.h"
#include "..\Helpers\ServerDataReader.h"
#include "..\LobbySessions\LobbyClient.h"
#include "..\LobbySessions\NetworkSession.h"
#include "..\LobbySessions\GameLobby.h"
#include "..\LobbySessions\MainLobby.h"
using namespace Oyster::Network;
using namespace Oyster::Thread;
using namespace DanBias;
struct AdminInstanceData :public IThreadObject
{
bool isCreated;
Oyster::Network::NetworkServer adminServer;
NetworkClient* admin;
NetworkSession* parentInstance;
OysterThread worker;
bool DoWork() override
{
//((GameServer*)parentInstance)->serve
return true;
}
}adminInstanceData;
void AdminArrived(NetworkClient* adm)
{
if(adminInstanceData.admin)
{
delete adm;
return;
}
adminInstanceData.admin = adm;
adminInstanceData.worker.Create(&adminInstanceData, true, true);
}
void AdminInterface::Toggle(bool toggle, NetworkSession* parent)
{
if(toggle)
{
if(!parent) return;
if(adminInstanceData.isCreated) return;
NetworkServer::INIT_DESC desc;
desc.port = 15152;
desc.callbackType = NetworkClientCallbackType_Function;
desc.recvObj.clientConnectFnc = AdminArrived;
if(!adminInstanceData.adminServer.Init(desc)) return;
adminInstanceData.parentInstance = parent;
adminInstanceData.adminServer.Start();
}
else
{
adminInstanceData.adminServer.Shutdown();
}
}

20
Code/Game/DanBiasServer/AdminInterface/AdminInterface.h
View File

@ -1,20 +0,0 @@
/////////////////////////////////////////
// Created by [Dennis Andersen] [2013] //
/////////////////////////////////////////
#ifndef DANBIASSERVER_ADMIN_INTERFACE_H
#define DANBIASSERVER_ADMIN_INTERFACE_H
#include <NetworkServer.h>
namespace DanBias
{
class NetworkSession;
//Global admin
class AdminInterface
{
public:
static void Toggle(bool toggle, NetworkSession* parent);
};
}
#endif // !DANBIASSERVER_ADMIN_INTERFACE_H

28
Code/Game/DanBiasServer/DanBiasServerAPI.cpp
View File

@ -1,28 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#include "DanBiasServerAPI.h"
#include "GameServer.h"
namespace DanBias
{
#pragma region Server Data
static GameServer server;
#pragma endregion
DanBiasServerReturn DanBiasServerAPI::Initiate()
{
return server.Create();
}
DanBiasServerReturn DanBiasServerAPI::Run()
{
return server.Run();
}
DanBiasServerReturn DanBiasServerAPI::Release()
{
return server.Release();
}
} //End namspace DanBias

37
Code/Game/DanBiasServer/DanBiasServerAPI.h
View File

@ -1,37 +0,0 @@
/////////////////////////////////////////
// Created by [Dennis Andersen] [2013] //
/////////////////////////////////////////
#ifndef DANBIAS_SERVER_DANBIAS_SERVER_H
#define DANBIAS_SERVER_DANBIAS_SERVER_H
#include <vld.h>
#define DANBIAS_SERVER
#ifdef DANBIAS_SERVER_DLL_EXPORT
#define DANBIAS_SERVER_DLL __declspec(dllexport)
#else
#define DANBIAS_SERVER_DLL __declspec(dllimport)
#endif
namespace DanBias
{
enum DanBiasServerReturn
{
DanBiasServerReturn_Error,
DanBiasServerReturn_Sucess,
};
extern "C"
{
class DANBIAS_SERVER_DLL DanBiasServerAPI
{
public:
static DanBiasServerReturn Initiate();
static DanBiasServerReturn Run();
static DanBiasServerReturn Release();
};//End class DanBiasServer
}//End Extern "C"
} //End namspace DanBias
#endif // !DANBIAS_SERVER_DANBIAS_SERVER_H

161
Code/Game/DanBiasServer/GameServer.cpp
View File

@ -1,161 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#define NOMINMAX
#include <Windows.h>
#include <WindowShell.h>
#include <iostream>
#include "GameServer.h"
#include "Helpers\ServerDataReader.h"
#include "GameSession\GameSessionManager.h"
#include "LobbySessions\LobbyClient.h"
#include "GameSession\GameSession.h"
#include "AdminInterface\AdminInterface.h"
#include <Thread\OysterThread.h>
#include <Utilities.h>
#include <CollisionManager.h>
namespace DanBias
{
using namespace Oyster::Network;
GameServer* GameServer::instance = 0;
void GameServer::NetworkCallback(NetworkClient* client)
{
static bool myTest = false;
static int sessionId = -1;
printf("Client with ID [%i] connected.\n", client->GetID());
if(!myTest)
{
Utility::DynamicMemory::SmartPointer<LobbyClient> c = new LobbyClient(client);
GameSessionDescription desc;
desc.mapName = L"test";
desc.clients.Push(c);
desc.exitDestionation = this->mainLobby;
if((sessionId = GameSessionManager::AddSession(desc, true)) == 0)
printf("Failed to create a game session\n");
myTest = true;
//myTest = new GameSession();
//
//DanBias::GameSession::GameSessionDescription desc;
//desc.owner = 0;
//desc.clients.Push(c);
//
//if(!myTest->Create(desc)) return;
//myTest->Run();
}
else
{
Utility::DynamicMemory::SmartPointer<LobbyClient> c = new LobbyClient(client);
GameSessionManager::JoinSession(sessionId, c);
}
//Utility::DynamicMemory::SmartPointer<LobbyClient> c = new LobbyClient(client);
//this->mainLobby->Attach(c, this->mainLobby->GetPostbox());
}
GameServer::GameServer()
: initiated(0)
, running(0)
, released(0)
, maxClients(0)
, mainLobby(0)
, server(0)
{ this->instance = this; }
GameServer::~GameServer()
{
}
DanBiasServerReturn GameServer::Create()
{
this->server = new NetworkServer();
this->mainLobby = new MainLobby();
InitData data;
if(!LoadIniFile(data)) return DanBiasServerReturn_Error;
NetworkServer::INIT_DESC serverDesc;
this->maxClients = data.clients;
serverDesc.port = data.port;
serverDesc.recvObj = this;
serverDesc.callbackType = Oyster::Network::NetworkClientCallbackType_Object;
if(!this->server->Init(serverDesc)) return DanBiasServerReturn_Error;
if(!WindowShell::CreateConsoleWindow()) return DanBiasServerReturn_Error;
this->initiated = true;
return DanBiasServerReturn_Sucess;
}
DanBiasServerReturn GameServer::Run()
{
if(this->running) return DanBiasServerReturn_Error;
if(this->released) return DanBiasServerReturn_Error;
if(!this->initiated) return DanBiasServerReturn_Error;
if(!this->server->Start()) return DanBiasServerReturn_Error;
//Oyster::Thread::OysterThread ioThread;
//ioThread.Create(this, true,
while (true)
{
if(!WindowShell::Frame()) break;
this->mainLobby->Frame();
if(GetAsyncKeyState(0x51)) //Q for exit
break;
}
return DanBiasServerReturn_Sucess;
}
DanBiasServerReturn GameServer::Release()
{
GameSessionManager::CloseSession();
this->mainLobby->Release();
delete this->mainLobby;
this->server->Shutdown();
delete this->server;
this->released = true;
return DanBiasServerReturn_Sucess;
}
NetworkSession* GameServer::MainLobbyInstance()
{
return GameServer::instance->mainLobby;
}
bool GameServer::LoadIniFile(InitData& ini)
{
std::ifstream in;
std::string f = GetInitPath(InitPath_ServerIni);
in.open(f, std::ios::in);
if(!in.is_open()) return false;
std::string buffer;
while (!in.eof())
{
in >> buffer;
if(buffer == "port")
{
in >> ini.port;
}
else if(buffer == "clients")
{
in >> ini.clients;
}
}
in.close();
return true;
}
}//End namespace DanBias

50
Code/Game/DanBiasServer/GameServer.h
View File

@ -1,50 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#ifndef DANBIASSERVER_GAME_SERVER_H
#define DANBIASSERVER_GAME_SERVER_H
#include "DanBiasServerAPI.h"
#include "LobbySessions\MainLobby.h"
#include <NetworkServer.h>
#include <NetworkCallbackHelper.h>
namespace DanBias
{
class GameServer :public Oyster::Network::ClientConnectedObject
{
public:
GameServer();
virtual~GameServer();
DanBiasServerReturn Create();
DanBiasServerReturn Run();
DanBiasServerReturn Release();
static NetworkSession* MainLobbyInstance();
private:
//static void ClientConnectCallbackFunction(Oyster::Network::NetworkClient& connectedClient);
void NetworkCallback(Oyster::Network::NetworkClient* client) override;
bool initiated;
bool running;
bool released;
int maxClients;
MainLobby *mainLobby;
Oyster::Network::NetworkServer *server;
static GameServer* instance;
private:
struct InitData
{
int port;
int clients;
};
bool LoadIniFile(InitData&);
private:
friend class AdminInterface;
};
}// End namspace DanBias
#endif // !DANBIASSERVER_DBSERVER_H

67
Code/Game/DanBiasServer/GameSession/GameClient.cpp
View File

@ -1,67 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#include "GameClient.h"
#include "..\LobbySessions\NetworkSession.h"
#include <Protocols.h>
using namespace Utility::DynamicMemory;
using namespace DanBias;
using namespace GameLogic;
static int gameClientIDCount = 1;
GameClient::GameClient(SmartPointer<LobbyClient> client, IPlayerData* player, Oyster::Callback::OysterCallback<void, NetworkSession::NetEvent> value)
{
this->callbackValue = value;
this->client = client;
this->id = gameClientIDCount++;
this->player = player;
Oyster::Callback::OysterCallback<void, NetworkSession::NetEvent> c;
c.callbackType = Oyster::Callback::CallbackType_Object;
c.value = this;
this->client->SetCallback(c);
}
GameClient::~GameClient()
{
if(this->client) this->client->Disconnect();
this->player = 0;
this->id = -1;
}
void GameClient::SetCallback(Oyster::Callback::OysterCallback<void, NetworkSession::NetEvent> value)
{
this->callbackValue = value;
}
GameLogic::IPlayerData* GameClient::GetPlayer()
{
return this->player;
}
GameLogic::IPlayerData* GameClient::ReleasePlayer()
{
GameLogic::IPlayerData *temp = this->player;
this->player = 0;
return temp;
}
LobbyClient* GameClient::GetClient() const
{
return this->client;
}
Utility::DynamicMemory::SmartPointer<LobbyClient> GameClient::ReleaseClient()
{
SmartPointer<LobbyClient> temp = this->client;
this->client = 0;
return temp;
}
int GameClient::GetID() const
{
return this->id;
}
void GameClient::ObjectCallback(NetworkSession::NetEvent e)
{
e.gameClient = this;
this->callbackValue(e);
}

43
Code/Game/DanBiasServer/GameSession/GameClient.h
View File

@ -1,43 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#ifndef DANBIASSERVER_CLIENT_OBJECT_H
#define DANBIASSERVER_CLIENT_OBJECT_H
#include "..\LobbySessions\LobbyClient.h"
#include <PostBox\PostBox.h>
#include <GameAPI.h>
namespace DanBias
{
class GameClient: Oyster::Callback::CallbackObject<void, NetworkSession::NetEvent>
{
public:
GameClient(Utility::DynamicMemory::SmartPointer<LobbyClient> client, GameLogic::IPlayerData* player, Oyster::Callback::OysterCallback<void, NetworkSession::NetEvent> value);
virtual~GameClient();
void SetCallback(Oyster::Callback::OysterCallback<void, NetworkSession::NetEvent> value);
/* */
GameLogic::IPlayerData* GetPlayer();
GameLogic::IPlayerData* ReleasePlayer();
LobbyClient* GetClient() const;
Utility::DynamicMemory::SmartPointer<LobbyClient> ReleaseClient();
int GetID() const;
private:
//Utility::DynamicMemory::SmartPointer<GameLogic::Player> player;
GameLogic::IPlayerData* player;
Utility::DynamicMemory::SmartPointer<LobbyClient> client;
Oyster::Callback::OysterCallback<void, NetworkSession::NetEvent> callbackValue;
int id;
void ObjectCallback(NetworkSession::NetEvent) override;
private:
friend class AdminInterface;
};
}//End namespace DanBias
#endif // !DANBIASSERVER_CLIENT_OBJECT_H

123
Code/Game/DanBiasServer/GameSession/GameSessionManager.cpp
View File

@ -1,123 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#include "GameSessionManager.h"
#include "..\LobbySessions\LobbyClient.h"
#include "GameSession.h"
#include <DynamicArray.h>
using namespace DanBias;
using namespace Utility::DynamicMemory;
struct GameSessionData
{
DynamicArray< SmartPointer< GameSession > > sessions;
int freeSpot;
int Existst(int session)
{
for (unsigned int i = 0; i < sessions.Size(); i++)
{
if(!sessions[i] && freeSpot == -1) freeSpot = i;
if(sessions[i]->GetID() == session) return i;
}
return -1;
}
int GetFree()
{
for (unsigned int i = 0; i < sessions.Size(); i++)
{
if(!sessions[i])
{
this->freeSpot = i;
return this->freeSpot;
}
}
this->freeSpot = -1;
return this->freeSpot;
}
} gameSessionData;
int GameSessionManager::AddSession(GameSessionDescription& instance, bool run)
{
int k = gameSessionData.GetFree();
SmartPointer<GameSession> gs = new GameSession();
DanBias::GameSession::GameDescription desc;
desc.owner = instance.exitDestionation;
desc.clients = instance.clients;
desc.mapName = instance.mapName;
if(!gs->Create(desc)) return 0;
if(k == -1) gameSessionData.sessions.Push(gs);
else gameSessionData.sessions[k] = gs;
if(run) gs->Run();
return gs->GetID();
}
bool GameSessionManager::StartSession(int session)
{
int i = -1;
if((i = gameSessionData.Existst(session)) != -1) return false;
gameSessionData.sessions[i]->Run();
return true;
}
bool GameSessionManager::JoinSession(int session, Utility::DynamicMemory::SmartPointer<LobbyClient> client)
{
int i = -1;
if((i = gameSessionData.Existst(session)) == -1) return false;
gameSessionData.sessions[i]->Join(client);
return true;
}
void GameSessionManager::GetSessionInfo(int session, GameSessionInfo& data)
{
memset(&data, 0, sizeof(GameSessionInfo));
int i = -1;
if((i = gameSessionData.Existst(session)) != -1) return;
//data.gametime = gameSessionData.sessions[i]->
//data.mapName = gameSessionData.sessions[i]->
//data.numberOfPlayers = gameSessionData.sessions[i]->
}
void GameSessionManager::CloseSession()
{
for (unsigned int i = 0; i < gameSessionData.sessions.Size(); i++)
{
gameSessionData.sessions[i]->CloseSession();
}
}
void GameSessionManager::CloseSession(int session)
{
int i = -1;
if((i = gameSessionData.Existst(session)) != -1) return;
gameSessionData.sessions[i]->CloseSession();
}
int GameSessionManager::GetSessionSize()
{
return gameSessionData.sessions.Size();
}

82
Code/Game/DanBiasServer/GameSession/GameSessionManager.h
View File

@ -1,82 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#ifndef DANBIASSERVER_GAME_SEESION_MANAGER_H
#define DANBIASSERVER_GAME_SEESION_MANAGER_H
#include <string>
#include <Utilities.h>
#include <DynamicArray.h>
namespace DanBias
{
class LobbyClient;
class NetworkSession;
struct GameSessionDescription
{
std::wstring mapName;
Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<LobbyClient>> clients;
NetworkSession* exitDestionation; //The new owner when session dies
};
struct GameSessionInfo
{
std::wstring mapName;
unsigned int numberOfPlayers;
float gametime;
};
class GameSessionManager
{
public:
/**
* Add a new game session.
* On success, the function returns the game instance id number greater than 0.
*/
static int AddSession(GameSessionDescription& instance, bool run);
/**
* Starts an existing game session
* @param session The session id recieved when created.
* @param run Indicates if the game session should start imidiatly when created.
* @return Returns false if session is not found.
*/
static bool StartSession(int session);
/**
* Join an exiting session
* @param session The session id recieved when created.
* @param client The client that is to join a game session
* @return Returns false on failure.
*/
static bool JoinSession(int session, Utility::DynamicMemory::SmartPointer<LobbyClient> client);
/**
* Gets information about a given session
* @param session The session id recieved when created.
* @param sessionInformation The output parameter that will be filled.
*/
static void GetSessionInfo(int session, GameSessionInfo& sessionInformation);
/**
* Close a session.
* @param session The session id recieved when created a session.
*/
static void CloseSession(int session);
/**
* Close all sessions.
*/
static void CloseSession();
/**
* Get total sessions running
* @return Returns the total sessions curently running.
*/
static int GetSessionSize();
private:
friend class AdminInterface;
};
}
#endif // !DANBIASSERVER_GAME_SEESION_MANAGER_H

29
Code/Game/DanBiasServer/GameSession/GameSession_Network.cpp
View File

@ -1,29 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#include "GameSession.h"
#include "GameClient.h"
#include <Protocols.h>
#include <PostBox\PostBox.h>
#include <GameLogicStates.h>
#include <Windows.h>
using namespace Utility::DynamicMemory;
using namespace Oyster;
using namespace Oyster::Network;
using namespace Oyster::Thread;
using namespace GameLogic;
namespace DanBias
{
void GameSession::Send(Oyster::Network::CustomNetProtocol* p)
{
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
if(this->clients[i] && this->clients[i]->GetClient())
this->clients[i]->GetClient()->Send(p);
}
}
}//End namespace DanBias

30
Code/Game/DanBiasServer/Helpers/MapManager.h
View File

@ -1,30 +0,0 @@
/////////////////////////////////////////
// Created by [Dennis Andersen] [2013] //
/////////////////////////////////////////
#ifndef DANBIASSERVER_LEVELMANAGER_H
#define DANBIASSERVER_LEVELMANAGER_H
#include "ServerDataReader.h"
#include "..\LobbySessions\LobbyClient.h"
#include "..\LobbySessions\NetworkSession.h"
#include "..\LobbySessions\GameLobby.h"
#include <Utilities.h>
namespace DanBias
{
class MapManager
{
public:
struct MapInitDesc
{
const wchar_t* map;
Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<LobbyClient>> clients;
};
public:
static bool InitiateMapPack(const MapInitDesc& desc);
};
}
#endif // !DANBIASSERVER_LEVELMANAGER_H

44
Code/Game/DanBiasServer/Helpers/ServerDataReader.h
View File

@ -1,44 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#ifndef DANBIASSERVER_SERVER_INIT_READER_H
#define DANBIASSERVER_SERVER_INIT_READER_H
#include <fstream>
#include <string>
namespace DanBias
{
enum InitPath
{
InitPath_ServerIni,
};
static std::string GetInitPath(InitPath file)
{
std::string type = "";
std::string path = "";
std::string flag = "";
switch (file)
{
case DanBias::InitPath_ServerIni:
flag = "ServerInit";
break;
}
std::fstream in;
in.open("..\\Settings\\serversearchpath.ini", std::ios::in);
if(!in.is_open()) return "";
while (!in.eof() && type != flag)
{
in >> type;
in >> path;
}
in.close();
return path;
}
}
#endif // !DANBIASSERVER_SERVER_INIT_READER_H

21
Code/Game/DanBiasServer/LobbySessions/GameLobby.cpp
View File

@ -1,21 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#include "GameLobby.h"
namespace DanBias
{
GameLobby::GameLobby(Utility::DynamicMemory::SmartPointer<LobbyClient> owner)
{
}
GameLobby::~GameLobby()
{
}
void GameLobby::Release()
{
}
}//End namespace DanBias

24
Code/Game/DanBiasServer/LobbySessions/GameLobby.h
View File

@ -1,24 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#ifndef DANBIASSERVER_GAMELOBBY_H
#define DANBIASSERVER_GAMELOBBY_H
#include "NetworkSession.h"
namespace DanBias
{
class GameLobby :public NetworkSession
{
public:
GameLobby(Utility::DynamicMemory::SmartPointer<LobbyClient> owner);
virtual~GameLobby();
void Release();
private:
friend class AdminInterface;
};
}//End namespace DanBias
#endif // !DANBIASSERVER_GAME_LOBBY_H

18
Code/Game/DanBiasServer/LobbySessions/INetworkSession.cpp
View File

@ -1,18 +0,0 @@
#include "INetworkSession.h"
#include <GID.h>
INetworkSession::INetworkSession()
:id(GID())
{}
INetworkSession::INetworkSession(const INetworkSession& orig)
{
id = orig.id;
}
const INetworkSession& INetworkSession::operator=(const INetworkSession& orig)
{
id = orig.id;
return *this;
}
INetworkSession::~INetworkSession()
{}

22
Code/Game/DanBiasServer/LobbySessions/INetworkSession.h
View File

@ -1,22 +0,0 @@
/////////////////////////////////////////
// Created by [Dennis Andersen] [2013] //
/////////////////////////////////////////
#ifndef DANBIASSERVER_INETWORKSESSION_H
#define DANBIASSERVER_INETWORKSESSION_H
class INetworkSession
{
public:
INetworkSession();
INetworkSession(const INetworkSession& orig);
const INetworkSession& operator=(const INetworkSession& orig);
virtual~INetworkSession();
inline int GetID() const { return this->id; }
private:
int id;
};
#endif // !DANBIASSERVER_INETWORKSESSION_H

51
Code/Game/DanBiasServer/LobbySessions/LobbyClient.cpp
View File

@ -1,51 +0,0 @@
#include "LobbyClient.h"
#include <Protocols.h>
using namespace Utility::DynamicMemory;
using namespace Oyster::Network;
using namespace Oyster::Callback;
using namespace GameLogic;
namespace DanBias
{
LobbyClient::LobbyClient(SmartPointer<NetworkClient> client)
{
this->client = client;
this->client->SetRecieverObject(this, NetworkProtocolCallbackType_Object);
}
LobbyClient::~LobbyClient()
{
this->callbackValue.callbackType = CallbackType_Unknown;
}
void LobbyClient::Disconnect()
{
this->client->Disconnect();
}
void LobbyClient::SetCallback(OysterCallback<void, NetworkSession::NetEvent> value)
{
this->callbackValue = value;
}
/** This method is NOT threadsafe. */
void LobbyClient::NetworkCallback(CustomNetProtocol& protocol)
{
if(this->callbackValue.callbackType == CallbackType_Unknown) return;
NetworkSession::NetEvent e;
e.sender = this;
e.protocol = protocol;
this->callbackValue(e);
}
void LobbyClient::Disconnected()
{
if(this->callbackValue.callbackType == CallbackType_Unknown) return;
NetworkSession::NetEvent e;
e.sender = this;
e.protocol = *GameLogic::Protocol_General_Status(Protocol_General_Status::States_disconected).GetProtocol();
this->callbackValue(e);
}
}//End namsapce DanBias

38
Code/Game/DanBiasServer/LobbySessions/LobbyClient.h
View File

@ -1,38 +0,0 @@
/////////////////////////////////////////
// Created by [Dennis Andersen] [2013] //
/////////////////////////////////////////
#ifndef DANBIASSERVER_LOBBYCLIENT_H
#define DANBIASSERVER_LOBBYCLIENT_H
#include "NetworkSession.h"
#include <NetworkClient.h>
#include <PostBox\PostBox.h>
namespace DanBias
{
class LobbyClient :public Oyster::Network::NetClientEvent
{
public:
LobbyClient(Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> client);
virtual~LobbyClient();
void Disconnect();
void SetCallback(Oyster::Callback::OysterCallback<void, NetworkSession::NetEvent> value);
inline void Send(Oyster::Network::CustomProtocolObject& protocol) { this->client->Send(protocol); }
inline void Send(Oyster::Network::CustomNetProtocol* protocol) { this->client->Send(protocol); }
inline int GetID() const { return this->client->GetID(); }
private:
Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> client;
Oyster::Callback::OysterCallback<void, NetworkSession::NetEvent> callbackValue;
private:
void NetworkCallback(Oyster::Network::CustomNetProtocol& protocol) override;
void Disconnected() override;
private:
friend class AdminInterface;
};
}//End namspace DanBias
#endif // !DANBIASSERVER_LOBBYCLIENT_H

64
Code/Game/DanBiasServer/LobbySessions/LobbyGeneralProtocolParser.cpp
View File

@ -1,64 +0,0 @@
#include "MainLobby.h"
#include "LobbyClient.h"
using namespace DanBias;
using namespace GameLogic;
void MainLobby::ParseGeneralProtocol(Oyster::Network::CustomNetProtocol& p, DanBias::LobbyClient* c)
{
switch (p[0].value.netShort)
{
case protocol_General_Status:
{
GeneralStatus(GameLogic::Protocol_General_Status(p), c);
} break;
case protocol_General_Text:
{
GameLogic::Protocol_General_Text(p);
} break;
case protocol_Lobby_Login:
{
} break;
case protocol_Lobby_Join:
{
JoinLobby(GameLogic::Protocol_LobbyJoin(p), c);
} break;
}
}
void MainLobby::GeneralStatus(GameLogic::Protocol_General_Status& p, DanBias::LobbyClient* c)
{
switch (p.status)
{
case Protocol_General_Status::States_ready:
{
}
case Protocol_General_Status::States_idle:
{
}
case Protocol_General_Status::States_leave:
{
}
case Protocol_General_Status::States_disconected:
{
Detach(c)->Disconnect();
}
}
}
void MainLobby::JoinLobby(GameLogic::Protocol_LobbyJoin& p, DanBias::LobbyClient* c)
{
for (unsigned int i = 0; i < this->gameLobby.Size(); i++)
{
if (this->gameLobby[i]->GetID() == p.value)
{
this->gameLobby[i]->Attach(Detach(c));
return;
}
}
}

37
Code/Game/DanBiasServer/LobbySessions/LobbyProtocolParser.cpp
View File

@ -1,37 +0,0 @@
#include "MainLobby.h"
using namespace DanBias;
void MainLobby::ParseLobbyProtocol(Oyster::Network::CustomNetProtocol& p, DanBias::LobbyClient* c)
{
switch (p[0].value.netShort)
{
case protocol_Lobby_Create:
CreateGame(GameLogic::Protocol_LobbyCreateGame(p), c);
break;
case protocol_Lobby_Start:
break;
case protocol_Lobby_Refresh:
GameLogic::Protocol_LobbyRefresh();
break;
}
}
void MainLobby::CreateGame(GameLogic::Protocol_LobbyCreateGame& p, DanBias::LobbyClient* c)
{
for (unsigned int i = 0; i < this->gameLobby.Size(); i++)
{
if(!gameLobby[i])
{
gameLobby[i] = new GameLobby(NetworkSession::Detach(c));
return;
}
}
this->gameLobby.Push(new GameLobby(NetworkSession::Detach(c)));
}

62
Code/Game/DanBiasServer/LobbySessions/MainLobby.cpp
View File

@ -1,62 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#include "MainLobby.h"
#include "LobbyClient.h"
#include <PlayerProtocols.h>
#include <PostBox\PostBox.h>
using namespace Utility::DynamicMemory;
using namespace Oyster::Network;
using namespace Oyster;
namespace DanBias
{
MainLobby::MainLobby()
:gameLobby(5)
{
this->box = new PostBox<DanBias::NetworkSession::NetEvent>();
}
MainLobby::~MainLobby()
{
}
void MainLobby::Release()
{
delete this->box;
this->box = 0;
this->CloseSession(true);
}
void MainLobby::Frame()
{
ParseEvents();
}
IPostBox<NetworkSession::NetEvent>* MainLobby::GetPostbox()
{
return this->box;
}
void MainLobby::SetRefreshFrequency(float delta)
{
this->refreshFrequency = delta;
}
float MainLobby::GetRefreshFrequency() const
{
return this->refreshFrequency;
}
//////// Private
void MainLobby::ParseEvents()
{
if(this->box && !this->box->IsEmpty())
{
NetEvent &e = this->box->Fetch();
short type = e.protocol[0].value.netShort;
if(ProtocolIsLobby(type)) ParseLobbyProtocol(e.protocol, e.sender);
else if(ProtocolIsGeneral(type)) ParseGeneralProtocol(e.protocol, e.sender);
}
}
}//End namespace DanBias

49
Code/Game/DanBiasServer/LobbySessions/MainLobby.h
View File

@ -1,49 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#ifndef DANBIASSERVER_MAINLOBBY_H
#define DANBIASSERVER_MAINLOBBY_H
#include "NetworkSession.h"
#include "GameLobby.h"
#include <Protocols.h>
#include <PostBox\IPostBox.h>
#include <WinTimer.h>
namespace DanBias
{
class MainLobby :public NetworkSession
{
public:
MainLobby();
virtual~MainLobby();
void Release();
void Frame();
void SetPostbox(Oyster::IPostBox<NetworkSession::NetEvent>* box);
Oyster::IPostBox<NetworkSession::NetEvent>* GetPostbox();
void SetRefreshFrequency(float delta);
float GetRefreshFrequency() const;
private:
void ParseEvents();
void ParseGeneralProtocol(Oyster::Network::CustomNetProtocol& p, DanBias::LobbyClient* c);
void ParseLobbyProtocol(Oyster::Network::CustomNetProtocol& p, DanBias::LobbyClient* c);
void GeneralStatus(GameLogic::Protocol_General_Status& p, DanBias::LobbyClient* c);
void CreateGame(GameLogic::Protocol_LobbyCreateGame& p, DanBias::LobbyClient* c);
void JoinLobby(GameLogic::Protocol_LobbyJoin& p, DanBias::LobbyClient* c);
private:
Oyster::IPostBox<NetworkSession::NetEvent> *box;
Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<GameLobby>> gameLobby;
Utility::WinTimer timer;
float refreshFrequency;
private:
friend class AdminInterface;
};
}//End namespace DanBias
#endif // !DANBIASGAME_GAMELOBBY_H

219
Code/Game/DanBiasServer/LobbySessions/NetworkSession.cpp
View File

@ -1,219 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#include "LobbyClient.h"
#include "NetworkSession.h"
#include <mutex>
namespace DanBias
{
NetworkSession::NetworkSession()
: owner(0)
, clientCount(0)
{}
NetworkSession::NetworkSession(const NetworkSession& orig)
{
this->clients = orig.clients;
this->owner = orig.owner;
this->clientCount = orig.clientCount;
}
const NetworkSession& NetworkSession::operator=(const NetworkSession& orig)
{
this->clients = orig.clients;
this->owner = orig.owner;
this->clientCount = orig.clientCount;
return *this;
}
NetworkSession::~NetworkSession()
{
this->clients.Clear();
this->clientCount = 0;
}
bool NetworkSession::Attach(Utility::DynamicMemory::SmartPointer<LobbyClient> client)
{
clientListLock.lock();
int k = -1;
for (unsigned int i = 0; (k == -1) && i < this->clients.Size(); i++)
{
if(!this->clients[i])
k = i;
}
if(k == -1)
{
this->clients.Push(client);
}
else
{
this->clients[k] = client;
}
this->clientCount++;
clientListLock.unlock();
return true;
}
Utility::DynamicMemory::SmartPointer<LobbyClient> NetworkSession::Detach(Oyster::Network::NetworkClient* client)
{
Utility::DynamicMemory::SmartPointer<LobbyClient> val;
clientListLock.lock();
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
if(this->clients[0]->GetID() == client->GetID())
{
val = this->clients[i];
this->clients[i] = 0;
this->clientCount--;
}
}
clientListLock.unlock();
return val;
}
Utility::DynamicMemory::SmartPointer<LobbyClient> NetworkSession::Detach(const LobbyClient* client)
{
Utility::DynamicMemory::SmartPointer<LobbyClient> val;
clientListLock.lock();
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
if(this->clients[0]->GetID() == client->GetID())
{
val = this->clients[i];
this->clients[i] = 0;
this->clientCount--;
}
}
clientListLock.unlock();
return val;
}
Utility::DynamicMemory::SmartPointer<LobbyClient> NetworkSession::Detach(const LobbyClient& client)
{
Utility::DynamicMemory::SmartPointer<LobbyClient> val;
clientListLock.lock();
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
if(this->clients[0]->GetID() == client.GetID())
{
val = this->clients[i];
this->clients[i] = 0;
this->clientCount--;
}
}
clientListLock.unlock();
return val;
}
Utility::DynamicMemory::SmartPointer<LobbyClient> NetworkSession::Detach(short ID)
{
Utility::DynamicMemory::SmartPointer<LobbyClient> val;
clientListLock.lock();
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
if(this->clients[0]->GetID() == ID)
{
val = this->clients[i];
this->clients[i] = 0;
this->clientCount--;
}
}
clientListLock.unlock();
return val;
}
bool NetworkSession::Send(Oyster::Network::CustomNetProtocol& protocol)
{
bool returnValue = false;
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
if(this->clients[i])
{
this->clients[i]->Send(&protocol);
returnValue = true;
}
}
return returnValue;
}
bool NetworkSession::Send(Oyster::Network::CustomNetProtocol& protocol, int ID)
{
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
if(this->clients[i] && this->clients[i]->GetID() == ID)
{
this->clients[i]->Send(&protocol);
return true;
}
}
return false;
}
void NetworkSession::SetCallback(Oyster::Callback::OysterCallback<void, NetworkSession::NetEvent> value)
{
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
this->clients[i]->SetCallback(value);
}
}
void NetworkSession::CloseSession(bool dissconnectClients)
{
clientListLock.lock();
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
if(dissconnectClients) this->clients[i]->Disconnect();
else if(this->owner) this->owner->Attach(this->clients[i]);
}
this->clients.Clear();
clientListLock.unlock();
}
Utility::DynamicMemory::SmartPointer<LobbyClient> NetworkSession::FindClient(int ID)
{
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
if(this->clients[i]->GetID() == ID)
return this->clients[i];
}
return Utility::DynamicMemory::SmartPointer<LobbyClient>();
}
Utility::DynamicMemory::SmartPointer<LobbyClient> NetworkSession::FindClient(LobbyClient& obj)
{
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
if(this->clients[i]->GetID() == obj.GetID())
return this->clients[i];
}
return Utility::DynamicMemory::SmartPointer<LobbyClient>();
}
Utility::DynamicMemory::SmartPointer<LobbyClient> NetworkSession::FindClient(LobbyClient* obj)
{
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
if(this->clients[i]->GetID() == obj->GetID())
return this->clients[i];
}
return Utility::DynamicMemory::SmartPointer<LobbyClient>();
}
}//End namespace DanBias

91
Code/Game/DanBiasServer/LobbySessions/NetworkSession.h
View File

@ -1,91 +0,0 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#ifndef DANBIASSERVER_NETWORK_SESSION_H
#define DANBIASSERVER_NETWORK_SESSION_H
//warning C4150: deletion of pointer to incomplete type, no destructor called
#pragma warning(disable : 4150)
#define NOMINMAX
#include "INetworkSession.h"
#include <Utilities.h>
#include <OysterCallback.h>
#include <DynamicArray.h>
#include <PostBox\IPostBox.h>
#include <CustomNetProtocol.h>
#include <NetworkClient.h>
#include <vector>
#include <mutex>
namespace DanBias
{
class LobbyClient;
class GameClient;
class NetworkSession :public INetworkSession
{
public:
struct NetEvent
{
LobbyClient* sender;
GameClient* gameClient;
Oyster::Network::CustomNetProtocol protocol;
NetEvent():sender(0), gameClient(0){}
};
public:
NetworkSession();
NetworkSession(const NetworkSession& orig);
const NetworkSession& operator=(const NetworkSession& orig);
virtual~NetworkSession();
virtual bool Attach(Utility::DynamicMemory::SmartPointer<LobbyClient> client);
virtual Utility::DynamicMemory::SmartPointer<LobbyClient> Detach(Oyster::Network::NetworkClient* client);
virtual Utility::DynamicMemory::SmartPointer<LobbyClient> Detach(const LobbyClient* client);
virtual Utility::DynamicMemory::SmartPointer<LobbyClient> Detach(const LobbyClient& client);
virtual Utility::DynamicMemory::SmartPointer<LobbyClient> Detach(short ID);
Utility::DynamicMemory::SmartPointer<LobbyClient> FindClient(LobbyClient& obj);
Utility::DynamicMemory::SmartPointer<LobbyClient> FindClient(LobbyClient* obj);
Utility::DynamicMemory::SmartPointer<LobbyClient> FindClient(int ID);
/**
* Sends a message to all clients in this session.
*/
virtual bool Send(Oyster::Network::CustomNetProtocol& message);
/**
* Sends a message to a specific client in this session.
*/
virtual bool Send(Oyster::Network::CustomNetProtocol& protocol, int ID);
/**
* Set the callback to all clients to where a messages is recieved.
*/
virtual void SetCallback(Oyster::Callback::OysterCallback<void, NetworkSession::NetEvent> value);
/**
* Closes the session and sends the clients to given owner session if any.
* If session is null, clients is assumed to already be elsewhere and only releases a reference.
*/
virtual void CloseSession(bool dissconnectClients = false);
/** Set where the clients is returned on closed session. */
inline void SetOwner(NetworkSession* owner) { this->owner = owner; }
protected:
Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<LobbyClient>> clients;
NetworkSession* owner; //Where clients end up when session is closed.
private:
std::mutex clientListLock;
int clientCount;
private:
friend class AdminInterface;
};
}//End namespace DanBias
#endif // !DANBIASSERVER_NETWORK_SESSION_H

29
Code/Game/DanBiasServerLauncher/DanBiasServerLauncher.vcxproj
View File

@ -71,7 +71,7 @@
<OutDir>$(SolutionDir)..\Bin\Executable\</OutDir>
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
<IncludePath>$(SolutionDir)Game\DanBiasServer;C:\Program Files %28x86%29\Visual Leak Detector\include;$(IncludePath)</IncludePath>
<IncludePath>$(SolutionDir)Game\GameServer;C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)WindowManager\;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir)..\DLL\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@ -79,7 +79,7 @@
<OutDir>$(SolutionDir)..\Bin\Executable\</OutDir>
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
<IncludePath>$(SolutionDir)Game\DanBiasServer;C:\Program Files %28x86%29\Visual Leak Detector\include;$(IncludePath)</IncludePath>
<IncludePath>$(SolutionDir)Game\GameServer;C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)WindowManager\;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir)..\DLL\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@ -87,7 +87,7 @@
<OutDir>$(SolutionDir)..\Bin\Executable\</OutDir>
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
<IncludePath>$(SolutionDir)Game\DanBiasServer;C:\Program Files %28x86%29\Visual Leak Detector\include;$(IncludePath)</IncludePath>
<IncludePath>$(SolutionDir)Game\GameServer;C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)WindowManager\;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir)..\DLL\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@ -95,7 +95,7 @@
<OutDir>$(SolutionDir)..\Bin\Executable\</OutDir>
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
<IncludePath>$(SolutionDir)Game\DanBiasServer;C:\Program Files %28x86%29\Visual Leak Detector\include;$(IncludePath)</IncludePath>
<IncludePath>$(SolutionDir)Game\GameServer;C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)WindowManager\;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir)..\DLL\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
@ -111,8 +111,8 @@
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<DelayLoadDLLs>DanBiasGame_$(PlatformShortName)D.dll;DanBiasServer_$(PlatformShortName)D.dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>DanBiasGame_$(PlatformShortName)D.lib;DanBiasServer_$(PlatformShortName)D.lib;%(AdditionalDependencies)</AdditionalDependencies>
<DelayLoadDLLs>DanBiasGame_$(PlatformShortName)D.dll;GameServer_$(PlatformShortName)D.dll</DelayLoadDLLs>
<AdditionalDependencies>GameServer_$(PlatformShortName)D.lib;DanBiasGame_$(PlatformShortName)D.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@ -128,8 +128,8 @@
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<DelayLoadDLLs>DanBiasServer_$(PlatformShortName)D.dll;DanBiasGame_$(PlatformShortName)D.dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>DanBiasGame_$(PlatformShortName)D.lib;DanBiasServer_$(PlatformShortName)D.lib;%(AdditionalDependencies)</AdditionalDependencies>
<DelayLoadDLLs>DanBiasGame_$(PlatformShortName)D.dll;GameServer_$(PlatformShortName)D.dll</DelayLoadDLLs>
<AdditionalDependencies>GameServer_$(PlatformShortName)D.lib;DanBiasGame_$(PlatformShortName)D.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@ -149,8 +149,8 @@
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<DelayLoadDLLs>DanBiasServer_$(PlatformShortName).dll;DanBiasGame_$(PlatformShortName).dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>DanBiasServer_$(PlatformShortName).lib;DanBiasGame_$(PlatformShortName).lib;%(AdditionalDependencies)</AdditionalDependencies>
<DelayLoadDLLs>DanBiasGame_$(PlatformShortName).dll;GameServer_$(PlatformShortName).dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>GameServer_$(PlatformShortName).lib;DanBiasGame_$(PlatformShortName).lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@ -170,13 +170,18 @@
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<DelayLoadDLLs>DanBiasServer_$(PlatformShortName).dll;DanBiasGame_$(PlatformShortName).dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>DanBiasServer_$(PlatformShortName).lib;DanBiasGame_$(PlatformShortName).lib;%(AdditionalDependencies)</AdditionalDependencies>
<DelayLoadDLLs>DanBiasGame_$(PlatformShortName).dll;GameServer_$(PlatformShortName).dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>GameServer_$(PlatformShortName).lib;DanBiasGame_$(PlatformShortName).lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="ServerLauncher.cpp" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\WindowManager\WindowManager.vcxproj">
<Project>{35aea3c0-e0a7-4e1e-88cd-514aa5a442b1}</Project>
</ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>

25
Code/Game/DanBiasServerLauncher/ServerLauncher.cpp
View File

@ -2,12 +2,13 @@
// Launcher to launch Danbias server //
// Created by [Dennis Andersen] [2013] //
//////////////////////////////////////////////////
#define NOMINMAX //Blame it on windows
#define NOMINMAX //Blame it on microsoft
#include <Windows.h>
#include <vld.h>
#include <iostream>
#include <WindowShell.h>
#include <DanBiasServerAPI.h>
#include <GameServerAPI.h>
int WINAPI WinMain( HINSTANCE hinst, HINSTANCE prevInst, PSTR cmdLine, int cmdShow)
{
@ -15,10 +16,22 @@ int WINAPI WinMain( HINSTANCE hinst, HINSTANCE prevInst, PSTR cmdLine, int cmdSh
{
return cmdShow;
}
if( DanBias::DanBiasServerAPI::Initiate() == DanBias::DanBiasServerReturn_Sucess)
WindowShell::CreateConsoleWindow();
DanBias::GameServerAPI::ServerInitDesc desc;
desc.listenPort = 15151;
if(DanBias::GameServerAPI::ServerInitiate(desc) == DanBias::DanBiasServerReturn_Sucess)
{
DanBias::DanBiasServerAPI::Run();
DanBias::DanBiasServerAPI::Release();
DanBias::GameServerAPI::ServerStart();
//DanBias::GameServerAPI::GameStart();
while (!(GetAsyncKeyState(0x51))) //Q for exit
{
DanBias::GameServerAPI::ServerUpdate();
Sleep(1);
}
DanBias::GameServerAPI::ServerStop();
}
return cmdShow;
}

2
Code/Game/GameLogic/CollisionManager.cpp
View File

@ -21,7 +21,7 @@ using namespace GameLogic;
Object *realObj = (Object*)obj->GetCustomTag(); //needs to be changed?
return;
switch (realObj->GetType())
switch (realObj->GetObjectType())
{
case OBJECT_TYPE::OBJECT_TYPE_GENERIC:
PlayerVObject(*player,*realObj, kineticEnergyLoss);

17
Code/Game/GameLogic/Game.cpp
View File

@ -93,17 +93,7 @@ void Game::CreateTeam()
bool Game::NewFrame()
{
for (unsigned int i = 0; i < this->players.Size(); i++)
{
if(this->players[i]->player) this->players[i]->player->BeginFrame();
}
API::Instance().Update();
for (unsigned int i = 0; i < this->players.Size(); i++)
{
if(this->players[i]->player) this->players[i]->player->EndFrame();
}
for (unsigned int i = 0; i < this->players.Size(); i++)
{
if(this->players[i]->player) this->players[i]->player->BeginFrame();
@ -138,7 +128,12 @@ bool Game::NewFrame()
if(this->players[i]->player) this->players[i]->player->EndFrame();
}
<<<<<<< HEAD
gameInstance.onMoveFnc(this->level);
=======
//gameInstance.onMoveFnc(this->level);
>>>>>>> cec022b3814c680d5be161e7cfe0596841736c77
return true;
}

10
Code/Game/GameLogic/Game.h
View File

@ -32,14 +32,15 @@ namespace GameLogic
~PlayerData();
void Move(const PLAYER_MOVEMENT &movement) override;
void Rotate(const Oyster::Math3D::Float3 lookDir) override;
void UseWeapon(const WEAPON_FIRE &usage) override;
int GetTeamID() const override;
PLAYER_STATE GetState() const override;
Oyster::Math::Float3 GetPosition() override;
Oyster::Math::Float4x4 GetOrientation() override;
int GetID() const override;
OBJECT_TYPE GetType() const override;
OBJECT_TYPE GetObjectType() const override;
void Rotate(const Oyster::Math3D::Float3 lookDir) override;
Player *player;
};
@ -51,9 +52,8 @@ namespace GameLogic
Oyster::Math::Float3 GetPosition() override;
Oyster::Math::Float4x4 GetOrientation() override;
int GetID() const override;
OBJECT_TYPE GetType() const override;
IObjectData* GetObjectAt( int ID ) const override;
OBJECT_TYPE GetObjectType() const override;
IObjectData* GetObjectAt(int ID) const override;
Level *level;
};

8
Code/Game/GameLogic/GameAPI.h
View File

@ -13,6 +13,7 @@
#include "GameLogicStates.h"
#include <OysterMath.h>
namespace GameLogic
{
class IObjectData;
@ -61,7 +62,7 @@ namespace GameLogic
/** Get the type of the object
* @return The OBJECT_TYPE of the object is returned
*/
virtual OBJECT_TYPE GetType() const = 0;
virtual OBJECT_TYPE GetObjectType() const = 0;
};
class IPlayerData :public IObjectData
@ -78,7 +79,7 @@ namespace GameLogic
* @param x: The relative x axis
* @param y: The relative y axis
**/
virtual void Rotate(const const Oyster::Math3D::Float3 lookDir) = 0;
virtual void Rotate(const Oyster::Math3D::Float3 lookDir) = 0;
/********************************************************
* Uses the chosen players weapon based on input
@ -99,8 +100,7 @@ namespace GameLogic
class ILevelData :public IObjectData
{
public:
virtual IObjectData* GetObjectAt( int ID) const = 0;
virtual IObjectData* GetObjectAt(int ID) const = 0;
};
class DANBIAS_GAMELOGIC_DLL GameAPI

9
Code/Game/GameLogic/GameLogic.vcxproj
View File

@ -184,7 +184,12 @@
<ClInclude Include="GameMode.h" />
<ClInclude Include="IAttatchment.h" />
<ClInclude Include="Level.h" />
<ClInclude Include="LevelLoader\LevelLoader.h" />
<ClInclude Include="LevelLoader\Loader.h" />
<ClInclude Include="Object.h" />
<ClInclude Include="LevelLoader\ObjectDefines.h" />
<ClInclude Include="LevelLoader\LevelParser.h" />
<ClInclude Include="LevelLoader\ParseFunctions.h" />
<ClInclude Include="Player.h" />
<ClInclude Include="StaticObject.h" />
<ClInclude Include="Team.h" />
@ -202,7 +207,11 @@
<ClCompile Include="Game_PlayerData.cpp" />
<ClCompile Include="IAttatchment.cpp" />
<ClCompile Include="Level.cpp" />
<ClCompile Include="LevelLoader\LevelLoader.cpp" />
<ClCompile Include="LevelLoader\Loader.cpp" />
<ClCompile Include="LevelLoader\LevelParser.cpp" />
<ClCompile Include="Object.cpp" />
<ClCompile Include="LevelLoader\ParseFunctions.cpp" />
<ClCompile Include="Player.cpp" />
<ClCompile Include="StaticObject.cpp" />
<ClCompile Include="Team.cpp" />

4
Code/Game/GameLogic/Game_LevelData.cpp
View File

@ -30,9 +30,9 @@ int Game::LevelData::GetID() const
{
return ((IObjectData*)this->level)->GetID();
}
OBJECT_TYPE Game::LevelData::GetType() const
OBJECT_TYPE Game::LevelData::GetObjectType() const
{
return ((IObjectData*)this->level)->GetType();
return ((IObjectData*)this->level)->GetObjectType();
//return OBJECT_TYPE_UNKNOWN;
}

7
Code/Game/GameLogic/Game_PlayerData.cpp
View File

@ -27,7 +27,8 @@ Game::PlayerData::~PlayerData()
delete this->player;
}
void Game::PlayerData::Move(const PLAYER_MOVEMENT &movement){
void Game::PlayerData::Move(const PLAYER_MOVEMENT &movement)
{
this->player->Move(movement);
}
void Game::PlayerData::UseWeapon(const WEAPON_FIRE &usage)
@ -55,9 +56,9 @@ int Game::PlayerData::GetTeamID() const
return this->player->GetTeamID();
}
OBJECT_TYPE Game::PlayerData::GetType() const
OBJECT_TYPE Game::PlayerData::GetObjectType() const
{
return this->player->GetType();
return this->player->GetObjectType();
}
void Game::PlayerData::Rotate(const Oyster::Math3D::Float3 lookDir)
{

18
Code/Game/GameLogic/LevelLoader/LevelLoader.cpp Normal file
View File

@ -0,0 +1,18 @@
//////////////////////////////////
// Created by Sam Svensson 2013 //
//////////////////////////////////
#include "LevelLoader.h"
using namespace GameLogic;
using namespace GameLogic::LevelFileLoader;
std::vector<ObjectTypeHeader> LevelLoader::LoadLevel(std::string fileName)
{
return parser.Parse(fileName);
}
LevelMetaData LevelLoader::LoadLevelHeader(std::string fileName)
{
return parser.ParseHeader(fileName);
}

42
Code/Game/GameLogic/LevelLoader/LevelLoader.h Normal file
View File

@ -0,0 +1,42 @@
//////////////////////////////////
// Created by Sam Svensson 2013 //
//////////////////////////////////
#ifndef LEVELLOADER_H
#define LEVELLOADER_H
#include <string>
#include <vector>
#include <Vector.h>
#include "ObjectDefines.h"
#include "LevelParser.h"
namespace GameLogic
{
class LevelLoader
{
public:
LevelLoader(){this->parser = GameLogic::LevelFileLoader::LevelParser(); }
~LevelLoader(){}
/********************************************************
* Loads the level and objects from file.
* @param fileName: Path to the level-file that you want to load.
* @return: Returns all structs with objects and information about the level.
********************************************************/
std::vector<ObjectTypeHeader> LoadLevel(std::string fileName);
/********************************************************
* Just for fast access for the meta information about the level.
* @param fileName: Path to the level-file that you want to load.
* @return: Returns the meta information about the level.
********************************************************/
LevelMetaData LoadLevelHeader(std::string fileName); //.
private:
GameLogic::LevelFileLoader::LevelParser parser;
};
}
#endif

117
Code/Game/GameLogic/LevelLoader/LevelParser.cpp Normal file
View File

@ -0,0 +1,117 @@
#include "LevelParser.h"
#include "Loader.h"
#include "ParseFunctions.h"
using namespace GameLogic;
using namespace ::LevelFileLoader;
LevelParser::LevelParser()
{
formatVersion.formatVersionMajor = 1;
formatVersion.formatVersionMinor = 0;
}
LevelParser::~LevelParser()
{
}
std::vector<ObjectTypeHeader> LevelParser::Parse(std::string filename)
{
int bufferSize = 0;
int counter = 0;
std::vector<ObjectTypeHeader> objects;
//Read entire level file.
Loader loader;
char* buffer = (char*)loader.LoadFile(filename.c_str(), bufferSize);
//Read format version
FormatVersion levelFormatVersion;
//ParseObject(&buffer[counter], &levelFormatVersion, sizeof(formatVersion));
if(this->formatVersion != levelFormatVersion)
{
//Do something if it's not the same version
}
while(counter < bufferSize)
{
//Get typeID
ObjectTypeHeader typeID;
ParseObject(&buffer[counter], &typeID, sizeof(typeID));
switch((int)typeID.typeID)
{
case ObjectType_LevelMetaData:
{
LevelMetaData header;
ParseLevelMetaData(&buffer[counter], header, counter);
objects.push_back(header);
break;
}
case ObjectType_Dynamic:
{
ObjectHeader header;
ParseObject(&buffer[counter], &header, sizeof(header));
objects.push_back(header);
counter += sizeof(header);
break;
}
default:
//Couldn't find typeID. FAIL!!!!!!
break;
}
}
return objects;
}
//för meta information om leveln.
LevelMetaData LevelParser::ParseHeader(std::string filename)
{
int bufferSize = 0;
int counter = 0;
LevelMetaData levelHeader;
levelHeader.typeID = ObjectType::ObjectType_Unknown;
//Read entire level file.
Loader loader;
char* buffer = (char*)loader.LoadFile(filename.c_str(), bufferSize);
//Read format version
FormatVersion levelFormatVersion;
//ParseObject(&buffer[counter], &levelFormatVersion, sizeof(formatVersion));
if(this->formatVersion != levelFormatVersion)
{
//Do something if it's not the same version
}
//Find the header in the returned string.
while(counter < bufferSize)
{
ObjectTypeHeader typeID;
ParseObject(&buffer[counter], &typeID, sizeof(typeID));
switch(typeID.typeID)
{
case ObjectType_LevelMetaData:
ParseLevelMetaData(&buffer[counter], levelHeader, counter);
return levelHeader;
break;
case ObjectType_Dynamic:
//Do not call parse this object, since we are only interested in the LevelMetaData
//Only increase the counter size
counter += sizeof(ObjectHeader);
break;
default:
//Couldn't find typeID. FAIL!!!!!!
break;
}
}
return levelHeader;
}

30
Code/Game/GameLogic/LevelLoader/LevelParser.h Normal file
View File

@ -0,0 +1,30 @@
#ifndef LEVEL_PARSER_H
#define LEVEL_PARSER_H
#include <string>
#include <vector>
#include "ObjectDefines.h"
namespace GameLogic
{
namespace LevelFileLoader
{
class LevelParser
{
public:
LevelParser();
~LevelParser();
//
std::vector<ObjectTypeHeader> Parse(std::string filename);
//
LevelMetaData ParseHeader(std::string filename);
private:
FormatVersion formatVersion;
};
}
}
#endif

22
Code/Game/GameLogic/LevelLoader/Loader.cpp Normal file
View File

@ -0,0 +1,22 @@
//////////////////////////////////
// Created by Sam Svensson 2013 //
//////////////////////////////////
#include "Loader.h"
#include <fstream>
using namespace GameLogic::LevelFileLoader;
using namespace Oyster::Resource;
using namespace std;
char* Loader::LoadFile(std::string fileName, int &size)
{
//convert from string to wstring
std::wstring temp(fileName.begin(), fileName.end());
//convert from wstring to wchar then loads the file
char* buffer = (char*)OysterResource::LoadResource(temp.c_str(), Oyster::Resource::ResourceType::ResourceType_Byte_Raw, -1 , false);
size = OysterResource::GetResourceSize(buffer);
return buffer;
}

28
Code/Game/GameLogic/LevelLoader/Loader.h Normal file
View File

@ -0,0 +1,28 @@
//////////////////////////////////
// Created by Sam Svensson 2013 //
//////////////////////////////////
#ifndef LOADER_H
#define LOADER_H
#include "..\Misc\Resource\OysterResource.h"
#include <string>
namespace GameLogic
{
namespace LevelFileLoader
{
class Loader
{
public:
Loader (){};
~Loader(){};
char* LoadFile(std::string fileName, int &size);
//TODO:
//Add functionality to load physicsObjects (hitboxes)
};
}
}
#endif;

109
Code/Game/GameLogic/LevelLoader/ObjectDefines.h Normal file
View File

@ -0,0 +1,109 @@
#ifndef OBJECT_DEFINES_H
#define OBJECT_DEFINES_H
#include <string>
#include <vector>
namespace GameLogic
{
/************************************
Enums
*************************************/
enum ObjectType
{
ObjectType_LevelMetaData,
ObjectType_Static,
ObjectType_Dynamic,
//Etc
ObjectType_NUM_OF_TYPES,
ObjectType_Unknown = -1,
};
enum UsePhysics
{
UsePhysics_UseFullPhysics,
UsePhysics_IgnoreGravity,
UsePhysics_IgnorePhysics,
UsePhysics_Count,
UsePhysics_Unknown = -1,
};
//Should this be moved somewhere else?
enum GameMode
{
GameMode_FreeForAll,
GameMode_TeamDeathMatch,
//Etc
GameMode_Count,
GameMode_Unknown = -1,
};
/************************************
Structs
*************************************/
struct FormatVersion
{
int formatVersionMajor;
int formatVersionMinor;
bool operator ==(const FormatVersion& obj)
{
return (this->formatVersionMajor != obj.formatVersionMajor && this->formatVersionMinor != obj.formatVersionMinor);
}
bool operator !=(const FormatVersion& obj)
{
return !(*this == obj);
}
};
struct ObjectTypeHeader
{
ObjectType typeID;
};
struct PhysicsObject
{
float mass;
float elasticity;
float frictionCoeffStatic;
float frictionCoeffDynamic;
float inertiaTensor[16];
UsePhysics usePhysics;
};
struct LevelMetaData : ObjectTypeHeader
{
std::string levelName;
FormatVersion levelVersion;
std::string levelDescription;
std::string levelAuthor;
int maxNumberOfPlayer;
float worldSize;
int overviewPictureID;
std::vector<GameMode> gameModesSupported;
};
struct ObjectHeader : public ObjectTypeHeader
{
//Model,
int ModelID;
//Texture
int TextureID;
//Position
float position[3];
//Rotation
float rotation[3];
//Scale
float scale[3];
};
}
#endif

80
Code/Game/GameLogic/LevelLoader/ParseFunctions.cpp Normal file
View File

@ -0,0 +1,80 @@
//////////////////////////////////
// Created by Sam Svensson 2013 //
//////////////////////////////////
#include "ParseFunctions.h"
#include "../../../Misc/Packing/Packing.h"
#include <string>
using namespace Oyster::Packing;
using namespace GameLogic::LevelFileLoader;
using namespace GameLogic;
using namespace std;
namespace GameLogic
{
namespace LevelFileLoader
{
void ParseObject(char* buffer, void *header, int size)
{
memcpy(header, buffer, size);
}
void ParseLevelMetaData(char* buffer, LevelMetaData &header, int &size)
{
int start = 0;
int tempSize;
char tempName[100];
memcpy(&header.typeID, &buffer[start], 4);
start += 4;
memcpy(&tempSize , &buffer[start], 4);
start += 4;
memcpy(&tempName, &buffer[start], tempSize);
header.levelName.assign(&tempName[0], &tempName[tempSize]);
start += tempSize;
memcpy(&header.levelVersion, &buffer[start], 8);
start += 8;
memcpy(&tempSize, &buffer[start], 4);
start +=4;
memcpy(&tempName, &buffer[start], tempSize);
header.levelDescription.assign(&tempName[0], &tempName[tempSize]);
start += tempSize;
memcpy(&tempSize, &buffer[start], 4);
start += 4;
memcpy(&tempName, &buffer[start], tempSize);
header.levelAuthor.assign(&tempName[0], &tempName[tempSize]);
start += tempSize;
memcpy(&header.maxNumberOfPlayer, &buffer[start], 4);
start += 4;
memcpy(&header.worldSize, &buffer[start], 4);
start += 4;
memcpy(&header.overviewPictureID, &buffer[start], 4);
start += 4;
memcpy(&tempSize, &buffer[start], 4);
start += 4;
int temp;
for(int i = 0; i < tempSize; i++)
{
memcpy(&temp, &buffer[start], 4);
start += 4;
header.gameModesSupported.push_back((GameMode)temp);
}
size += start;
}
}
}

19
Code/Game/GameLogic/LevelLoader/ParseFunctions.h Normal file
View File

@ -0,0 +1,19 @@
//////////////////////////////////
// Created by Sam Svensson 2013 //
//////////////////////////////////
#ifndef PARSERFUNCTIONS_H
#define PARSERFUNCTIONS_H
#include "ObjectDefines.h"
namespace GameLogic
{
namespace LevelFileLoader
{
void ParseObject(char* buffer, void *header, int size);
void ParseLevelMetaData(char* buffer, LevelMetaData &header, int &size);
}
}
#endif

2
Code/Game/GameLogic/Object.cpp
View File

@ -101,7 +101,7 @@ Object::~Object(void)
}
OBJECT_TYPE Object::GetType() const
OBJECT_TYPE Object::GetObjectType() const
{
return this->type;
}

2
Code/Game/GameLogic/Object.h
View File

@ -26,7 +26,7 @@ namespace GameLogic
~Object(void);
// API overrides
OBJECT_TYPE GetType() const;
OBJECT_TYPE GetObjectType() const;
int GetID() const;
Oyster::Math::Float3 GetPosition();
Oyster::Math::Float4x4 GetOrientation();

1
Code/Game/GameProtocols/GameProtocols.vcxproj
View File

@ -155,7 +155,6 @@
</ItemDefinitionGroup>
<ItemGroup>
<ClInclude Include="GeneralProtocols.h" />
<ClInclude Include="GameplayProtocols.h" />
<ClInclude Include="Protocols.h" />
<ClInclude Include="LobbyProtocols.h" />
<ClInclude Include="ObjectProtocols.h" />

13
Code/Game/GameProtocols/GameplayProtocols.h
View File

@ -1,13 +0,0 @@
#ifndef GAMEPROTOCOLS_GAMEPLAYPROTOCOLS_H
#define GAMEPROTOCOLS_GAMEPLAYPROTOCOLS_H
#include <vector>
#include <CustomNetProtocol.h>
#include "ProtocolIdentificationID.h"
namespace GameLogic
{
}
#endif // !GAMEPROTOCOLS_GAMEPLAYPROTOCOLS_H

10
Code/Game/GameProtocols/GeneralProtocols.h
View File

@ -19,8 +19,8 @@ namespace GameLogic
Protocol_General_Status()
{
this->protocol[protocol_INDEX_ID].value = protocol_General_Status;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_General_Status;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
}
@ -31,8 +31,8 @@ namespace GameLogic
}
Protocol_General_Status(States state)
{
this->protocol[protocol_INDEX_ID].value = protocol_General_Status;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_General_Status;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->status = state;
this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
}
@ -61,7 +61,7 @@ namespace GameLogic
}
Oyster::Network::CustomNetProtocol* GetProtocol() override
{
this->protocol.Set(protocol_INDEX_ID, protocol_General_Text, Oyster::Network::NetAttributeType_Short);
this->protocol.Set(0, protocol_General_Text, Oyster::Network::NetAttributeType_Short);
this->protocol.Set(1, destination, Oyster::Network::NetAttributeType_Int);
this->protocol.Set(2, text);
return &protocol;

215
Code/Game/GameProtocols/LobbyProtocols.h
View File

@ -14,6 +14,7 @@
namespace GameLogic
{
/*
struct Protocol_LobbyCreateGame :public Oyster::Network::CustomProtocolObject
{
char* mapName;
@ -21,8 +22,8 @@ namespace GameLogic
Protocol_LobbyCreateGame()
{
this->protocol[protocol_INDEX_ID].value = protocol_Lobby_Create;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Lobby_Create;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_CharArray;
this->protocol[2].type = Oyster::Network::NetAttributeType_Char;
@ -42,17 +43,21 @@ namespace GameLogic
private:
Oyster::Network::CustomNetProtocol protocol;
};
*/
struct Protocol_LobbyStartGame :public Oyster::Network::CustomProtocolObject
{
char gameId;
short gameId;
Protocol_LobbyStartGame()
{
this->protocol[protocol_INDEX_ID].value = protocol_Lobby_Start;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Lobby_Start;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Char;
this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
}
Protocol_LobbyStartGame(Oyster::Network::CustomNetProtocol& o)
{
gameId = o[1].value.netInt;
}
Oyster::Network::CustomNetProtocol* GetProtocol() override
{
@ -69,10 +74,14 @@ namespace GameLogic
// Login stuff
Protocol_LobbyLogin()
{
this->protocol[protocol_INDEX_ID].value = protocol_Lobby_Join;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Lobby_Join;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
}
Protocol_LobbyLogin(Oyster::Network::CustomNetProtocol& p)
{
}
Oyster::Network::CustomNetProtocol* GetProtocol() override
{
@ -83,39 +92,43 @@ namespace GameLogic
Oyster::Network::CustomNetProtocol protocol;
};
struct Protocol_LobbyJoin :public Oyster::Network::CustomProtocolObject
{
short value;
Protocol_LobbyJoin()
{
this->protocol[protocol_INDEX_ID].value = protocol_Lobby_Join;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
}
Protocol_LobbyJoin(Oyster::Network::CustomNetProtocol& p)
{
this->protocol[protocol_INDEX_ID].value = protocol_Lobby_Join;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
value = p[1].value.netShort;
}
Oyster::Network::CustomNetProtocol* GetProtocol() override
{
protocol[1].value = value;
return &protocol;
}
private:
Oyster::Network::CustomNetProtocol protocol;
};
//struct Protocol_LobbyJoin :public Oyster::Network::CustomProtocolObject
//{
// short value;
//
// Protocol_LobbyJoin()
// {
// this->protocol[0].value = protocol_Lobby_Join;
// this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
// this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
// }
// Protocol_LobbyJoin(Oyster::Network::CustomNetProtocol& p)
// {
// this->protocol[0].value = protocol_Lobby_Join;
// this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
// this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
// value = p[1].value.netShort;
// }
// Oyster::Network::CustomNetProtocol* GetProtocol() override
// {
// protocol[1].value = value;
// return &protocol;
// }
//
// private:
// Oyster::Network::CustomNetProtocol protocol;
//};
struct Protocol_LobbyRefresh :public Oyster::Network::CustomProtocolObject
{
Protocol_LobbyRefresh()
{
this->protocol[protocol_INDEX_ID].value = protocol_Lobby_Login;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Lobby_Login;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
}
Protocol_LobbyRefresh(Oyster::Network::CustomNetProtocol& o)
{
}
Oyster::Network::CustomNetProtocol* GetProtocol() override
{ return &protocol; }
@ -127,62 +140,130 @@ namespace GameLogic
/**
* A protocol that contains all data to send to client when update game lobby
*/
struct Protocol_LobbyGameData :public Oyster::Network::CustomProtocolObject
struct Protocol_LobbyClientData :public Oyster::Network::CustomProtocolObject
{
// Player list
struct PlayerData
{
std::string name;
std::string ip;
int id;
int team;
};
Utility::DynamicMemory::DynamicArray<PlayerData> list;
Protocol_LobbyGameData()
Protocol_LobbyClientData()
{
this->protocol[protocol_INDEX_ID].value = protocol_Lobby_GameData;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Lobby_ClientData;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_UnsignedInt; //DataType
list.Reserve(10);
}
Oyster::Network::CustomNetProtocol* GetProtocol() override
Protocol_LobbyClientData(Oyster::Network::CustomNetProtocol& p)
{
int a = 1;
unsigned int size = this->protocol[1].value.netUInt;
list.Reserve(size);
int a = 2;
for (unsigned int i = 0; i < list.Size(); i++)
{
this->protocol[a].type = Oyster::Network::NetAttributeType_Int;
this->protocol[a].type = Oyster::Network::NetAttributeType_CharArray;
this->protocol[a].value = list[i].id;
this->protocol.Set(a, list[i].name);
PlayerData d;
d.id = this->protocol[a++].value.netInt;
d.team = this->protocol[a++].value.netInt;
d.name = this->protocol.Get(a++).value.netCharPtr;
d.ip = this->protocol.Get(a++).value.netCharPtr;
list.Push(d);
}
}
Oyster::Network::CustomNetProtocol* GetProtocol() override
{
this->protocol[1].value = list.Size();
int a = 2;
for (unsigned int i = 0; i < list.Size(); i++)
{
this->protocol[a].type = Oyster::Network::NetAttributeType_Int; // client-id
this->protocol[a++].value = list[i].id;
this->protocol[a].type = Oyster::Network::NetAttributeType_Int; // team-id
this->protocol[a++].value = list[i].team;
this->protocol[a].type = Oyster::Network::NetAttributeType_CharArray; // clientName
this->protocol.Set(a++, list[i].name);
this->protocol[a].type = Oyster::Network::NetAttributeType_CharArray; // clientIP
this->protocol.Set(a++, list[i].ip);
}
return &protocol;
}
private:
Oyster::Network::CustomNetProtocol protocol;
};
struct Protocol_LobbyGameData :public Oyster::Network::CustomProtocolObject
{
std::string mapName;
int majorVersion;
int minorVersion;
Protocol_LobbyGameData()
{
this->protocol[0].value = protocol_Lobby_GameData;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
this->protocol[2].type = Oyster::Network::NetAttributeType_Int;
this->protocol[3].type = Oyster::Network::NetAttributeType_CharArray;
}
Protocol_LobbyGameData(Oyster::Network::CustomNetProtocol& p)
{
majorVersion = (int)p.Get(1).value.netInt;
minorVersion = (int)p.Get(2).value.netInt;
mapName = p.Get(3).value.netCharPtr;
}
Oyster::Network::CustomNetProtocol* GetProtocol() override
{
this->protocol[1].value = majorVersion;
this->protocol[2].value = minorVersion;
this->protocol[3].value.netCharPtr = const_cast<char*>(mapName.c_str());
return &protocol;
}
private:
Oyster::Network::CustomNetProtocol protocol;
};
/**
* A protocol that contains all data to send to client when update main lobby
*/
struct Protocol_LobbyMainData :public Oyster::Network::CustomProtocolObject
{
// Game instance list
Protocol_LobbyMainData()
{
this->protocol[protocol_INDEX_ID].value = protocol_Lobby_MainData;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
}
Oyster::Network::CustomNetProtocol* GetProtocol() override
{
return &protocol;
}
private:
Oyster::Network::CustomNetProtocol protocol;
};
//struct Protocol_LobbyMainData :public Oyster::Network::CustomProtocolObject
//{
// // Game instance list
//
// Protocol_LobbyMainData()
// {
// this->protocol[0].value = protocol_Lobby_MainData;
// this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
//
// this->protocol[1].type = Oyster::Network::NetAttributeType_Short;
// }
// Protocol_LobbyMainData(Oyster::Network::CustomNetProtocol& p)
// {
//
// }
// Oyster::Network::CustomNetProtocol* GetProtocol() override
// {
// return &protocol;
// }
//
// private:
// Oyster::Network::CustomNetProtocol protocol;
//};
}
#endif // !GAMELOGIC_PLAYER_PROTOCOLS_H

72
Code/Game/GameProtocols/ObjectProtocols.h
View File

@ -13,19 +13,23 @@ namespace GameLogic
Protocol_ObjectPickup()
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_ObjectPickup;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_ObjectPickup;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
this->protocol[2].type = Oyster::Network::NetAttributeType_Short;
object_ID = -1;
pickup_ID = -1;
}
Protocol_ObjectPickup(Oyster::Network::CustomNetProtocol& p)
{
}
Protocol_ObjectPickup(int objectID, short pickupID)
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_ObjectPosition;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_ObjectPosition;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
this->protocol[2].type = Oyster::Network::NetAttributeType_Short;
@ -52,19 +56,23 @@ namespace GameLogic
Protocol_ObjectDamage()
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_ObjectDamage;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_ObjectDamage;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
this->protocol[2].type = Oyster::Network::NetAttributeType_Float;
object_ID = -1;
health = 0.0f;
}
Protocol_ObjectDamage(Oyster::Network::CustomNetProtocol& p)
{
}
Protocol_ObjectDamage(int id, float hp)
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_ObjectDamage;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_ObjectDamage;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[2].type = Oyster::Network::NetAttributeType_Float;
@ -89,8 +97,8 @@ namespace GameLogic
Protocol_ObjectPosition()
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_ObjectPosition;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_ObjectPosition;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
@ -100,11 +108,15 @@ namespace GameLogic
}
object_ID = -1;
memset(&worldMatrix[0], 0, sizeof(float) * 16);
}
Protocol_ObjectPosition(Oyster::Network::CustomNetProtocol& p)
{
}
Protocol_ObjectPosition(float m[16], int id)
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_ObjectPosition;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_ObjectPosition;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
@ -137,8 +149,8 @@ namespace GameLogic
Protocol_ObjectEnable()
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_ObjectEnabled;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_ObjectEnabled;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
@ -148,11 +160,15 @@ namespace GameLogic
}
object_ID = -1;
memset(&worldMatrix[0], 0, sizeof(float) * 16);
}
Protocol_ObjectEnable(Oyster::Network::CustomNetProtocol& p)
{
}
Protocol_ObjectEnable(float m[16], int id)
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_ObjectEnabled;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_ObjectEnabled;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
@ -183,16 +199,20 @@ namespace GameLogic
Protocol_ObjectDisable()
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_ObjectDisabled;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_ObjectDisabled;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
this->protocol[2].type = Oyster::Network::NetAttributeType_Float;
}
Protocol_ObjectDisable(Oyster::Network::CustomNetProtocol& p)
{
}
Protocol_ObjectDisable(int id, float time)
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_ObjectDisabled;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_ObjectDisabled;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
this->protocol[2].type = Oyster::Network::NetAttributeType_Float;
@ -219,8 +239,8 @@ namespace GameLogic
Protocol_ObjectCreate()
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_ObjectCreate;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_ObjectCreate;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
this->protocol[2].type = Oyster::Network::NetAttributeType_CharArray;
@ -229,11 +249,15 @@ namespace GameLogic
{
this->protocol[i].type = Oyster::Network::NetAttributeType_Float;
}
}
Protocol_ObjectCreate(Oyster::Network::CustomNetProtocol& p)
{
}
Protocol_ObjectCreate(float m[16], int id, char *path)
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_ObjectCreate;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Int;
this->protocol[0].value = protocol_Gameplay_ObjectCreate;
this->protocol[0].type = Oyster::Network::NetAttributeType_Int;
this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
this->protocol[2].type = Oyster::Network::NetAttributeType_CharArray;

40
Code/Game/GameProtocols/PlayerProtocols.h
View File

@ -25,13 +25,17 @@ namespace GameLogic
Protocol_PlayerMovement()
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_PlayerMovement;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_PlayerMovement;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Bool;
this->protocol[2].type = Oyster::Network::NetAttributeType_Bool;
this->protocol[3].type = Oyster::Network::NetAttributeType_Bool;
this->protocol[4].type = Oyster::Network::NetAttributeType_Bool;
}
Protocol_PlayerMovement(Oyster::Network::CustomNetProtocol& p)
{
}
const Protocol_PlayerMovement& operator=(Oyster::Network::CustomNetProtocol& val)
{
@ -65,13 +69,17 @@ namespace GameLogic
Protocol_PlayerLook()
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_PlayerLookDir;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_PlayerLookDir;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Float;
this->protocol[2].type = Oyster::Network::NetAttributeType_Float;
this->protocol[3].type = Oyster::Network::NetAttributeType_Float;
}
Protocol_PlayerLook(Oyster::Network::CustomNetProtocol& p)
{
}
const Protocol_PlayerLook& operator=(Oyster::Network::CustomNetProtocol& val)
{
@ -101,13 +109,17 @@ namespace GameLogic
Protocol_PlayerChangeWeapon()
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_PlayerChangeWeapon;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_PlayerChangeWeapon;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Float;
this->protocol[2].type = Oyster::Network::NetAttributeType_Float;
this->protocol[3].type = Oyster::Network::NetAttributeType_Float;
}
Protocol_PlayerChangeWeapon(Oyster::Network::CustomNetProtocol& p)
{
}
const Protocol_PlayerChangeWeapon& operator=(Oyster::Network::CustomNetProtocol& val)
{
@ -128,10 +140,14 @@ namespace GameLogic
Protocol_PlayerShot()
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_PlayerShot;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_PlayerShot;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Bool;
}
Protocol_PlayerShot(Oyster::Network::CustomNetProtocol& p)
{
}
const Protocol_PlayerShot& operator=(Oyster::Network::CustomNetProtocol& val)
{
@ -154,10 +170,14 @@ namespace GameLogic
Protocol_PlayerJump()
{
this->protocol[protocol_INDEX_ID].value = protocol_Gameplay_PlayerJump;
this->protocol[protocol_INDEX_ID].type = Oyster::Network::NetAttributeType_Short;
this->protocol[0].value = protocol_Gameplay_PlayerJump;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Bool;
}
Protocol_PlayerJump(Oyster::Network::CustomNetProtocol& p)
{
}
const Protocol_PlayerJump& operator=(Oyster::Network::CustomNetProtocol& val)
{

7
Code/Game/GameProtocols/ProtocolIdentificationID.h
View File

@ -8,11 +8,6 @@
/* THERE CAN ABSOLUTLEY NOT BE TWO DEFINITIONS WITH THE SAME ID!! */
/** Index where the identifier is located(aka protocol identification index) **/
/* Use this as id accesser since it may change in the future. */
#define protocol_INDEX_ID 0
/***********************************/
/********* RESERVERD PROTOCOLS ***************************************************************************************************/
/********** [ 0 - 99 ] *********/
@ -37,7 +32,7 @@
#define protocol_Lobby_Join 202
#define protocol_Lobby_Login 203
#define protocol_Lobby_Refresh 204
#define protocol_Lobby_MainData 205
#define protocol_Lobby_ClientData 205
#define protocol_Lobby_GameData 206
#define protocol_LobbyMAX 299

1
Code/Game/GameProtocols/Protocols.h
View File

@ -5,6 +5,5 @@
#include "PlayerProtocols.h"
#include "LobbyProtocols.h"
#include "GeneralProtocols.h"
#include "GameplayProtocols.h"
#endif // !GAMEPROTOCOLS_GAMEPROTOCOLS_H

36
Code/Game/GameServer/GameClient.h Normal file
View File

@ -0,0 +1,36 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#ifndef DANBIASSERVER_CLIENT_OBJECT_H
#define DANBIASSERVER_CLIENT_OBJECT_H
#include <NetworkClient.h>
#include <PostBox\PostBox.h>
#include <GameAPI.h>
#include <Utilities.h>
namespace DanBias
{
/**
* Container to keep logic player and network client together as a unit.
*/
class GameClient
{
public:
GameClient(Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> client, GameLogic::IPlayerData* player);
virtual~GameClient();
GameLogic::IPlayerData* GetPlayer();
GameLogic::IPlayerData* ReleasePlayer();
Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> GetClient();
Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> ReleaseClient();
int GetID() const;
private:
GameLogic::IPlayerData* player;
Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> client;
int id;
};
}//End namespace DanBias
#endif // !DANBIASSERVER_CLIENT_OBJECT_H

59
Code/Game/GameServer/GameLobby.h Normal file
View File

@ -0,0 +1,59 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#ifndef DANBIASSERVER_MAINLOBBY_H
#define DANBIASSERVER_MAINLOBBY_H
#include <NetworkSession.h>
#include <Protocols.h>
#include <PostBox\IPostBox.h>
#include <WinTimer.h>
#include "GameSession.h"
namespace DanBias
{
struct LobbyLevelData
{
int mapNumber;
int maxClients;
int gameMode;
int gameTime;
std::string gameName;
};
class GameLobby :public Oyster::Network::NetworkSession
{
public:
GameLobby();
virtual~GameLobby();
void Release();
void Update();
void SetGameDesc(const LobbyLevelData& desc);
void GetGameDesc(LobbyLevelData& desc);
bool StartGameSession();
private:
void ParseProtocol(Oyster::Network::CustomNetProtocol& p, Oyster::Network::NetworkClient* c);
void GeneralStatus(GameLogic::Protocol_General_Status& p, Oyster::Network::NetworkClient* c); //id = protocol_General_Status:
void GeneralText(GameLogic::Protocol_General_Text& p, Oyster::Network::NetworkClient* c); //id = protocol_General_Text:
//void LobbyCreateGame(GameLogic::Protocol_LobbyCreateGame& p, Oyster::Network::NetworkClient* c); //id = protocol_Lobby_Create:
void LobbyStartGame(GameLogic::Protocol_LobbyStartGame& p, Oyster::Network::NetworkClient* c); //id = protocol_Lobby_Start:
//void LobbyJoin(GameLogic::Protocol_LobbyJoin& p, Oyster::Network::NetworkClient* c); //id = protocol_Lobby_Join:
void LobbyLogin(GameLogic::Protocol_LobbyLogin& p, Oyster::Network::NetworkClient* c); //id = protocol_Lobby_Login:
void LobbyRefresh(GameLogic::Protocol_LobbyRefresh& p, Oyster::Network::NetworkClient* c); //id = protocol_Lobby_Refresh:
void LobbyGameData(GameLogic::Protocol_LobbyGameData& p, Oyster::Network::NetworkClient* c); //id = protocol_Lobby_GameData:
void LobbyMainData(GameLogic::Protocol_LobbyClientData& p, Oyster::Network::NetworkClient* c); //id = protocol_Lobby_MainData:
private:
void ClientEventCallback(Oyster::Network::NetEvent<Oyster::Network::NetworkClient*, Oyster::Network::NetworkClient::ClientEventArgs> e) override;
void ClientConnectedEvent(Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> client) override;
private:
Utility::WinTimer timer;
float refreshFrequency;
GameSession gameSession;
LobbyLevelData description;
};
}//End namespace DanBias
#endif // !DANBIASGAME_GAMELOBBY_H

68
Code/Game/DanBiasServer/DanBiasServer.vcxproj → Code/Game/GameServer/GameServer.vcxproj
View File

@ -19,9 +19,10 @@
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{52380DAA-0F4A-4D97-8E57-98DF39319CAF}</ProjectGuid>
<ProjectGuid>{143BD516-20A1-4890-A3E4-F8BFD02220E7}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>DanBiasServer</RootNamespace>
<RootNamespace>GameServer</RootNamespace>
<ProjectName>GameServer</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
@ -73,32 +74,32 @@
<OutDir>$(SolutionDir)..\Bin\DLL\</OutDir>
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Game\GameLogic\;$(SolutionDir)Network\NetworkAPI\;$(SolutionDir)OysterMath\;$(SolutionDir)GamePhysics\;$(SolutionDir)Misc\;$(SolutionDir)WindowManager\;C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)OysterPhysics3D\;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir);$(SolutionDir)..\External\Lib\WindowManager\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Game\GameLogic\;$(SolutionDir)Network\NetworkAPI\;$(SolutionDir)OysterMath\;$(SolutionDir)GamePhysics\;$(SolutionDir)Misc\;$(SolutionDir)WindowManager\;$(SolutionDir)OysterPhysics3D\;$(SolutionDir)Game\ServerDependencies;C:\Program Files %28x86%29\Visual Leak Detector\include;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir);$(SolutionDir)..\External\Lib\WindowManager\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(SolutionDir)..\External\Lib\ServerDependencies\;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
<OutDir>$(SolutionDir)..\Bin\DLL\</OutDir>
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Game\GameLogic\;$(SolutionDir)Network\NetworkAPI\;$(SolutionDir)OysterMath\;$(SolutionDir)GamePhysics\;$(SolutionDir)Misc\;$(SolutionDir)WindowManager\;C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)OysterPhysics3D\;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir);$(SolutionDir)..\External\Lib\WindowManager\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Game\GameLogic\;$(SolutionDir)Network\NetworkAPI\;$(SolutionDir)OysterMath\;$(SolutionDir)GamePhysics\;$(SolutionDir)Misc\;$(SolutionDir)WindowManager\;$(SolutionDir)OysterPhysics3D\;$(SolutionDir)Game\ServerDependencies;C:\Program Files %28x86%29\Visual Leak Detector\include;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir);$(SolutionDir)..\External\Lib\WindowManager\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(SolutionDir)..\External\Lib\ServerDependencies\;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
<OutDir>$(SolutionDir)..\Bin\DLL\</OutDir>
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Game\GameLogic\;$(SolutionDir)Network\NetworkAPI\;$(SolutionDir)OysterMath\;$(SolutionDir)GamePhysics\;$(SolutionDir)Misc\;$(SolutionDir)WindowManager\;C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)OysterPhysics3D\;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir);$(SolutionDir)..\External\Lib\WindowManager\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Game\GameLogic\;$(SolutionDir)Network\NetworkAPI\;$(SolutionDir)OysterMath\;$(SolutionDir)GamePhysics\;$(SolutionDir)Misc\;$(SolutionDir)WindowManager\;$(SolutionDir)OysterPhysics3D\;$(SolutionDir)Game\ServerDependencies;C:\Program Files %28x86%29\Visual Leak Detector\include;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir);$(SolutionDir)..\External\Lib\WindowManager\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(SolutionDir)..\External\Lib\ServerDependencies\;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
<OutDir>$(SolutionDir)..\Bin\DLL\</OutDir>
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Game\GameLogic\;$(SolutionDir)Network\NetworkAPI\;$(SolutionDir)OysterMath\;$(SolutionDir)GamePhysics\;$(SolutionDir)Misc\;$(SolutionDir)WindowManager\;C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)OysterPhysics3D\;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir);$(SolutionDir)..\External\Lib\WindowManager\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
<IncludePath>$(SolutionDir)..\External\Include\;$(SolutionDir)Game\GameProtocols\;$(SolutionDir)Game\GameLogic\;$(SolutionDir)Network\NetworkAPI\;$(SolutionDir)OysterMath\;$(SolutionDir)GamePhysics\;$(SolutionDir)Misc\;$(SolutionDir)WindowManager\;$(SolutionDir)OysterPhysics3D\;$(SolutionDir)Game\ServerDependencies;C:\Program Files %28x86%29\Visual Leak Detector\include;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir);$(SolutionDir)..\External\Lib\WindowManager\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(SolutionDir)..\External\Lib\ServerDependencies\;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
@ -173,39 +174,24 @@
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="AdminInterface\AdminInterface.cpp" />
<ClCompile Include="GameSession\GameSessionManager.cpp" />
<ClCompile Include="DanBiasServerAPI.cpp" />
<ClCompile Include="DLLMain.cpp" />
<ClCompile Include="GameServer.cpp" />
<ClCompile Include="GameSession\GameClient.cpp" />
<ClCompile Include="GameSession\GameSession_Events.cpp" />
<ClCompile Include="GameSession\GameSession_General.cpp" />
<ClCompile Include="GameSession\GameSession_Network.cpp" />
<ClCompile Include="LobbySessions\INetworkSession.cpp" />
<ClCompile Include="LobbySessions\LobbyClient.cpp" />
<ClCompile Include="LobbySessions\GameLobby.cpp" />
<ClCompile Include="GameSession\GameSession_Logic.cpp" />
<ClCompile Include="LobbySessions\LobbyGeneralProtocolParser.cpp" />
<ClCompile Include="LobbySessions\LobbyProtocolParser.cpp" />
<ClCompile Include="LobbySessions\MainLobby.cpp" />
<ClCompile Include="LobbySessions\NetworkSession.cpp" />
<ClCompile Include="Implementation\DLLMain.cpp" />
<ClCompile Include="Implementation\GameClient.cpp" />
<ClCompile Include="Implementation\GameLobby.cpp" />
<ClCompile Include="Implementation\GameServer.cpp" />
<ClCompile Include="Implementation\GameSession_General.cpp" />
<ClCompile Include="Implementation\GameSession_Gameplay.cpp" />
<ClCompile Include="Implementation\GameLobby_ProtocolParser.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="AdminInterface\AdminInterface.h" />
<ClInclude Include="Event\EventManager.h" />
<ClInclude Include="GameServer.h" />
<ClInclude Include="GameSession\GameSessionManager.h" />
<ClInclude Include="DanBiasServerAPI.h" />
<ClInclude Include="Helpers\MapManager.h" />
<ClInclude Include="Helpers\ServerDataReader.h" />
<ClInclude Include="GameSession\GameClient.h" />
<ClInclude Include="GameSession\GameSession.h" />
<ClInclude Include="LobbySessions\INetworkSession.h" />
<ClInclude Include="LobbySessions\LobbyClient.h" />
<ClInclude Include="LobbySessions\GameLobby.h" />
<ClInclude Include="LobbySessions\MainLobby.h" />
<ClInclude Include="LobbySessions\NetworkSession.h" />
<ClInclude Include="GameClient.h" />
<ClInclude Include="GameLobby.h" />
<ClInclude Include="GameServerAPI.h" />
<ClInclude Include="GameSession.h" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\Misc\Misc.vcxproj">

0
Code/Game/DanBiasServer/DanBiasServer.vcxproj.user → Code/Game/GameServer/GameServer.vcxproj.user
View File

69
Code/Game/GameServer/GameServerAPI.h Normal file
View File

@ -0,0 +1,69 @@
/////////////////////////////////////////
// Created by [Dennis Andersen] [2013] //
/////////////////////////////////////////
#ifndef DANBIAS_SERVER_DANBIAS_SERVER_H
#define DANBIAS_SERVER_DANBIAS_SERVER_H
#include <vld.h>
#define DANBIAS_SERVER
#ifdef DANBIAS_SERVER_DLL_EXPORT
#define DANBIAS_SERVER_DLL __declspec(dllexport)
#else
#define DANBIAS_SERVER_DLL __declspec(dllimport)
#endif
namespace DanBias
{
enum DanBiasServerReturn
{
DanBiasServerReturn_Error,
DanBiasServerReturn_Sucess,
DanBiasServerReturn_GameNotCreated,
};
extern "C"
{
class DANBIAS_SERVER_DLL GameServerAPI
{
public:
struct ServerInitDesc
{
char* serverName;
int listenPort;
ServerInitDesc()
: serverName("Game Server")
, listenPort(15151)
{};
};
struct GameServerInfo
{
unsigned int listenPort; // If set to 0, the default port 15151 will be used
const char *serverIp; // This cant be mofidfied..
};
public:
static DanBiasServerReturn ServerInitiate(const ServerInitDesc& desc);
static void ServerStart();
static void ServerStop();
static void ServerUpdate();
static GameServerInfo ServerGetInfo();
static void GameSetMapId(const int& val);
static void GameSetMaxClients(const int& val);
static void GameSetGameMode(const int& val);
static void GameSetGameTime(const int& val);
static int GameGetMapId();
static int GameGetMaxClients();
static int GameGetGameMode();
static int GameGetGameTime();
static const char* GameGetGameName();
static bool GameStart();
};//End class DanBiasServer
}//End Extern "C"
} //End namspace DanBias
#endif // !DANBIAS_SERVER_DANBIAS_SERVER_H

108
Code/Game/GameServer/GameSession.h Normal file
View File

@ -0,0 +1,108 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#ifndef DANBIASSERVER_GAME_SESSION_H
#define DANBIASSERVER_GAME_SESSION_H
//warning C4150: deletion of pointer to incomplete type, no destructor called, because of forward decleration and the use of smartpointer.
#pragma warning(disable: 4150)
#include "GameClient.h"
#include <WinTimer.h>
#include <PostBox\IPostBox.h>
#include <Thread\OysterThread.h>
#include <GameAPI.h>
#include <Queue.h>
#include <NetworkSession.h>
#include <DynamicArray.h>
#include <Protocols.h>
namespace DanBias
{
class GameSession : public Oyster::Network::NetworkSession
, public Oyster::Thread::IThreadObject
{
public:
/**
* A container to use when initiating a new session
*/
struct GameDescription
{
int mapNumber;
int gameMode;
int gameTime;
Oyster::Network::NetworkSession* owner;
Utility::DynamicMemory::DynamicArray<Oyster::Network::NetClient> clients;
};
public:
GameSession();
virtual~GameSession();
/** Initiates and creates a game session. */
bool Create(GameDescription& desc);
/** Runs the game session (ie starts the game loop). */
void Run();
/** Join an existing/running game session
* @param client The client to attach to the session
*/
bool Attach(Oyster::Network::NetClient client) override;
inline bool IsCreated() const { return this->isCreated; }
inline bool IsRunning() const { return this->isRunning; }
//Private member functions
private:
// TODO: find out what this method does..
void ClientEventCallback(Oyster::Network::NetEvent<Oyster::Network::NetworkClient*, Oyster::Network::NetworkClient::ClientEventArgs> e) override;
//Sends a client to the owner, if obj is NULL then all clients is sent
void SendToOwner(DanBias::GameClient* obj);
//Frame function, derived from IThreadObject
bool DoWork ( ) override;
private:
void ParseProtocol (Oyster::Network::CustomNetProtocol& p, DanBias::GameClient* c);
void Gameplay_PlayerMovement ( GameLogic::Protocol_PlayerMovement& p, DanBias::GameClient* c );
void Gameplay_PlayerLookDir ( GameLogic::Protocol_PlayerLook& p, DanBias::GameClient* c );
void Gameplay_PlayerChangeWeapon ( GameLogic::Protocol_PlayerChangeWeapon& p, DanBias::GameClient* c );
void Gameplay_PlayerShot ( GameLogic::Protocol_PlayerShot& p, DanBias::GameClient* c );
void Gameplay_PlayerJump ( GameLogic::Protocol_PlayerJump& p, DanBias::GameClient* c );
void Gameplay_ObjectPickup ( GameLogic::Protocol_ObjectPickup& p, DanBias::GameClient* c );
void Gameplay_ObjectDamage ( GameLogic::Protocol_ObjectDamage& p, DanBias::GameClient* c );
void Gameplay_ObjectPosition ( GameLogic::Protocol_ObjectPosition& p, DanBias::GameClient* c );
void Gameplay_ObjectEnabled ( GameLogic::Protocol_ObjectEnable& p, DanBias::GameClient* c );
void Gameplay_ObjectDisabled ( GameLogic::Protocol_ObjectDisable& p, DanBias::GameClient* c );
void Gameplay_ObjectCreate ( GameLogic::Protocol_ObjectCreate& p, DanBias::GameClient* c );
void General_Status ( GameLogic::Protocol_General_Status& p, DanBias::GameClient* c );
void General_Text ( GameLogic::Protocol_General_Text& p, DanBias::GameClient* c );
//Callback method recieving from gamelogic
static void ObjectMove(GameLogic::IObjectData* movedObject);
//Private member variables
private:
Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<GameClient>> clients;
Oyster::Thread::OysterThread worker;
GameLogic::GameAPI& gameInstance;
GameLogic::ILevelData *levelData;
NetworkSession* owner;
bool isCreated;
bool isRunning;
Utility::WinTimer timer;
GameDescription description;
//TODO: Remove this uggly hax
static GameSession* gameSession;
};//End GameSession
}//End namespace DanBias
#endif // !DANBIASSERVER_GAME_SESSION_H

0
Code/Game/DanBiasServer/DLLMain.cpp → Code/Game/GameServer/Implementation/DLLMain.cpp
View File

52
Code/Game/GameServer/Implementation/GameClient.cpp Normal file
View File

@ -0,0 +1,52 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#include "..\GameClient.h"
#include <NetworkSession.h>
#include <Protocols.h>
using namespace Utility::DynamicMemory;
using namespace Oyster::Network;
using namespace DanBias;
using namespace GameLogic;
static int gameClientIDCount = 1;
GameClient::GameClient(SmartPointer<NetworkClient> client, GameLogic::IPlayerData* player)
{
this->client = client;
this->id = gameClientIDCount++;
this->player = player;
}
GameClient::~GameClient()
{
this->client->Disconnect();
this->player = 0;
this->id = -1;
}
GameLogic::IPlayerData* GameClient::GetPlayer()
{
return this->player;
}
GameLogic::IPlayerData* GameClient::ReleasePlayer()
{
GameLogic::IPlayerData *temp = this->player;
this->player = 0;
return temp;
}
SmartPointer<Oyster::Network::NetworkClient> GameClient::GetClient()
{
return this->client;
}
SmartPointer<Oyster::Network::NetworkClient> GameClient::ReleaseClient()
{
SmartPointer<Oyster::Network::NetworkClient> temp = this->client;
this->client = 0;
return temp;
}
int GameClient::GetID() const
{
return this->id;
}

111
Code/Game/GameServer/Implementation/GameLobby.cpp Normal file
View File

@ -0,0 +1,111 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#include "..\GameLobby.h"
#include <PlayerProtocols.h>
#include <PostBox\PostBox.h>
#include <Protocols.h>
using namespace Utility::DynamicMemory;
using namespace Oyster::Network;
using namespace Oyster;
using namespace GameLogic;
namespace DanBias
{
GameLobby::GameLobby()
{ }
GameLobby::~GameLobby()
{ }
void GameLobby::Release()
{
NetworkSession::CloseSession(true);
}
void GameLobby::Update()
{
if(GetAsyncKeyState(VK_DOWN)) //TODO: Dont forget to remove this...
this->Send(*GameLogic::Protocol_General_Status().GetProtocol());
this->ProcessClients();
}
void GameLobby::SetGameDesc(const LobbyLevelData& desc)
{
this->description.gameMode = desc.gameMode;
this->description.gameTime = desc.gameTime;
this->description.mapNumber = desc.mapNumber;
this->description.maxClients = desc.maxClients;
}
void GameLobby::GetGameDesc(LobbyLevelData& desc)
{
desc.gameMode = this->description.gameMode;
desc.gameTime = this->description.gameTime;
desc.mapNumber = this->description.mapNumber;
desc.maxClients = this->description.maxClients;
}
bool GameLobby::StartGameSession()
{
GameSession::GameDescription desc;
desc.gameMode = this->description.gameMode;
desc.gameTime = this->description.gameTime;
desc.mapNumber = this->description.mapNumber;
desc.owner = this;
desc.clients = this->clients;
if(this->gameSession.Create(desc))
{
this->gameSession.Run();
return true;
}
return false;
}
void GameLobby::ClientEventCallback(NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e)
{
switch (e.args.type)
{
case NetworkClient::ClientEventArgs::EventType_Disconnect:
break;
case NetworkClient::ClientEventArgs::EventType_ProtocolFailedToRecieve:
break;
case NetworkClient::ClientEventArgs::EventType_ProtocolFailedToSend:
printf("\t(%i : %s) - EventType_ProtocolFailedToSend\n", e.sender->GetID(), e.sender->GetIpAddress().c_str());
e.sender->Disconnect();
break;
case NetworkClient::ClientEventArgs::EventType_ProtocolRecieved:
printf("\t(%i : %s) - EventType_ProtocolRecieved\n", e.sender->GetID(), e.sender->GetIpAddress().c_str());
this->ParseProtocol(e.args.data.protocol, e.sender);
break;
}
}
void GameLobby::ClientConnectedEvent(Utility::DynamicMemory::SmartPointer<Oyster::Network::NetworkClient> client)
{
printf("New client(%i) connected - %s \n", client->GetID(), client->GetIpAddress().c_str());
Attach(client);
Protocol_LobbyClientData p1;
Protocol_LobbyGameData p2;
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
if(this->clients[i])
{
Protocol_LobbyClientData::PlayerData t;
t.id = this->clients[i]->GetID();
t.ip = this->clients[i]->GetIpAddress();
t.team = 0;
t.name = "DennisÄrKung";
p1.list.Push(t);
}
}
p2.majorVersion = 1;
p2.minorVersion = 0;
p2.mapName = "BetsMap";
client->Send(p1.GetProtocol());
client->Send(p2.GetProtocol());
}
}//End namespace DanBias

95
Code/Game/GameServer/Implementation/GameLobby_ProtocolParser.cpp Normal file
View File

@ -0,0 +1,95 @@
#include "..\GameLobby.h"
using namespace DanBias;
using namespace GameLogic;
using namespace Oyster::Network;
void GameLobby::ParseProtocol(Oyster::Network::CustomNetProtocol& p, NetworkClient* c)
{
switch (p[0].value.netShort)
{
case protocol_General_Status: this->GeneralStatus (Protocol_General_Status (p), c);
break;
case protocol_General_Text: this->GeneralText (Protocol_General_Text (p), c);
break;
//case protocol_Lobby_Create: this->LobbyCreateGame (Protocol_LobbyCreateGame (p), c);
//break;
case protocol_Lobby_Start: this->LobbyStartGame (Protocol_LobbyStartGame (p), c);
break;
//case protocol_Lobby_Join: this->LobbyJoin (Protocol_LobbyJoin (p), c);
//break;
case protocol_Lobby_Login: this->LobbyLogin (Protocol_LobbyLogin (p), c);
break;
case protocol_Lobby_Refresh: this->LobbyRefresh (Protocol_LobbyRefresh (p), c);
break;
case protocol_Lobby_GameData: this->LobbyGameData (Protocol_LobbyGameData (p), c);
break;
case protocol_Lobby_ClientData: this->LobbyMainData (Protocol_LobbyClientData (p), c);
break;
//case protocol_Lobby_GameData: this->LobbyGameData (Protocol_LobbyGameData (p), c);
//break;
}
}
void GameLobby::GeneralStatus(GameLogic::Protocol_General_Status& p, Oyster::Network::NetworkClient* c)
{
switch (p.status)
{
case Protocol_General_Status::States_ready:
{
}
case Protocol_General_Status::States_idle:
{
}
case Protocol_General_Status::States_leave:
case Protocol_General_Status::States_disconected:
{
Detach(c)->Disconnect();
}
}
}
void GameLobby::GeneralText(GameLogic::Protocol_General_Text& p, Oyster::Network::NetworkClient* c)
{
printf(p.text.c_str());
}
//void GameLobby::LobbyCreateGame(GameLogic::Protocol_LobbyCreateGame& p, Oyster::Network::NetworkClient* c)
//{
//
//}
void GameLobby::LobbyStartGame(GameLogic::Protocol_LobbyStartGame& p, Oyster::Network::NetworkClient* c)
{
//TODO: Prio 1
}
//void GameLobby::LobbyJoin(GameLogic::Protocol_LobbyJoin& p, Oyster::Network::NetworkClient* c)
//{
// //for (unsigned int i = 0; i < this->gameLobby.Size(); i++)
// //{
// // if (this->gameLobby[i]->GetID() == p.value)
// // {
// // this->gameLobby[i]->Attach(Detach(c));
// // return;
// // }
// //}
//}
void GameLobby::LobbyLogin(GameLogic::Protocol_LobbyLogin& p, Oyster::Network::NetworkClient* c)
{
}
void GameLobby::LobbyRefresh(GameLogic::Protocol_LobbyRefresh& p, Oyster::Network::NetworkClient* c)
{
//Dont need to handle this on the server...
}
void GameLobby::LobbyGameData(GameLogic::Protocol_LobbyGameData& p, Oyster::Network::NetworkClient* c)
{
}
void GameLobby::LobbyMainData(GameLogic::Protocol_LobbyClientData& p, Oyster::Network::NetworkClient* c)
{
}

155
Code/Game/GameServer/Implementation/GameServer.cpp Normal file
View File

@ -0,0 +1,155 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#define NOMINMAX
#include <Windows.h>
#include <iostream>
#include <vld.h>
#include "..\GameServerAPI.h"
#include "..\GameLobby.h"
#include "..\GameSession.h"
#include <NetworkServer.h>
#include <NetworkClient.h>
#include <WindowShell.h>
#include <Utilities.h>
#include <WinTimer.h>
#include <thread>
using namespace DanBias;
using namespace Oyster::Network;
using namespace Oyster::Thread;
using namespace Utility;
namespace
{
GameLobby lobby;
NetworkServer server;
WinTimer timer;
}
DanBiasServerReturn GameServerAPI::ServerInitiate(const ServerInitDesc& desc)
{
if(server.Init(desc.listenPort, &lobby) == NetworkServer::ServerReturnCode_Error)
{
return DanBiasServerReturn_Error;
}
GameSession::GameDescription d;
std::printf("Server created!\t-\t%s: [%i]\n\n", server.GetLanAddress().c_str(), desc.listenPort);
return DanBiasServerReturn_Sucess;
}
void GameServerAPI::ServerStart()
{
timer.reset();
server.Start();
}
void GameServerAPI::ServerStop()
{
lobby.Release();
server.Shutdown();
double total = timer.getElapsedSeconds();
int time = (int)total;
int hour, min, sec;
hour=time / 3600;
time=time % 3600;
min=time / 60;
time=time % 60;
sec = time;
printf( "Server has been running for: %i:%i:%i - [hh:mm:ss] \n\n", hour, min, sec );
printf( "Terminating in : ");
for (int i = 0; i < 3; i++)
{
printf( "%i ", 3-i );
Sleep(1000);
}
printf( "\nServer terminated!" );
}
void GameServerAPI::ServerUpdate()
{
server.Update();
lobby.Update();
}
GameServerAPI::GameServerInfo GameServerAPI::ServerGetInfo()
{
GameServerAPI::GameServerInfo i;
i.serverIp = server.GetLanAddress().c_str();
i.listenPort = server.GetPort();
return i;
}
void GameServerAPI::GameSetMapId(const int& val)
{
LobbyLevelData d;
lobby.GetGameDesc(d);
d.mapNumber = val;
lobby.SetGameDesc(d);
}
void GameServerAPI::GameSetMaxClients(const int& val)
{
LobbyLevelData d;
lobby.GetGameDesc(d);
d.maxClients = val;
lobby.SetGameDesc(d);
}
void GameServerAPI::GameSetGameMode(const int& val)
{
LobbyLevelData d;
lobby.GetGameDesc(d);
d.gameMode = val;
lobby.SetGameDesc(d);
}
void GameServerAPI::GameSetGameTime(const int& val)
{
LobbyLevelData d;
lobby.GetGameDesc(d);
d.gameTime = val;
lobby.SetGameDesc(d);
}
int GameServerAPI::GameGetMapId()
{
LobbyLevelData d;
lobby.GetGameDesc(d);
return d.mapNumber;
}
int GameServerAPI::GameGetMaxClients()
{
LobbyLevelData d;
lobby.GetGameDesc(d);
return d.maxClients;
}
int GameServerAPI::GameGetGameMode()
{
LobbyLevelData d;
lobby.GetGameDesc(d);
return d.gameMode;
}
int GameServerAPI::GameGetGameTime()
{
LobbyLevelData d;
lobby.GetGameDesc(d);
return d.gameTime;
}
const char* GameServerAPI::GameGetGameName()
{
LobbyLevelData d;
lobby.GetGameDesc(d);
return d.gameName.c_str();
}
bool GameServerAPI::GameStart()
{
return lobby.StartGameSession();
}

192
Code/Game/GameServer/Implementation/GameSession_Gameplay.cpp Normal file
View File

@ -0,0 +1,192 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#include "..\GameSession.h"
#include "..\GameClient.h"
#include <Protocols.h>
#include <PostBox\PostBox.h>
#include <GameLogicStates.h>
#include <OysterMath.h>
#define NOMINMAX
#include <Windows.h>
#define DELTA_TIME_20 0.05f
#define DELTA_TIME_24 0.04166666666666666666666666666667f
#define DELTA_TIME_30 0.03333333333333333333333333333333f
#define DELTA_TIME_60 0.01666666666666666666666666666667f
#define DELTA_TIME_120 0.00833333333333333333333333333333f
using namespace Utility::DynamicMemory;
using namespace Oyster;
using namespace Oyster::Network;
using namespace Oyster::Thread;
using namespace GameLogic;
namespace DanBias
{
bool GameSession::DoWork( )
{
if(this->isRunning)
{
double dt = this->timer.getElapsedSeconds();
gameInstance.SetFrameTimeLength((float)dt);
if(dt >= DELTA_TIME_20)
{
this->ProcessClients();
this->gameInstance.NewFrame();
this->timer.reset();
}
}
return this->isRunning;
}
void GameSession::ClientEventCallback(NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e)
{
}
void GameSession::ObjectMove(GameLogic::IObjectData* movedObject)
{
//GameLogic::IObjectData* obj = NULL;
//if(dynamic_cast<GameLogic::ILevelData*>(movedObject))
// obj =((GameLogic::ILevelData*)movedObject)->GetObjectAt(0);
//if(obj)
//{
// if(obj->GetType() == OBJECT_TYPE_BOX)
// {
// obj->GetID();
// Oyster::Math::Float4x4 world =obj->GetOrientation();
// Protocol_ObjectPosition p(world, 1);
// GameSession::gameSession->Send(p.GetProtocol());
// }
//}
}
//*****************************************************//
//****************** Protocol methods *****************//
//******************************************************************************************************************//
void GameSession::ParseProtocol(Oyster::Network::CustomNetProtocol& p, DanBias::GameClient* c)
{
switch (p[0].value.netShort)
{
case protocol_Gameplay_PlayerMovement: this->Gameplay_PlayerMovement ( Protocol_PlayerMovement (p), c );
break;
case protocol_Gameplay_PlayerLookDir: this->Gameplay_PlayerLookDir ( Protocol_PlayerLook (p), c );
break;
case protocol_Gameplay_PlayerChangeWeapon: this->Gameplay_PlayerChangeWeapon ( Protocol_PlayerChangeWeapon (p), c );
break;
case protocol_Gameplay_PlayerShot: this->Gameplay_PlayerShot ( Protocol_PlayerShot (p), c );
break;
case protocol_Gameplay_PlayerJump: this->Gameplay_PlayerJump ( Protocol_PlayerJump (p), c );
break;
case protocol_Gameplay_ObjectPickup: this->Gameplay_ObjectPickup ( Protocol_ObjectPickup (p), c );
break;
case protocol_Gameplay_ObjectDamage: this->Gameplay_ObjectDamage ( Protocol_ObjectDamage (p), c );
break;
case protocol_Gameplay_ObjectPosition: this->Gameplay_ObjectPosition ( Protocol_ObjectPosition (p), c );
break;
case protocol_Gameplay_ObjectEnabled: this->Gameplay_ObjectEnabled ( Protocol_ObjectEnable (p), c );
break;
case protocol_Gameplay_ObjectDisabled: this->Gameplay_ObjectDisabled ( Protocol_ObjectDisable (p), c );
break;
case protocol_Gameplay_ObjectCreate: this->Gameplay_ObjectCreate ( Protocol_ObjectCreate (p), c );
break;
case protocol_General_Status: this->General_Status ( Protocol_General_Status (p), c );
break;
case protocol_General_Text: this->General_Text ( Protocol_General_Text (p), c );
break;
}
}
void GameSession::Gameplay_PlayerMovement ( Protocol_PlayerMovement& p, DanBias::GameClient* c )
{
if(p.bForward) c->GetPlayer()->Move(GameLogic::PLAYER_MOVEMENT_FORWARD);
if(p.bBackward) c->GetPlayer()->Move(GameLogic::PLAYER_MOVEMENT_BACKWARD);
if(p.bLeft) c->GetPlayer()->Move(GameLogic::PLAYER_MOVEMENT_LEFT);
if(p.bRight) c->GetPlayer()->Move(GameLogic::PLAYER_MOVEMENT_RIGHT);
}
void GameSession::Gameplay_PlayerLookDir ( Protocol_PlayerLook& p, DanBias::GameClient* c )
{
Oyster::Math3D::Float3 lookDir;
lookDir.x = p.lookDirX;
lookDir.y = p.lookDirY;
lookDir.z = p.lookDirZ;
c->GetPlayer()->Rotate(lookDir);
}
void GameSession::Gameplay_PlayerChangeWeapon ( Protocol_PlayerChangeWeapon& p, DanBias::GameClient* c )
{
}
void GameSession::Gameplay_PlayerShot ( Protocol_PlayerShot& p, DanBias::GameClient* c )
{
c->GetPlayer()->UseWeapon(GameLogic::WEAPON_USE_PRIMARY_PRESS);
}
void GameSession::Gameplay_PlayerJump ( Protocol_PlayerJump& p, DanBias::GameClient* c )
{
if(p.hasJumped) c->GetPlayer()->Move(GameLogic::PLAYER_MOVEMENT_JUMP);
}
void GameSession::Gameplay_ObjectPickup ( Protocol_ObjectPickup& p, DanBias::GameClient* c )
{
}
void GameSession::Gameplay_ObjectDamage ( Protocol_ObjectDamage& p, DanBias::GameClient* c )
{
}
void GameSession::Gameplay_ObjectPosition ( Protocol_ObjectPosition& p, DanBias::GameClient* c )
{
}
void GameSession::Gameplay_ObjectEnabled ( Protocol_ObjectEnable& p, DanBias::GameClient* c )
{
}
void GameSession::Gameplay_ObjectDisabled ( Protocol_ObjectDisable& p, DanBias::GameClient* c )
{
}
void GameSession::Gameplay_ObjectCreate ( Protocol_ObjectCreate& p, DanBias::GameClient* c )
{
}
void GameSession::General_Status ( Protocol_General_Status& p, DanBias::GameClient* c )
{
switch (p.status)
{
case GameLogic::Protocol_General_Status::States_disconected:
printf("Client with ID [%i] dissconnected\n", c->GetClient()->GetID());
this->Detach(c->GetClient()->GetID());
break;
case GameLogic::Protocol_General_Status::States_idle:
break;
case GameLogic::Protocol_General_Status::States_ready:
break;
case GameLogic::Protocol_General_Status::States_leave:
break;
}
}
void GameSession::General_Text ( Protocol_General_Text& p, DanBias::GameClient* c )
{
printf("Message recieved from (%i):\t %s\n", c->GetID(), p.text.c_str());
}
}//End namespace DanBias

118
Code/Game/DanBiasServer/GameSession/GameSession_General.cpp → Code/Game/GameServer/Implementation/GameSession_General.cpp
View File

@ -1,13 +1,13 @@
/////////////////////////////////////////////////////////////////////
// Created by [Dennis Andersen] [2013]
/////////////////////////////////////////////////////////////////////
#include "GameSession.h"
#include "GameClient.h"
#include "..\GameServer.h"
#include "..\GameSession.h"
#include "..\GameClient.h"
#include <Protocols.h>
#include <PostBox\PostBox.h>
#include <GameLogicStates.h>
#define NOMINMAX
#include <Windows.h>
@ -20,34 +20,38 @@ using namespace GameLogic;
namespace DanBias
{
GameSession* GameSession::gameSession = nullptr;
GameSession::GameSession()
:gameInstance(GameAPI::Instance())
{
this->owner = 0;
this->box = 0;
this->isCreated = false;
this->isRunning = false;
this->gameSession = this;
memset(&this->description, 0, sizeof(GameDescription));
}
GameSession::~GameSession()
{
delete this->box;
this->box = 0;
this->worker.Terminate();
this->clients.Clear();
this->gameInstance;
this->owner = 0;
this->isCreated = false;
this->isRunning = false;
}
bool GameSession::Create(GameDescription& desc)
{
this->description = desc;
/* Do some error checking */
if(desc.clients.Size() == 0) return false;
if(!desc.owner) return false;
if(!desc.mapName.size()) return false;
if(this->isCreated) return false;
/* standard initialization of some data */
this->clients.Resize(desc.clients.Size());
this->box = new PostBox<NetworkSession::NetEvent>();
this->owner = desc.owner;
/* Initiate the game instance */
@ -63,18 +67,13 @@ namespace DanBias
return false;
}
/* Create a callback object */
Oyster::Callback::OysterCallback<void, NetworkSession::NetEvent> c;
c.value.callbackPostBox = this->box;
c.callbackType = Oyster::Callback::CallbackType_PostBox;
/* Create the players in the game instance */
GameLogic::IPlayerData* p = 0;
for (unsigned int i = 0; i < desc.clients.Size(); i++)
{
if( (p = this->gameInstance.CreatePlayer()) )
{
this->clients[i] = new GameClient(desc.clients[i], p, c);
this->clients[i] = new GameClient(desc.clients[i], p);
}
else
{
@ -83,12 +82,12 @@ namespace DanBias
}
/* Create the worker thread */
if(this->worker.Create(this, true, true) != OYSTER_THREAD_ERROR_SUCCESS)
if(this->worker.Create(this, false) != OYSTER_THREAD_ERROR_SUCCESS)
return false;
this->worker.SetPriority(Oyster::Thread::OYSTER_THREAD_PRIORITY_3);
/* Set some gameinstance data options */
/* Set some game instance data options */
this->gameInstance.SetSubscription(GameLogic::GameEvent::ObjectEventFunctionType_OnMove, GameSession::ObjectMove);
this->isCreated = true;
@ -97,106 +96,39 @@ namespace DanBias
void GameSession::Run()
{
if(this->isRunning) return;
if(this->clients.Size() > 0)
{
this->worker.Start();
this->worker.SetPriority(OYSTER_THREAD_PRIORITY_1);
this->isRunning = true;
}
}
bool GameSession::Join(Utility::DynamicMemory::SmartPointer<LobbyClient> client)
bool GameSession::Attach(Utility::DynamicMemory::SmartPointer<NetworkClient> client)
{
if(!this->isCreated) return false;
Oyster::Callback::OysterCallback<void, DanBias::NetworkSession::NetEvent> c;
c.value.callbackPostBox = this->box;
c.callbackType = Oyster::Callback::CallbackType_PostBox;
client->SetOwner(this);
SmartPointer<GameClient> obj = new GameClient(client, this->gameInstance.CreatePlayer());
SmartPointer<GameClient> obj = new GameClient(client, this->gameInstance.CreatePlayer(), c);
InsertClient(obj);
return true;
}
void GameSession::CloseSession(bool dissconnectClients)
{
if(dissconnectClients)
{
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
this->clients[i]->GetClient()->Disconnect();
}
}
else
{
this->SendToOwner(0); //Send all clients to the current owner
}
this->Clean();
}
void GameSession::InsertClient(SmartPointer<GameClient> obj)
{
for (unsigned int i = 0; i < clients.Size(); i++)
{
if(!clients[i])
{
clients[i] = obj;
return;
return true;
}
}
clients.Push(obj);
return true;
}
void GameSession::RemoveClient(DanBias::GameClient* obj)
{
for (unsigned int i = 0; i < clients.Size(); i++)
{
if(clients[i] && clients[i]->GetID() == obj->GetID())
{
clients[i] = 0;
return;
}
}
}
void GameSession::SendToOwner(DanBias::GameClient* obj)
{
DanBias::NetworkSession *s = GameServer::MainLobbyInstance();
if(this->owner) s = this->owner;
if(obj)
{
s->Attach(obj->ReleaseClient());
RemoveClient(obj);
}
else
{
for (unsigned int i = 0; i < this->clients.Size(); i++)
{
if(this->clients[i])
{
s->Attach(this->clients[i]->ReleaseClient());
RemoveClient(this->clients[i]);
}
}
}
}
void GameSession::Clean()
{
this->worker.Terminate();
this->clients.Clear();
delete this->box;
this->box = 0;
this->gameInstance;
this->owner = 0;
this->isCreated = false;
this->isRunning = false;
}
}//End namespace DanBias

20
Code/Game/aDanBiasGameLauncher/Launcher.cpp
View File

@ -4,19 +4,26 @@
#include <vld.h>
#include "DanBiasGame.h"
#include <DanBiasServerAPI.h>
#include <GameServerAPI.h>
#include <thread>
void ServerFnc()
{
if( DanBias::DanBiasServerAPI::Initiate() == DanBias::DanBiasServerReturn_Sucess)
DanBias::GameServerAPI::ServerInitDesc desc;
desc.listenPort = 15151;
if(DanBias::GameServerAPI::ServerInitiate(desc) == DanBias::DanBiasServerReturn_Sucess)
{
DanBias::DanBiasServerAPI::Run();
DanBias::DanBiasServerAPI::Release();
DanBias::GameServerAPI::ServerStart();
while (!(GetAsyncKeyState(0x51))) //Q for exit
{
DanBias::GameServerAPI::ServerUpdate();
Sleep(1);
}
DanBias::GameServerAPI::ServerStop();
}
Sleep(100);
}
void ClientFnc()
@ -29,6 +36,7 @@ void ClientFnc()
//gameDesc.IP = "193.11.184.31";
//gameDesc.IP = "194.47.150.56";
gameDesc.IP = "127.0.0.1";
//gameDesc.IP = "194.47.150.184";
if( DanBias::DanBiasGame::Initiate(gameDesc) == DanBias::DanBiasClientReturn_Sucess)
{
@ -49,7 +57,7 @@ int WINAPI WinMain( HINSTANCE hinst, HINSTANCE prevInst, PSTR cmdLine, int cmdSh
return cmdShow;
}
serverThread = std::thread(ServerFnc);
//serverThread = std::thread(ServerFnc);
Sleep(200);

28
Code/Game/aDanBiasGameLauncher/aDanBiasGameLauncher.vcxproj
View File

@ -71,7 +71,7 @@
<OutDir>$(SolutionDir)..\Bin\Executable\</OutDir>
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
<IncludePath>$(SolutionDir)..\External\Include\;C:\Program Files %28x86%29\Visual Leak Detector\include;C:\Users\Dennis\Desktop\Skola\DV1477 - Stort spelutvecklingsprojekt\DanBias\Code\Game\DanBiasServer;$(IncludePath)</IncludePath>
<IncludePath>$(SolutionDir)..\External\Include\;C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)Game\GameServer;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir)..\DLL\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@ -79,7 +79,7 @@
<OutDir>$(SolutionDir)..\Bin\Executable\</OutDir>
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)D</TargetName>
<IncludePath>$(SolutionDir)..\External\Include\;C:\Program Files %28x86%29\Visual Leak Detector\include;C:\Users\Dennis\Desktop\Skola\DV1477 - Stort spelutvecklingsprojekt\DanBias\Code\Game\DanBiasServer;$(IncludePath)</IncludePath>
<IncludePath>$(SolutionDir)..\External\Include\;C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)Game\GameServer;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir)..\DLL\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@ -87,7 +87,7 @@
<OutDir>$(SolutionDir)..\Bin\Executable\</OutDir>
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
<IncludePath>$(SolutionDir)..\External\Include\;C:\Program Files %28x86%29\Visual Leak Detector\include;C:\Users\Dennis\Desktop\Skola\DV1477 - Stort spelutvecklingsprojekt\DanBias\Code\Game\DanBiasServer;$(IncludePath)</IncludePath>
<IncludePath>$(SolutionDir)..\External\Include\;C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)Game\GameServer;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir)..\DLL\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@ -95,7 +95,7 @@
<OutDir>$(SolutionDir)..\Bin\Executable\</OutDir>
<IntDir>$(SolutionDir)..\Obj\$(ProjectName)\$(PlatformShortName)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)_$(PlatformShortName)</TargetName>
<IncludePath>$(SolutionDir)..\External\Include\;C:\Program Files %28x86%29\Visual Leak Detector\include;C:\Users\Dennis\Desktop\Skola\DV1477 - Stort spelutvecklingsprojekt\DanBias\Code\Game\DanBiasServer;$(IncludePath)</IncludePath>
<IncludePath>$(SolutionDir)..\External\Include\;C:\Program Files %28x86%29\Visual Leak Detector\include;$(SolutionDir)Game\GameServer;$(IncludePath)</IncludePath>
<LibraryPath>$(OutDir)..\DLL\;C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
@ -110,8 +110,8 @@
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<DelayLoadDLLs>DanBiasGame_$(PlatformShortName)D.dll;DanBiasServer_$(PlatformShortName)D.dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>DanBiasGame_$(PlatformShortName)D.lib;DanBiasServer_$(PlatformShortName)D.lib;%(AdditionalDependencies)</AdditionalDependencies>
<DelayLoadDLLs>DanBiasGame_$(PlatformShortName)D.dll;GameServer_$(PlatformShortName)D.dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>DanBiasGame_$(PlatformShortName)D.lib;GameServer_$(PlatformShortName)D.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@ -126,8 +126,8 @@
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<DelayLoadDLLs>DanBiasGame_$(PlatformShortName)D.dll;DanBiasServer_$(PlatformShortName)D.dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>DanBiasGame_$(PlatformShortName)D.lib;%(AdditionalDependencies)</AdditionalDependencies>
<DelayLoadDLLs>DanBiasGame_$(PlatformShortName)D.dll;GameServer_$(PlatformShortName)D.dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>DanBiasGame_$(PlatformShortName)D.lib;GameServer_$(PlatformShortName)D.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@ -146,8 +146,8 @@
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<DelayLoadDLLs>DanBiasGame_$(PlatformShortName).dll;DanBiasServer_$(PlatformShortName).dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>DanBiasGame_$(PlatformShortName).lib;%(AdditionalDependencies)</AdditionalDependencies>
<DelayLoadDLLs>DanBiasGame_$(PlatformShortName).dll;GameServer_$(PlatformShortName).dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>DanBiasGame_$(PlatformShortName).lib;GameServer_$(PlatformShortName).lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@ -166,8 +166,8 @@
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<DelayLoadDLLs>DanBiasGame_$(PlatformShortName).dll;DanBiasServer_$(PlatformShortName).dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>DanBiasGame_$(PlatformShortName).lib;%(AdditionalDependencies)</AdditionalDependencies>
<DelayLoadDLLs>DanBiasGame_$(PlatformShortName).dll;GameServer_$(PlatformShortName).dll;%(DelayLoadDLLs)</DelayLoadDLLs>
<AdditionalDependencies>DanBiasGame_$(PlatformShortName).lib;GameServer_$(PlatformShortName).lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
@ -177,8 +177,8 @@
<ProjectReference Include="..\DanBiasGame\DanBiasGame.vcxproj">
<Project>{2a1bc987-af42-4500-802d-89cd32fc1309}</Project>
</ProjectReference>
<ProjectReference Include="..\DanBiasServer\DanBiasServer.vcxproj">
<Project>{52380daa-0f4a-4d97-8e57-98df39319caf}</Project>
<ProjectReference Include="..\GameServer\GameServer.vcxproj">
<Project>{143bd516-20a1-4890-a3e4-f8bfd02220e7}</Project>
</ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

2
Code/Misc/DynamicArray.h
View File

@ -4,6 +4,8 @@
#ifndef MISC_DYNAMIC_ARRAY_H
#define MISC_DYNAMIC_ARRAY_H
#include <assert.h>
namespace Utility
{
namespace DynamicMemory

2
Code/Misc/Misc.vcxproj
View File

@ -146,6 +146,7 @@
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="Packing\Packing.cpp" />
<ClCompile Include="Resource\Loaders\ByteLoader.cpp" />
<ClCompile Include="Resource\Loaders\CustomLoader.cpp" />
<ClCompile Include="Resource\OResourceHandler.cpp" />
@ -164,6 +165,7 @@
<ClInclude Include="GID.h" />
<ClInclude Include="IQueue.h" />
<ClInclude Include="OysterCallback.h" />
<ClInclude Include="Packing\Packing.h" />
<ClInclude Include="PostBox\IPostBox.h" />
<ClInclude Include="PostBox\PostBox.h" />
<ClInclude Include="Queue.h" />

6
Code/Misc/Misc.vcxproj.filters
View File

@ -48,6 +48,9 @@
<ClCompile Include="Resource\ResourceManager.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="Packing\Packing.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Utilities.h">
@ -110,5 +113,8 @@
<ClInclude Include="Resource\ResourceManager.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Packing\Packing.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
</Project>

346
Code/Misc/Packing/Packing.cpp Normal file
View File

@ -0,0 +1,346 @@
#include "Packing.h"
/***************************
Packing
***************************/
#include <stdint.h>
namespace Oyster
{
namespace Packing
{
//bool (1-bit)
void Pack(unsigned char buffer[], bool i)
{
*buffer++ = i;
}
//char (8-bit)
void Pack(unsigned char buffer[], char i)
{
*buffer++ = i;
}
void Pack(unsigned char buffer[], unsigned char i)
{
*buffer++ = i;
}
//short (16-bit)
void Pack(unsigned char buffer[], short i)
{
*buffer++ = i >> 8;
*buffer++ = (char)i;
}
void Pack(unsigned char buffer[], unsigned short i)
{
*buffer++ = i >> 8;
*buffer++ = (char)i;
}
//int (32-bit)
void Pack(unsigned char buffer[], int i)
{
*buffer++ = i >> 24;
*buffer++ = i >> 16;
*buffer++ = i >> 8;
*buffer++ = i;
}
void Pack(unsigned char buffer[], unsigned int i)
{
*buffer++ = i >> 24;
*buffer++ = i >> 16;
*buffer++ = i >> 8;
*buffer++ = i;
}
//__int64 (64-bit)
void Pack(unsigned char buffer[], __int64 i)
{
*buffer++ = (char)(i >> 56);
*buffer++ = (char)(i >> 48);
*buffer++ = (char)(i >> 40);
*buffer++ = (char)(i >> 32);
*buffer++ = (char)(i >> 24);
*buffer++ = (char)(i >> 16);
*buffer++ = (char)(i >> 8);
*buffer++ = (char)i;
}
void Pack(unsigned char buffer[], unsigned __int64 i)
{
*buffer++ = (char)(i >> 56);
*buffer++ = (char)(i >> 48);
*buffer++ = (char)(i >> 40);
*buffer++ = (char)(i >> 32);
*buffer++ = (char)(i >> 24);
*buffer++ = (char)(i >> 16);
*buffer++ = (char)(i >> 8);
*buffer++ = (char)i;
}
//floating point (32, 64-bit)
void Pack(unsigned char buffer[], float i)
{
int tempFloat = (int)Pack754(i, 32, 8);
Pack(buffer, tempFloat);
}
void Pack(unsigned char buffer[], double i)
{
__int64 tempDouble = Pack754(i, 64, 11);
Pack(buffer, tempDouble);
}
//string
void Pack(unsigned char buffer[], char str[])
{
short len = (short)strlen(str);
Pack(buffer, len);
buffer += 2;
memcpy(buffer, str, len);
}
void Pack(unsigned char buffer[], std::string& str)
{
short len = (short)str.length();
Pack(buffer, len);
buffer += 2;
memcpy(buffer, str.c_str(), len);
}
unsigned __int64 Pack754(long double f, unsigned bits, unsigned expbits)
{
long double fnorm;
int shift;
long long sign, exp, significand;
unsigned significandbits = bits - expbits - 1; // -1 for sign bit
if (f == 0.0)
return 0; // get this special case out of the way
// check sign and begin normalization
if (f < 0)
{
sign = 1;
fnorm = -f;
}
else
{
sign = 0;
fnorm = f;
}
// get the normalized form of f and track the exponent
shift = 0;
while(fnorm >= 2.0)
{
fnorm /= 2.0;
shift++;
}
while(fnorm < 1.0)
{
fnorm *= 2.0;
shift--;
}
fnorm = fnorm - 1.0;
// calculate the binary form (non-float) of the significand data
significand = (long long)(fnorm * ((1LL << significandbits) + 0.5f));
// get the biased exponent
exp = shift + ((1 << (expbits - 1)) - 1); // shift + bias
// return the final answer
return (sign << (bits - 1)) | (exp << (bits - expbits - 1)) | significand;
}
/******************************
Unpacking
******************************/
//bool (1-bit)
bool Unpackb(unsigned char buffer[])
{
return *buffer;
}
//char (8-bit)
char Unpackc(unsigned char buffer[])
{
if(*buffer <= 0x7f)
{
return *buffer;
}
else
{
return (-1 - (unsigned char)(0xffu - *buffer));
}
}
unsigned char UnpackC(unsigned char buffer[])
{
return *buffer;
}
//short (16-bit)
short Unpacks(unsigned char buffer[])
{
short i = ((short)buffer[0] << 8) | buffer[1];
if(i > 0x7fffu)
{
i = -1 - (unsigned short)(0xffffu - i);
}
return i;
}
unsigned short UnpackS(unsigned char buffer[])
{
return ((unsigned int)buffer[0] << 8) | buffer[1];
}
//int (32-bit)
int Unpacki(unsigned char buffer[])
{
int i = ((int)buffer[0] << 24) |
((int)buffer[1] << 16) |
((int)buffer[2] << 8) |
((int)buffer[3]);
if(i > 0x7fffffffu)
{
i = -1 - (int)(0xffffffffu - i);
}
return i;
}
unsigned int UnpackI(unsigned char buffer[])
{
return ((unsigned int)buffer[0] << 24) |
((unsigned int)buffer[1] << 16) |
((unsigned int)buffer[2] << 8) |
((unsigned int)buffer[3]);
}
//__int64 (64-bit)
__int64 Unpacki64(unsigned char buffer[])
{
__int64 i = ((__int64)buffer[0] << 56) |
((__int64)buffer[1] << 48) |
((__int64)buffer[2] << 40) |
((__int64)buffer[3] << 32) |
((__int64)buffer[4] << 24) |
((__int64)buffer[5] << 16) |
((__int64)buffer[6] << 8) |
(buffer[7]);
if(i > 0x7fffffffffffffffu)
{
i = -1 - (__int64)(0xffffffffffffffffu - i);
}
return i;
}
unsigned __int64 UnpackI64(unsigned char buffer[])
{
return ((__int64)buffer[0] << 56) |
((__int64)buffer[1] << 48) |
((__int64)buffer[2] << 40) |
((__int64)buffer[3] << 32) |
((__int64)buffer[4] << 24) |
((__int64)buffer[5] << 16) |
((__int64)buffer[6] << 8) |
((__int64)buffer[7]);
}
//floating point (32, 64-bit)
float Unpackf(unsigned char buffer[])
{
int tempFloat = Unpacki(buffer);
return (float)Unpack754(tempFloat, 32, 8);
}
double Unpackd(unsigned char buffer[])
{
__int64 tempDouble = Unpacki64(buffer);
return Unpack754(tempDouble, 64, 11);
}
//string
char* UnpackCStr(unsigned char buffer[])
{
short len = UnpackS(buffer);
char* str = new char[len+1];
buffer += 2;
for(int i = 0; i < len; i++)
{
str[i] = buffer[i];
}
str[len] = '\0';
return str;
}
std::string UnpackStr(unsigned char buffer[])
{
short len = UnpackS(buffer);
std::string temp;
temp.resize(len);
buffer += 2;
for(int i = 0; i < len; i++)
{
temp[i] = buffer[i];
}
return temp;
}
long double Unpack754(unsigned __int64 i, unsigned bits, unsigned expbits)
{
long double result;
long long shift;
unsigned bias;
unsigned significandbits = bits - expbits - 1; // -1 for sign bit
if (i == 0)
return 0.0;
// pull the significand
result = (long double)(i&((1LL << significandbits) - 1)); // mask
result /= (1LL << significandbits); // convert back to float
result += 1.0f; // add the one back on
// deal with the exponent
bias = (1 << (expbits - 1)) - 1;
shift = ((i >> significandbits) & ((1LL << expbits) - 1)) - bias;
while(shift > 0)
{
result *= 2.0;
shift--;
}
while(shift < 0)
{
result /= 2.0;
shift++;
}
// sign it
result *= (i >> (bits - 1)) & 1 ? -1.0 : 1.0;
return result;
}
}
}

81
Code/Misc/Packing/Packing.h Normal file
View File

@ -0,0 +1,81 @@
#ifndef PACKING_H
#define PACKING_H
/////////////////////////////////////
// Created by Pontus Fransson 2013 //
/////////////////////////////////////
#include <string>
/******************************
Packing
******************************/
namespace Oyster
{
namespace Packing
{
//bool (1-bit)
void Pack(unsigned char buffer[], bool i);
//char (8-bit)
void Pack(unsigned char buffer[], char i);
void Pack(unsigned char buffer[], unsigned char i); // unsigned
//short (16-bit)
void Pack(unsigned char buffer[], short i);
void Pack(unsigned char buffer[], unsigned short i); // unsigned
//int (32-bit)
void Pack(unsigned char buffer[], int i);
void Pack(unsigned char buffer[], unsigned int i); // unsigned
//__int64 (64-bit)
void Pack(unsigned char buffer[], __int64 i);
void Pack(unsigned char buffer[], unsigned __int64 i); // unsigned
//floating point (32, 64-bit)
void Pack(unsigned char buffer[], float i);
void Pack(unsigned char buffer[], double i);
//string
void Pack(unsigned char buffer[], char str[]);
void Pack(unsigned char buffer[], std::string& str);
unsigned __int64 Pack754(long double f, unsigned bits, unsigned expbits);
/******************************
Unpacking
******************************/
//bool (1-bit)
bool Unpackb(unsigned char buffer[]);
//char (8-bit)
char Unpackc(unsigned char buffer[]);
unsigned char UnpackC(unsigned char buffer[]); // unsigned
//short (16-bit)
short Unpacks(unsigned char buffer[]);
unsigned short UnpackS(unsigned char buffer[]); // unsigned
//int (32-bit)
int Unpacki(unsigned char buffer[]);
unsigned int UnpackI(unsigned char buffer[]); // unsigned
//__int64 (64-bit)
__int64 Unpacki64(unsigned char buffer[]);
unsigned __int64 UnpackI64(unsigned char buffer[]); // unsigned
//floating point (32, 64-bit)
float Unpackf(unsigned char buffer[]);
double Unpackd(unsigned char buffer[]);
//string
char* UnpackCStr(unsigned char buffer[]);
std::string UnpackStr(unsigned char buffer[]);
long double Unpack754(unsigned __int64 i, unsigned bits, unsigned expbits);
}
}
#endif

7
Code/Misc/Resource/OResourceHandler.cpp
View File

@ -214,7 +214,14 @@ int OysterResource::GetResourceId(const wchar_t c[])
return -1;
}
int OysterResource::GetResourceSize(const OHRESOURCE& resource)
{
OResource* t = resourcePrivate.FindResource(resource);
if(t) return t->GetResourceSize();
return -1;
}
OResource* ResourcePrivate::FindResource(const OHRESOURCE& h) const
{

5
Code/Misc/Resource/OysterResource.h
View File

@ -151,6 +151,11 @@ namespace Oyster
*/
static int GetResourceId(const wchar_t filename[]);
static int GetResourceSize(const OHRESOURCE& resource);
};
}
}

3
Code/Misc/Thread/OysterThread.h
View File

@ -72,8 +72,7 @@ namespace Oyster
//OYSTER_THREAD_ERROR Create(Oyster::Callback::CallbackFunction<bool, void>::FNC worker, bool start, bool detach = false);
OYSTER_THREAD_ERROR Start();
OYSTER_THREAD_ERROR Stop();
OYSTER_THREAD_ERROR Pause();
OYSTER_THREAD_ERROR Pause(int mSec);
OYSTER_THREAD_ERROR Stop(int msec);
OYSTER_THREAD_ERROR Resume();
OYSTER_THREAD_ERROR SetWorker(IThreadObject* worker = 0);
OYSTER_THREAD_ERROR SetWorker(ThreadFnc worker = 0);

29
Code/Misc/Thread/OysterThread_Impl.cpp
View File

@ -118,15 +118,17 @@ using namespace Utility::DynamicMemory;
{
SmartPointer<RefData> data;
PrivateData(){}
PrivateData()
{
data = new RefData();
}
~PrivateData()
{
data.Release();
data = 0;
}
OYSTER_THREAD_ERROR Create(ThreadFunction fnc, OwnerContainer worker, bool start, bool detach)
{
if(data) return OYSTER_THREAD_ERROR_ThreadAlreadyCreated;
data = new RefData();
if(!data) data = new RefData();
return data->Create(fnc, worker, start, detach);
}
OYSTER_THREAD_ERROR Terminate()
@ -205,9 +207,8 @@ using namespace Utility::DynamicMemory;
OysterThread::OysterThread()
{
this->privateData = new PrivateData();
}
:privateData(0)
{ }
OysterThread::OysterThread(const OysterThread& original)
{
this->privateData = new PrivateData(*original.privateData);
@ -227,7 +228,7 @@ OysterThread::~OysterThread()
OYSTER_THREAD_ERROR OysterThread::Create(IThreadObject* worker, bool start, bool detach)
{
if(!this->privateData) this->privateData = new PrivateData();
if(!this->privateData) this->privateData = new PrivateData();
OwnerContainer c;
c.type = Oyster::Callback::CallbackType_Object;
@ -236,7 +237,7 @@ OYSTER_THREAD_ERROR OysterThread::Create(IThreadObject* worker, bool start, bool
}
OYSTER_THREAD_ERROR OysterThread::Create(ThreadFnc worker, bool start, bool detach)
{
if(!this->privateData) this->privateData = new PrivateData();
if(!this->privateData) this->privateData = new PrivateData();
OwnerContainer c;
c.type = Oyster::Callback::CallbackType_Function;
@ -257,15 +258,11 @@ OYSTER_THREAD_ERROR OysterThread::Start()
return OYSTER_THREAD_ERROR_SUCCESS;
}
OYSTER_THREAD_ERROR OysterThread::Stop()
{
return this->Terminate();
}
OYSTER_THREAD_ERROR OysterThread::Pause()
{
this->privateData->data->threadData->state = OYSTER_THREAD_STATE_IDLE;
return OYSTER_THREAD_ERROR_SUCCESS;
}
OYSTER_THREAD_ERROR OysterThread::Pause(int msec)
OYSTER_THREAD_ERROR OysterThread::Stop(int msec)
{
this->privateData->data->threadData->msec = msec;
return OYSTER_THREAD_ERROR_SUCCESS;
@ -299,7 +296,9 @@ OYSTER_THREAD_ERROR OysterThread::SetWorker(ThreadFnc worker)
}
OYSTER_THREAD_ERROR OysterThread::Terminate()
{
return this->privateData->Terminate();
if(this->privateData)
return this->privateData->Terminate();
return OYSTER_THREAD_ERROR_SUCCESS;
}
OYSTER_THREAD_ERROR OysterThread::Wait()
{

8
Code/Misc/ThreadSafeQueue.h
View File

@ -10,6 +10,7 @@
/////////////////////////////////////////////
#include "IQueue.h"
#include <mutex>
namespace Utility
{
@ -20,6 +21,7 @@ namespace Utility
{
public:
ThreadSafeQueue<Type>();
ThreadSafeQueue<Type>(const ThreadSafeQueue<Type>& obj);
virtual ~ThreadSafeQueue<Type>();
virtual void Push( Type item );
@ -64,6 +66,12 @@ namespace Utility
}
template < typename Type >
ThreadSafeQueue<Type>::ThreadSafeQueue(const ThreadSafeQueue<Type>& obj)
{
}
template < typename Type >
ThreadSafeQueue<Type>::~ThreadSafeQueue()
{

1
Code/Misc/WinTimer.h
View File

@ -7,6 +7,7 @@
#ifndef WINTIMER_H
#define WINTIMER_H
#define NOMINMAX
#include <Windows.h>
namespace Utility

Some files were not shown because too many files have changed in this diff Show More