Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/branches/core/src/orxonox/Orxonox.cc @ 853

Last change on this file since 853 was 852, checked in by landauf, 17 years ago
removed some includes of CoreIncludes.h from other .h files (included in .cc only)
File size: 50.6 KB

Line
1	/*
2	* ORXONOX - the hottest 3D action shooter ever to exist
3	*
4	*
5	* License notice:
6	*
7	* This program is free software; you can redistribute it and/or
8	* modify it under the terms of the GNU General Public License
9	* as published by the Free Software Foundation; either version 2
10	* of the License, or (at your option) any later version.
11	*
12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20	*
21	* Author:
22	* Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
23	* Co-authors:
24	* ...
25	*
26	*/
27
28	/**
29	@file Orxonox.cc
30	@brief Orxonox Main Class
31	*/
32
33	// Precompiled Headers
34	#include "OrxonoxStableHeaders.h"
35
36	//**** OGRE ****
37	#include <OgreException.h>
38	#include <OgreRoot.h>
39	#include <OgreFrameListener.h>
40	#include <OgreRenderWindow.h>
41	#include <OgreTextureManager.h>
42	#include <OgreResourceGroupManager.h>
43	#include <OgreConfigFile.h>
44	#include <OgreOverlay.h>
45	#include <OgreOverlayManager.h>
46
47	//**** OIS *****
48	#include <OIS/OIS.h>
49
50	//**** STD *****
51	#include <iostream>
52	#include <exception>
53
54	//*** ORXONOX **
55	//misc
56	#include "core/CoreIncludes.h"
57	#include "util/Sleep.h"
58
59	// loader and audio
60	//#include "loader/LevelLoader.h"
61	//#include "audio/AudioManager.h"
62
63	// network
64	//#include "network/Server.h"
65	//#include "network/Client.h"
66	//#include "network/NetworkFrameListener.h"
67
68	// objects
69	#include "objects/Tickable.h"
70	#include "tools/Timer.h"
71	//#include "objects/NPC.h"
72	#include "core/ArgReader.h"
73	#include "core/Factory.h"
74	#include "core/Debug.h"
75	//#include "hud/HUD.h"
76	//#include "objects/weapon/BulletManager.h"
77	#include "GraphicsEngine.h"
78
79	#include "core/ClassTreeMask.h"
80	#include "objects/WorldEntity.h"
81	#include "core/DebugLevel.h"
82	#include "core/BaseObject.h"
83	#include "objects/Test.h"
84	#include "objects/test1.h"
85	#include "objects/test2.h"
86	#include "objects/test3.h"
87	#include "core/Loader.h"
88
89	#include "Orxonox.h"
90
91	namespace orxonox
92	{
93	// put this in a seperate Class or solve the problem in another fashion
94	class OrxListener : public Ogre::FrameListener
95	{
96	public:
97	OrxListener(OIS::Keyboard keyboard/, audio::AudioManager* auMan*/, gameMode mode)
98	{
99	mKeyboard = keyboard;
100	mode_=mode;
101	// auMan_ = auMan;
102	}
103
104	bool frameStarted(const Ogre::FrameEvent& evt)
105	{
106	// auMan_->update();
107	updateAI();
108
109	/* if(mode_ == PRESENTATION)
110	server_g->tick(evt.timeSinceLastFrame);
111	else if(mode_ == CLIENT)
112	client_g->tick(evt.timeSinceLastFrame);
113	*/
114	usleep(10);
115
116	mKeyboard->capture();
117	return !mKeyboard->isKeyDown(OIS::KC_ESCAPE);
118	}
119
120	void updateAI()
121	{/*
122	for(Iterator<NPC> it = ObjectList<NPC>::start(); it; ++it)
123	{
124	it->update();
125	}*/
126	}
127
128	private:
129	gameMode mode_;
130	OIS::Keyboard *mKeyboard;
131	// audio::AudioManager* auMan_;
132	};
133
134	// init static singleton reference of Orxonox
135	Orxonox* Orxonox::singletonRef_ = NULL;
136
137	/**
138	* create a new instance of Orxonox
139	*/
140	Orxonox::Orxonox()
141	{
142	this->ogre_ = new GraphicsEngine();
143	this->dataPath_ = "";
144	// this->loader_ = 0;
145	// this->auMan_ = 0;
146	this->singletonRef_ = 0;
147	this->keyboard_ = 0;
148	this->mouse_ = 0;
149	this->inputManager_ = 0;
150	this->frameListener_ = 0;
151	this->root_ = 0;
152	}
153
154	/**
155	* destruct Orxonox
156	*/
157	Orxonox::~Orxonox()
158	{
159	// nothing to delete as for now
160	}
161
162	/**
163	* initialization of Orxonox object
164	* @param argc argument counter
165	* @param argv list of arguments
166	* @param path path to config (in home dir or something)
167	*/
168	void Orxonox::init(int argc, char **argv, std::string path)
169	{
170	//TODO: find config file (assuming executable directory)
171	//TODO: read config file
172	//TODO: give config file to Ogre
173	std::string mode;
174	// if(argc>=2)
175	// mode = std::string(argv[1]);
176	// else
177	// mode = "";
178	ArgReader ar = ArgReader(argc, argv);
179	ar.checkArgument("mode", mode, false);
180	ar.checkArgument("data", this->dataPath_, false);
181	ar.checkArgument("ip", serverIp_, false);
182	//mode = "presentation";
183	if(ar.errorHandling()) die();
184	if(mode == std::string("server"))
185	{
186	serverInit(path);
187	mode_ = SERVER;
188	}
189	else if(mode == std::string("client"))
190	{
191	clientInit(path);
192	mode_ = CLIENT;
193	}
194	else if(mode == std::string("presentation"))
195	{
196	serverInit(path);
197	mode_ = PRESENTATION;
198	}
199	else{
200	standaloneInit(path);
201	mode_ = STANDALONE;
202	}
203	}
204
205	/**
206	* start modules
207	*/
208	void Orxonox::start()
209	{
210	//TODO: start modules
211	// ogre_->startRender();
212	//TODO: run engine
213	Factory::createClassHierarchy();
214	// createScene();
215	// setupScene();
216	// setupInputSystem();
217	if(mode_!=CLIENT){ // remove this in future ---- presentation hack
218	}
219	else
220	std::cout << "client here" << std::endl;
221	createFrameListener();
222	switch(mode_){
223	case PRESENTATION:
224	//ogre_->getRoot()->addFrameListener(new network::ServerFrameListener());
225	//std::cout << "could not add framelistener" << std::endl;
226	// server_g->open();
227	break;
228	case CLIENT:
229	// client_g->establishConnection();
230	break;
231	case SERVER:
232	case STANDALONE:
233	default:
234	break;
235	}
236	#define testandcout(code) \
237	std::cout << #code << " " << code << "\n"
238	/*
239	std::cout << "Test 1\n";
240	BaseObject* test1;
241	test1 = new BaseObject();
242	test1 = new BaseObject();
243	test1 = new BaseObject();
244
245	std::cout << "Test 2\n";
246	A1* test2;
247	test2 = new A1();
248	test2 = new A1();
249	test2 = new A1();
250
251	std::cout << "Test 3\n";
252	BaseObject* test3;
253	test3 = new BaseObject();
254	test3 = new BaseObject();
255	test3 = new BaseObject();
256
257	std::cout << "Test 4\n";
258	A3* test4;
259	test4 = new A3();
260	test4 = new A3();
261	test4 = new A3();
262
263
264	std::cout << "Test 5\n";
265	A1* test5_01 = new A1();
266	A2* test5_02 = new A2();
267	A3* test5_03 = new A3();
268	A1B1* test5_04 = new A1B1();
269	A1B2* test5_05 = new A1B2();
270	A2B1* test5_06 = new A2B1();
271	A2B2* test5_07 = new A2B2();
272	A3B1* test5_08 = new A3B1();
273	A3B2* test5_09 = new A3B2();
274	A1B1C1* test5_10 = new A1B1C1();
275	A1B1C2* test5_11 = new A1B1C2();
276	A1B2C1* test5_12 = new A1B2C1();
277	A2B1C1* test5_13 = new A2B1C1();
278	A2B2C1* test5_14 = new A2B2C1();
279	A3B1C1* test5_15 = new A3B1C1();
280	A3B1C2* test5_16 = new A3B1C2();
281	A3B2C1* test5_17 = new A3B2C1();
282	A3B2C2* test5_18 = new A3B2C2();
283	*/
284	/*
285	OrxonoxClass* test5 = 0;
286	for (int i = 0; i <= 18; i++)
287	{
288	if (i == 0) test5 = new BaseObject;
289	if (i == 1) test5 = test5_01;
290	if (i == 2) test5 = test5_02;
291	if (i == 3) test5 = test5_03;
292	if (i == 4) test5 = test5_04;
293	if (i == 5) test5 = test5_05;
294	if (i == 6) test5 = test5_06;
295	if (i == 7) test5 = test5_07;
296	if (i == 8) test5 = test5_08;
297	if (i == 9) test5 = test5_09;
298	if (i == 10) test5 = test5_10;
299	if (i == 11) test5 = test5_11;
300	if (i == 12) test5 = test5_12;
301	if (i == 13) test5 = test5_13;
302	if (i == 14) test5 = test5_14;
303	if (i == 15) test5 = test5_15;
304	if (i == 16) test5 = test5_16;
305	if (i == 17) test5 = test5_17;
306	if (i == 18) test5 = test5_18;
307
308	std::cout << "\n";
309	std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): parents: " << test5->getIdentifier()->getParents() << "\n";
310	std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): children: " << test5->getIdentifier()->getChildren() << "\n";
311	std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): direct parents: " << test5->getIdentifier()->getDirectParents() << "\n";
312	std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): direct children: " << test5->getIdentifier()->getDirectChildren() << "\n";
313	}
314	*/
315	/*
316	for (std::map<std::string, Identifier*>::const_iterator it = Factory::getFactoryBegin(); it != Factory::getFactoryEnd(); ++it)
317	std::cout << "Class with ID " << (it).second->getNetworkID() << ": " << ID((it).second->getNetworkID()) << " / " << ID((*it).second->getNetworkID())->getName() << std::endl;
318
319	std::cout << "Class with ID 100: " << ID(100) << "\n";
320	std::cout << "ID of BaseObject: " << Class(BaseObject)->getNetworkID() << "\n";
321
322	std::cout << "\nChange ID of BaseObject to 100\n";
323	Class(BaseObject)->setNetworkID(100);
324	std::cout << "Class with ID 100: " << ID(100) << "\n";
325	std::cout << "Class with ID 1: " << ID(1) << "\n";
326	std::cout << "ID of BaseObject: " << Class(BaseObject)->getNetworkID() << "\n";
327
328	std::cout << "\nChange ID of BaseObject to 3\n";
329	Class(BaseObject)->setNetworkID(3);
330	std::cout << "Class with ID 100: " << ID(100) << "\n";
331	std::cout << "Class with ID 1: " << ID(1) << "\n";
332	std::cout << "Class with ID 3: " << ID(3) << "\n";
333	std::cout << "ID of BaseObject: " << Class(BaseObject)->getNetworkID() << "\n";
334	std::cout << "ID of Test1: " << Class(Test1)->getNetworkID() << "\n";
335	*/
336	/*
337	std::cout << "\n";
338	std::cout << "isA(XYZ)-Test:\n";
339	std::cout << "test5_01 = A1, Erwartet: 1 0 0 1 0\n";
340	testandcout(test5_01->isA(Class(A1)));
341	testandcout(test5_01->isA(Class(A2)));
342	testandcout(test5_01->isA(Class(A1B1)));
343	testandcout(test5_01->isA(Class(BaseObject)));
344	testandcout(test5_01->isA(Class(Interface1)));
345
346	std::cout << "\n";
347	std::cout << "test5_02 = A2, Erwartet: 0 1 0 1 0\n";
348	testandcout(test5_02->isA(Class(A1)));
349	testandcout(test5_02->isA(Class(A2)));
350	testandcout(test5_02->isA(Class(A1B1)));
351	testandcout(test5_02->isA(Class(BaseObject)));
352	testandcout(test5_02->isA(Class(Interface1)));
353
354	std::cout << "\n";
355	std::cout << "test5_01 = A3, Erwartet: 0 0 0 1 1\n";
356	testandcout(test5_03->isA(Class(A1)));
357	testandcout(test5_03->isA(Class(A2)));
358	testandcout(test5_03->isA(Class(A1B1)));
359	testandcout(test5_03->isA(Class(BaseObject)));
360	testandcout(test5_03->isA(Class(Interface1)));
361
362	std::cout << "\n";
363	std::cout << "isDirectA(XYZ)-Test:\n";
364	std::cout << "test5_01 = A1, Erwartet: 1 0 0 0 0\n";
365	testandcout(test5_01->isExactlyA(Class(A1)));
366	testandcout(test5_01->isExactlyA(Class(A2)));
367	testandcout(test5_01->isExactlyA(Class(A1B1)));
368	testandcout(test5_01->isExactlyA(Class(BaseObject)));
369	testandcout(test5_01->isExactlyA(Class(Interface1)));
370
371	std::cout << "\n";
372	std::cout << "test5_02 = A2, Erwartet: 0 1 0 0 0\n";
373	testandcout(test5_02->isExactlyA(Class(A1)));
374	testandcout(test5_02->isExactlyA(Class(A2)));
375	testandcout(test5_02->isExactlyA(Class(A1B1)));
376	testandcout(test5_02->isExactlyA(Class(BaseObject)));
377	testandcout(test5_02->isExactlyA(Class(Interface1)));
378
379	std::cout << "\n";
380	std::cout << "test5_03 = A3, Erwartet: 0 0 0 0 0\n";
381	testandcout(test5_03->isExactlyA(Class(A1)));
382	testandcout(test5_03->isExactlyA(Class(A2)));
383	testandcout(test5_03->isExactlyA(Class(A1B1)));
384	testandcout(test5_03->isExactlyA(Class(BaseObject)));
385	testandcout(test5_03->isExactlyA(Class(Interface1)));
386
387	std::cout << "\n";
388	std::cout << "isChildOf(XYZ)-Test:\n";
389	std::cout << "test5_04 = A1B1, Erwartet: 1 0 1 0 0 0 0\n";
390	testandcout(test5_04->isChildOf(Class(A1)));
391	testandcout(test5_04->isChildOf(Class(A2)));
392	testandcout(test5_04->isChildOf(Class(BaseObject)));
393	testandcout(test5_04->isChildOf(Class(Interface1)));
394	testandcout(test5_04->isChildOf(Class(Interface2)));
395	testandcout(test5_04->isChildOf(Class(A1B1C2)));
396	testandcout(test5_04->isChildOf(Class(A1B1)));
397
398	std::cout << "\n";
399	std::cout << "test5_06 = A2B1, Erwartet: 0 1 1 0 0 0 0\n";
400	testandcout(test5_06->isChildOf(Class(A1)));
401	testandcout(test5_06->isChildOf(Class(A2)));
402	testandcout(test5_06->isChildOf(Class(BaseObject)));
403	testandcout(test5_06->isChildOf(Class(Interface1)));
404	testandcout(test5_06->isChildOf(Class(Interface2)));
405	testandcout(test5_06->isChildOf(Class(A1B1C2)));
406	testandcout(test5_06->isChildOf(Class(A1B1)));
407
408	std::cout << "\n";
409	std::cout << "test5_07 = A2B2, Erwartet: 0 1 1 1 0 0\n";
410	testandcout(test5_07->isChildOf(Class(A1)));
411	testandcout(test5_07->isChildOf(Class(A2)));
412	testandcout(test5_07->isChildOf(Class(BaseObject)));
413	testandcout(test5_07->isChildOf(Class(Interface1)));
414	testandcout(test5_07->isChildOf(Class(Interface2)));
415	testandcout(test5_07->isChildOf(Class(A1B1C2)));
416
417	std::cout << "\n";
418	std::cout << "test5_08 = A3B1, Erwartet: 0 0 1 1 0 0\n";
419	testandcout(test5_08->isChildOf(Class(A1)));
420	testandcout(test5_08->isChildOf(Class(A2)));
421	testandcout(test5_08->isChildOf(Class(BaseObject)));
422	testandcout(test5_08->isChildOf(Class(Interface1)));
423	testandcout(test5_08->isChildOf(Class(Interface2)));
424	testandcout(test5_08->isChildOf(Class(A1B1C2)));
425
426	std::cout << "\n";
427	std::cout << "test5_09 = A3B2, Erwartet: 0 0 1 1 1 0\n";
428	testandcout(test5_09->isChildOf(Class(A1)));
429	testandcout(test5_09->isChildOf(Class(A2)));
430	testandcout(test5_09->isChildOf(Class(BaseObject)));
431	testandcout(test5_09->isChildOf(Class(Interface1)));
432	testandcout(test5_09->isChildOf(Class(Interface2)));
433	testandcout(test5_09->isChildOf(Class(A1B1C2)));
434
435	std::cout << "\n";
436	std::cout << "isDirectChildOf(XYZ)-Test:\n";
437	std::cout << "test5_04 = A1B1, Erwartet: 1 0 0 0 0 0 0\n";
438	testandcout(test5_04->isDirectChildOf(Class(A1)));
439	testandcout(test5_04->isDirectChildOf(Class(A2)));
440	testandcout(test5_04->isDirectChildOf(Class(BaseObject)));
441	testandcout(test5_04->isDirectChildOf(Class(Interface1)));
442	testandcout(test5_04->isDirectChildOf(Class(Interface2)));
443	testandcout(test5_04->isDirectChildOf(Class(A1B1C2)));
444	testandcout(test5_04->isDirectChildOf(Class(A1B1)));
445
446	std::cout << "\n";
447	std::cout << "test5_06 = A2B1, Erwartet: 0 1 0 0 0 0 0\n";
448	testandcout(test5_06->isDirectChildOf(Class(A1)));
449	testandcout(test5_06->isDirectChildOf(Class(A2)));
450	testandcout(test5_06->isDirectChildOf(Class(BaseObject)));
451	testandcout(test5_06->isDirectChildOf(Class(Interface1)));
452	testandcout(test5_06->isDirectChildOf(Class(Interface2)));
453	testandcout(test5_06->isDirectChildOf(Class(A1B1C2)));
454	testandcout(test5_06->isDirectChildOf(Class(A1B1)));
455
456	std::cout << "\n";
457	std::cout << "test5_07 = A2B2, Erwartet: 0 1 0 1 0 0\n";
458	testandcout(test5_07->isDirectChildOf(Class(A1)));
459	testandcout(test5_07->isDirectChildOf(Class(A2)));
460	testandcout(test5_07->isDirectChildOf(Class(BaseObject)));
461	testandcout(test5_07->isDirectChildOf(Class(Interface1)));
462	testandcout(test5_07->isDirectChildOf(Class(Interface2)));
463	testandcout(test5_07->isDirectChildOf(Class(A1B1C2)));
464
465	std::cout << "\n";
466	std::cout << "test5_08 = A3B1, Erwartet: 0 0 0 0 0 0\n";
467	testandcout(test5_08->isDirectChildOf(Class(A1)));
468	testandcout(test5_08->isDirectChildOf(Class(A2)));
469	testandcout(test5_08->isDirectChildOf(Class(BaseObject)));
470	testandcout(test5_08->isDirectChildOf(Class(Interface1)));
471	testandcout(test5_08->isDirectChildOf(Class(Interface2)));
472	testandcout(test5_08->isDirectChildOf(Class(A1B1C2)));
473
474	std::cout << "\n";
475	std::cout << "test5_09 = A3B2, Erwartet: 0 0 0 0 1 0\n";
476	testandcout(test5_09->isDirectChildOf(Class(A1)));
477	testandcout(test5_09->isDirectChildOf(Class(A2)));
478	testandcout(test5_09->isDirectChildOf(Class(BaseObject)));
479	testandcout(test5_09->isDirectChildOf(Class(Interface1)));
480	testandcout(test5_09->isDirectChildOf(Class(Interface2)));
481	testandcout(test5_09->isDirectChildOf(Class(A1B1C2)));
482
483	std::cout << "\n";
484
485	std::cout << "isParentOf(XYZ)-Test:\n";
486	std::cout << "test1 = BaseObject, Erwartet: 0 0 1 1 1 1 1\n";
487	testandcout(test1->isParentOf(Class(BaseObject)));
488	testandcout(test1->isParentOf(Class(Interface1)));
489	testandcout(test1->isParentOf(Class(A1)));
490	testandcout(test1->isParentOf(Class(A2)));
491	testandcout(test1->isParentOf(Class(A1B1)));
492	testandcout(test1->isParentOf(Class(A2B2)));
493	testandcout(test1->isParentOf(Class(A3B1C2)));
494
495	std::cout << "\n";
496	std::cout << "test5_01 = A1, Erwartet: 0 0 0 0 1 0 0\n";
497	testandcout(test5_01->isParentOf(Class(BaseObject)));
498	testandcout(test5_01->isParentOf(Class(Interface1)));
499	testandcout(test5_01->isParentOf(Class(A1)));
500	testandcout(test5_01->isParentOf(Class(A2)));
501	testandcout(test5_01->isParentOf(Class(A1B1)));
502	testandcout(test5_01->isParentOf(Class(A2B2)));
503	testandcout(test5_01->isParentOf(Class(A3B1C2)));
504
505	std::cout << "\n";
506	std::cout << "Interface1, Erwartet: 0 0 0 0 0 1 1\n";
507	testandcout(Class(Interface1)->isParentOf(Class(BaseObject)));
508	testandcout(Class(Interface1)->isParentOf(Class(Interface1)));
509	testandcout(Class(Interface1)->isParentOf(Class(A1)));
510	testandcout(Class(Interface1)->isParentOf(Class(A2)));
511	testandcout(Class(Interface1)->isParentOf(Class(A1B1)));
512	testandcout(Class(Interface1)->isParentOf(Class(A2B2)));
513	testandcout(Class(Interface1)->isParentOf(Class(A3B1C2)));
514
515	std::cout << "\n";
516	std::cout << "isDirectParentOf(XYZ)-Test:\n";
517	std::cout << "test1 = BaseObject, Erwartet: 0 0 1 1 0 0 0\n";
518	testandcout(test1->isDirectParentOf(Class(BaseObject)));
519	testandcout(test1->isDirectParentOf(Class(Interface1)));
520	testandcout(test1->isDirectParentOf(Class(A1)));
521	testandcout(test1->isDirectParentOf(Class(A2)));
522	testandcout(test1->isDirectParentOf(Class(A1B1)));
523	testandcout(test1->isDirectParentOf(Class(A2B2)));
524	testandcout(test1->isDirectParentOf(Class(A3B1C2)));
525
526	std::cout << "\n";
527	std::cout << "test5_01 = A1, Erwartet: 0 0 0 0 1 0 0\n";
528	testandcout(test5_01->isDirectParentOf(Class(BaseObject)));
529	testandcout(test5_01->isDirectParentOf(Class(Interface1)));
530	testandcout(test5_01->isDirectParentOf(Class(A1)));
531	testandcout(test5_01->isDirectParentOf(Class(A2)));
532	testandcout(test5_01->isDirectParentOf(Class(A1B1)));
533	testandcout(test5_01->isDirectParentOf(Class(A2B2)));
534	testandcout(test5_01->isDirectParentOf(Class(A3B1C2)));
535
536	std::cout << "\n";
537	std::cout << "Interface1, Erwartet: 0 0 0 0 0 1 0\n";
538	testandcout(Class(Interface1)->isDirectParentOf(Class(BaseObject)));
539	testandcout(Class(Interface1)->isDirectParentOf(Class(Interface1)));
540	testandcout(Class(Interface1)->isDirectParentOf(Class(A1)));
541	testandcout(Class(Interface1)->isDirectParentOf(Class(A2)));
542	testandcout(Class(Interface1)->isDirectParentOf(Class(A1B1)));
543	testandcout(Class(Interface1)->isDirectParentOf(Class(A2B2)));
544	testandcout(Class(Interface1)->isDirectParentOf(Class(A3B1C2)));
545	*/
546	/*
547	std::cout << "Test 6\n";
548	std::cout << "1\n";
549	Identifier* test6_01 = Class(A1B1);
550	std::cout << "2\n";
551	Identifier* test6_02 = Class(A1B1);
552	std::cout << "3\n";
553	Identifier* test6_03 = Class(A1);
554	std::cout << "4\n";
555	Identifier* test6_04 = Class(A1B1C1);
556	std::cout << "5\n";
557	Identifier* test6_05 = Class(A1B1);
558	std::cout << "6\n";
559	Identifier* test6_06 = Class(A1B1C1);
560
561	std::cout << "7\n";
562
563	std::cout << "\n";
564	std::cout << "BaseObject: parents: " << Class(BaseObject)->getParents() << "\n";
565	std::cout << "BaseObject: children: " << Class(BaseObject)->getChildren() << "\n";
566	std::cout << "BaseObject: direct parents: " << Class(BaseObject)->getDirectParents() << "\n";
567	std::cout << "BaseObject: direct children: " << Class(BaseObject)->getDirectChildren() << "\n";
568
569	std::cout << "\n";
570	std::cout << "A1: parents: " << Class(A1)->getParents() << "\n";
571	std::cout << "A1: children: " << Class(A1)->getChildren() << "\n";
572	std::cout << "A1: direct parents: " << Class(A1)->getDirectParents() << "\n";
573	std::cout << "A1: direct children: " << Class(A1)->getDirectChildren() << "\n";
574
575	std::cout << "\n";
576	std::cout << "A1B1: parents: " << Class(A1B1)->getParents() << "\n";
577	std::cout << "A1B1: children: " << Class(A1B1)->getChildren() << "\n";
578	std::cout << "A1B1: direct parents: " << Class(A1B1)->getDirectParents() << "\n";
579	std::cout << "A1B1: direct children: " << Class(A1B1)->getDirectChildren() << "\n";
580
581	std::cout << "\n";
582	std::cout << "A1B1C1: parents: " << Class(A1B1C1)->getParents() << "\n";
583	std::cout << "A1B1C1: children: " << Class(A1B1C1)->getChildren() << "\n";
584	std::cout << "A1B1C1: direct parents: " << Class(A1B1C1)->getDirectParents() << "\n";
585	std::cout << "A1B1C1: direct children: " << Class(A1B1C1)->getDirectChildren() << "\n";
586
587	std::cout << "\n";
588	std::cout << "A3B1C1 child of A3: " << Class(A3B1C1)->isChildOf(Class(A3)) << "\n";
589	std::cout << "\n";
590	std::cout << "A2 parent of A2B1C1: " << Class(A2)->isParentOf(Class(A2B1C1)) << "\n";
591
592	std::cout << "8\n";
593	*/
594	/*
595	std::cout << "Test 7\n";
596	std::cout << "1\n";
597	SubclassIdentifier<A1B1> test7_01;
598	test7_01 = Class(A1B1C1);
599
600	SubclassIdentifier<A1B1> test7_02;
601	test7_02 = Class(A1B1);
602
603	std::cout << test7_01->getName() << "\n";
604	std::cout << test7_02->getName() << "\n";
605	*/
606	/*
607	// ## WARNING - CRASH! ##
608	std::cout << "2\n";
609
610	SubclassIdentifier<A1B1> test7_03;
611	test7_03 = Class(A1);
612
613	SubclassIdentifier<A1B1> test7_04;
614	test7_04 = Class(A1B2);
615
616	SubclassIdentifier<A1B1> test7_05;
617	test7_05 = Class(A2);
618	// ## END WARNING - CRASH! ##
619	*/
620	/*
621	std::cout << "Test 8\n";
622
623	std::cout << "1\n";
624	Test1* test8_01 = new Test1;
625	Test3* test8_03 = new Test3;
626	test8_03->usefullClassesIsATest(test8_01);
627
628	std::cout << "2\n";
629	Test2* test8_02 = new Test2;
630	test8_03->usefullClassesIsATest(test8_02);
631
632	std::cout << "3\n";
633	test8_01->setUsefullClass1(Class(Test1));
634	test8_01->setUsefullClass1(test8_02->getIdentifier());
635	test8_01->setUsefullClass2(Class(Test2));
636	test8_01->setUsefullClassOfTypeTest3(Class(Test3));
637	test8_01->setUsefullClassOfTypeTest3(test8_03->getIdentifier());
638
639
640	testandcout(test8_01->isA(Class(Test1)));
641	testandcout(test8_01->isA(Class(Test2)));
642	testandcout(test8_01->isA(Class(Test3)));
643
644	Test2* test8_04 = new Test2;
645	testandcout(test8_02->isA(Class(Test1)));
646	testandcout(test8_02->isA(Class(Test2)));
647	testandcout(test8_02->isA(Class(Test3)));
648
649	Test3* test8_05 = new Test3;
650	testandcout(test8_03->isA(Class(Test1)));
651	testandcout(test8_03->isA(Class(Test2)));
652	testandcout(test8_03->isA(Class(Test3)));
653
654	delete test8_01;
655	delete test8_02;
656	delete test8_03;
657	*/
658	/*
659	std::cout << "Test 9\n";
660	std::cout << "1\n";
661	Identifier* test9_01 = Class(A3);
662	BaseObject* test9_02 = test9_01->fabricate();
663	std::cout << test9_02->getIdentifier()->getName() << "\n";
664
665	std::cout << "\n2\n";
666	BaseObject* test9_03 = Class(A1B2)->fabricate();
667	std::cout << test9_03->getIdentifier()->getName() << "\n";
668
669	std::cout << "\n3\n";
670	SubclassIdentifier<A1> test9_04;
671	test9_04 = Class(A1B1C1);
672	A1* test9_05 = test9_04.fabricate();
673	std::cout << test9_05->getIdentifier()->getName() << "\n";
674
675	std::cout << "\n4\n";
676	BaseObject* test9_06 = ID("A2B2")->fabricate();
677	std::cout << test9_06->getIdentifier()->getName() << "\n";
678
679	std::cout << "\n5\n";
680	delete test9_02;
681	delete test9_03;
682	delete test9_05;
683	delete test9_06;
684	*/
685	/*
686	std::cout << "Test 10\n";
687	Identifier* test10_01 = Class(A1B2);
688	Identifier* test10_02 = Class(A2);
689	Identifier* test10_03 = Class(A3B1C1);
690
691	BaseObject* test10_04 = test10_01->fabricate();
692	BaseObject* test10_05 = test10_02->fabricate();
693	BaseObject* test10_06 = test10_03->fabricate();
694
695	BaseObject* test10_07;
696	for (int i = 0; i < 10; i++)
697	test10_07 = ID("A1B1C1")->fabricate();
698
699	std::cout << "1\n";
700	int count;
701
702	count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; ++it) { count++; }
703	std::cout << "Anzahl BaseObjects: " << count << "\n";
704	count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it; ++it) { count++; }
705	std::cout << "Anzahl A1: " << count << "\n";
706	count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; }
707	std::cout << "Anzahl A1B1: " << count << "\n";
708	count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::start(); it; ++it) { count++; }
709	std::cout << "Anzahl A1B1C1: " << count << "\n";
710	count = 0; for (Iterator<A2> it = ObjectList<A2>::start(); it; ++it) { count++; }
711	std::cout << "Anzahl A2: " << count << "\n";
712
713	std::cout << "2\n";
714	BaseObject* test10_08;
715	BaseObject* test10_09 = 0;
716	BaseObject* test10_10 = 0;
717	for (int i = 0; i < 10; i++)
718	{
719	test10_08 = ID("A2B1C1")->fabricate();
720	std::string objName = "A2B1C1#";
721	objName += '0' + i;
722	test10_08->setName(objName);
723
724	if (i == 0)
725	test10_09 = test10_08;
726
727	if (i == 5)
728	test10_10 = test10_08;
729	}
730
731	count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; ++it) { count++; }
732	std::cout << "Anzahl BaseObjects: " << count << "\n";
733	count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it; ++it) { count++; }
734	std::cout << "Anzahl A1: " << count << "\n";
735	count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; }
736	std::cout << "Anzahl A1B1: " << count << "\n";
737	count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::start(); it; ++it) { count++; }
738	std::cout << "Anzahl A1B1C1: " << count << "\n";
739	count = 0; for (Iterator<A2> it = ObjectList<A2>::start(); it; ++it) { count++; }
740	std::cout << "Anzahl A2: " << count << "\n";
741
742	for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::start(); it; ++it)
743	std::cout << "Name: " << it->getName() << "\n";
744
745	std::cout << "3\n";
746	for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::end(); it; --it)
747	std::cout << "Name: " << it->getName() << "\n";
748
749	std::cout << "4\n";
750	delete test10_08;
751
752	count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; ++it) { count++; }
753	std::cout << "Anzahl BaseObjects: " << count << "\n";
754	count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it; ++it) { count++; }
755	std::cout << "Anzahl A1: " << count << "\n";
756	count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; }
757	std::cout << "Anzahl A1B1: " << count << "\n";
758	count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::start(); it; ++it) { count++; }
759	std::cout << "Anzahl A1B1C1: " << count << "\n";
760	count = 0; for (Iterator<A2> it = ObjectList<A2>::start(); it; ++it) { count++; }
761	std::cout << "Anzahl A2: " << count << "\n";
762
763	std::cout << "5\n";
764	for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::start(); it; ++it)
765	std::cout << "Name: " << it->getName() << "\n";
766
767	std::cout << "6\n";
768	for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::end(); it; --it)
769	std::cout << "Name: " << it->getName() << "\n";
770
771	std::cout << "7\n";
772	delete test10_09;
773
774	count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::end(); it; --it) { count++; }
775	std::cout << "Anzahl BaseObjects: " << count << "\n";
776	count = 0; for (Iterator<A1> it = ObjectList<A1>::end(); it; --it) { count++; }
777	std::cout << "Anzahl A1: " << count << "\n";
778	count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::end(); it; --it) { count++; }
779	std::cout << "Anzahl A1B1: " << count << "\n";
780	count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::end(); it; --it) { count++; }
781	std::cout << "Anzahl A1B1C1: " << count << "\n";
782	count = 0; for (Iterator<A2> it = ObjectList<A2>::end(); it; --it) { count++; }
783	std::cout << "Anzahl A2: " << count << "\n";
784
785	std::cout << "8\n";
786	for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::start(); it; ++it)
787	std::cout << "Name: " << it->getName() << "\n";
788
789	std::cout << "9\n";
790	for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::end(); it; --it)
791	std::cout << "Name: " << it->getName() << "\n";
792
793	std::cout << "10\n";
794	delete test10_10;
795
796	count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; ++it) { count++; }
797	std::cout << "Anzahl BaseObjects: " << count << "\n";
798	count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it; ++it) { count++; }
799	std::cout << "Anzahl A1: " << count << "\n";
800	count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; }
801	std::cout << "Anzahl A1B1: " << count << "\n";
802	count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::start(); it; ++it) { count++; }
803	std::cout << "Anzahl A1B1C1: " << count << "\n";
804	count = 0; for (Iterator<A2> it = ObjectList<A2>::start(); it; ++it) { count++; }
805	std::cout << "Anzahl A2: " << count << "\n";
806
807	std::cout << "11\n";
808	for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::start(); it; ++it)
809	std::cout << "Name: " << it->getName() << "\n";
810
811	std::cout << "12\n";
812	for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::end(); it; --it)
813	std::cout << "Name: " << it->getName() << "\n";
814
815	std::cout << "13\n";
816	*/
817	/*
818	std::cout << "Test 11\n";
819	std::cout << "1\n";
820	int count2 = 0; for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it) { count2++; }
821	std::cout << "AnzahlTickable: " << count2 << "\n";
822
823	Test1* test11_1;
824	for (int i = 0; i < 3; i++)
825	test11_1 = new Test1;
826
827	count2 = 0; for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it) { count2++; }
828	std::cout << "AnzahlTickable: " << count2 << "\n";
829
830	for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
831	it->tick(0);
832
833	std::cout << "2\n";
834	Test2* test11_2 = new Test2;
835
836
837	std::cout << "3\n";
838	Test3* test11_3 = new Test3;
839	test11_3->configOutput();
840
841	std::cout << "4\n";
842	*/
843	/*
844	std::cout << "Test 12\n";
845	std::cout << "1\n";
846
847	WorldEntity* test12_1 = new WorldEntity;
848
849	std::cout << sizeof(WorldEntity) << std::endl;
850
851	std::cout << "2\n";
852	*/
853	/*
854	std::cout << "Test 13\n";
855
856	#define BoolToYesNo(bool) \
857	if (bool) \
858	std::cout << "yes "; \
859	else \
860	std::cout << "no "
861
862	#define TestClassTreeMask(mask) \
863	std::cout << "========== ClassTreeMask-Test ===========" << std::endl; \
864	std::cout << mask << std::endl << std::endl; \
865	std::cout << " "; \
866	BoolToYesNo(mask.isIncluded(Class(BaseObject))); \
867	std::cout << std::endl; \
868	\
869	std::cout << " "; \
870	BoolToYesNo(mask.isIncluded(Class(A1))); \
871	std::cout << " "; \
872	BoolToYesNo(mask.isIncluded(Class(A2))); \
873	std::cout << " "; \
874	BoolToYesNo(mask.isIncluded(Class(A3))); \
875	std::cout << std::endl; \
876	\
877	std::cout << " "; \
878	BoolToYesNo(mask.isIncluded(Class(A1B1))); \
879	std::cout << " "; \
880	BoolToYesNo(mask.isIncluded(Class(A1B2))); \
881	std::cout << " "; \
882	BoolToYesNo(mask.isIncluded(Class(A2B1))); \
883	std::cout << " "; \
884	BoolToYesNo(mask.isIncluded(Class(A2B2))); \
885	std::cout << " "; \
886	BoolToYesNo(mask.isIncluded(Class(A3B1))); \
887	std::cout << " "; \
888	BoolToYesNo(mask.isIncluded(Class(A3B2))); \
889	std::cout << std::endl; \
890	\
891	BoolToYesNo(mask.isIncluded(Class(A1B1C1))); \
892	BoolToYesNo(mask.isIncluded(Class(A1B1C2))); \
893	BoolToYesNo(mask.isIncluded(Class(A1B2C1))); \
894	std::cout << " "; \
895	BoolToYesNo(mask.isIncluded(Class(A2B1C1))); \
896	std::cout << " "; \
897	BoolToYesNo(mask.isIncluded(Class(A2B2C1))); \
898	std::cout << " "; \
899	BoolToYesNo(mask.isIncluded(Class(A3B1C1))); \
900	BoolToYesNo(mask.isIncluded(Class(A3B1C2))); \
901	BoolToYesNo(mask.isIncluded(Class(A3B2C1))); \
902	BoolToYesNo(mask.isIncluded(Class(A3B2C2))); \
903	std::cout << std::endl; \
904	std::cout << "=========================================" << std::endl
905
906	std::cout << "1\n";
907
908	ClassTreeMask test13_1;
909	test13_1.exclude(Class(A1B1));
910	test13_1.exclude(Class(A2));
911	test13_1.include(Class(A2B2));
912	test13_1.exclude(Class(A2B2C1));
913	test13_1.exclude(Class(A3B1));
914	test13_1.include(Class(A3B1C2));
915	test13_1.exclude(Class(A3B2C1));
916	test13_1.exclude(Class(A3B2C2));
917	std::cout << "Mask 1:\n";
918	TestClassTreeMask(test13_1);
919
920	ClassTreeMask test13_2;
921	test13_2.exclude(Class(BaseObject));
922	test13_2.include(Class(A1));
923	test13_2.exclude(Class(A1B2));
924	test13_2.exclude(Class(A1B1C2));
925	test13_2.include(Class(A2));
926	test13_2.exclude(Class(A2B2));
927	test13_2.include(Class(A3B1));
928	test13_2.include(Class(A3B2));
929	test13_2.exclude(Class(A3B2C2));
930	std::cout << std::endl;
931	std::cout << "Mask 2:\n";
932	TestClassTreeMask(test13_2);
933
934	std::cout << "2\n";
935
936	ClassTreeMask test13_3;
937	test13_3.include(Class(A1), true, false);
938	test13_3.exclude(Class(A1B2), true, false);
939	test13_3.exclude(Class(A1B1C2), true, false);
940	test13_3.include(Class(A2), true, false);
941	test13_3.exclude(Class(A2B2), true, false);
942	test13_3.include(Class(A3B1), true, false);
943	test13_3.include(Class(A3B2), true, false);
944	test13_3.exclude(Class(A3B2C2), true, false);
945	std::cout << std::endl;
946	std::cout << "Mask 2 without excluded BaseObject:\n";
947	TestClassTreeMask(test13_3);
948	test13_3.exclude(Class(BaseObject), false, false);
949	std::cout << std::endl;
950	std::cout << "Mask 2 with BaseObject excluded afterwards without overwrite:\n";
951	TestClassTreeMask(test13_3);
952	test13_3.exclude(Class(BaseObject), true);
953	std::cout << std::endl;
954	std::cout << "Mask 2 with BaseObject excluded afterwards with overwrite:\n";
955	TestClassTreeMask(test13_3);
956
957	ClassTreeMask test13_4;
958	test13_4.include(Class(A3B2));
959	test13_4.exclude(Class(A1B1C2));
960	test13_4.include(Class(A3B1));
961	test13_4.exclude(Class(A3B2C2));
962	test13_4.exclude(Class(BaseObject));
963	test13_4.include(Class(A2));
964	test13_4.exclude(Class(A1B2));
965	test13_4.exclude(Class(A2B2));
966	test13_4.include(Class(A1));
967	std::cout << std::endl;
968	std::cout << "Mask 2 created in random order with overwrite and clean:\n";
969	TestClassTreeMask(test13_4);
970
971	ClassTreeMask test13_4_2;
972	test13_4_2.include(Class(A3B2), false, false);
973	test13_4_2.exclude(Class(A1B1C2), false, false);
974	test13_4_2.include(Class(A3B1), false, false);
975	test13_4_2.exclude(Class(A3B2C2), false, false);
976	test13_4_2.exclude(Class(BaseObject), false, false);
977	test13_4_2.include(Class(A2), false, false);
978	test13_4_2.exclude(Class(A1B2), false, false);
979	test13_4_2.exclude(Class(A2B2), false, false);
980	test13_4_2.include(Class(A1), false, false);
981	std::cout << std::endl;
982	std::cout << "Mask 2 created in random order without overwrite and without clean:\n";
983	TestClassTreeMask(test13_4_2);
984
985	std::cout << "3\n";
986
987	ClassTreeMask test13_6 = !test13_1;
988	std::cout << std::endl;
989	std::cout << "Mask 1 inverted:\n";
990	TestClassTreeMask(test13_6);
991
992	std::cout << "4\n";
993
994	ClassTreeMask test13_7 = test13_1 + test13_2;
995	std::cout << std::endl;
996	std::cout << "Mask 1 + Mask 2:\n";
997	TestClassTreeMask(test13_7);
998
999	std::cout << "5\n";
1000
1001	ClassTreeMask test13_8 = test13_1 * test13_2;
1002	std::cout << std::endl;
1003	std::cout << "Mask 1 * Mask 2:\n";
1004	TestClassTreeMask(test13_8);
1005
1006	std::cout << "6\n";
1007
1008	ClassTreeMask test13_9 = test13_1 - test13_2;
1009	std::cout << std::endl;
1010	std::cout << "Mask 1 - Mask 2:\n";
1011	TestClassTreeMask(test13_9);
1012
1013	std::cout << "7\n";
1014
1015	ClassTreeMask test13_10 = test13_1 ^ test13_2;
1016	std::cout << std::endl;
1017	std::cout << "Mask 1 ^ Mask 2:\n";
1018	TestClassTreeMask(test13_10);
1019
1020	std::cout << "8\n";
1021
1022	ClassTreeMask test13_12(!test13_1);
1023	std::cout << std::endl;
1024	std::cout << "Mask 1 inverted assigned with copyconstructor + the original from before:\n";
1025	TestClassTreeMask(test13_12);
1026	TestClassTreeMask(test13_1);
1027
1028
1029	ClassTreeMask test13_13 = test13_1 + test13_2;
1030	std::cout << std::endl;
1031	std::cout << "Mask 1 + Mask 2 assigned with copyconstructor + originals from before:\n";
1032	TestClassTreeMask(test13_13);
1033	TestClassTreeMask(test13_1);
1034	TestClassTreeMask(test13_2);
1035
1036	ClassTreeMask test13_14 = test13_1;
1037	test13_14 += test13_2;
1038	std::cout << std::endl;
1039	std::cout << "Mask 1 + Mask 2 with += operator + original of mask 2 from before:\n";
1040	TestClassTreeMask(test13_14);
1041	TestClassTreeMask(test13_2);
1042
1043	test13_1 = test13_1;
1044	std::cout << std::endl;
1045	std::cout << "Mask 1 assigned with = operator to itself:\n";
1046	TestClassTreeMask(test13_1);
1047
1048	std::cout << "9\n";
1049
1050	ClassTreeMask test13_15;
1051	test13_15.exclude(Class(Interface1));
1052	std::cout << std::endl;
1053	std::cout << "Mask with excluded Interface 1:\n";
1054	TestClassTreeMask(test13_15);
1055
1056	ClassTreeMask test13_16 = test13_1;
1057	test13_16.exclude(Class(Interface1));
1058	std::cout << std::endl;
1059	std::cout << "Mask 1 with excluded Interface 1 (overwrite):\n";
1060	TestClassTreeMask(test13_16);
1061
1062	ClassTreeMask test13_17 = test13_1;
1063	test13_17.exclude(Class(Interface1), false);
1064	std::cout << std::endl;
1065	std::cout << "Mask 1 with excluded Interface 1 (without overwrite):\n";
1066	TestClassTreeMask(test13_17);
1067
1068	ClassTreeMask test13_18 = test13_2;
1069	test13_18.exclude(Class(Interface1), false);
1070	std::cout << std::endl;
1071	std::cout << "Mask 2 with excluded Interface 1 (without overwrite):\n";
1072	TestClassTreeMask(test13_18);
1073
1074	std::cout << "10\n";
1075
1076	ClassTreeMask test13_19;
1077	test13_19.exclude(Class(Test1));
1078	std::cout << std::endl;
1079	std::cout << "Mask with excluded Test1:\n";
1080	TestClassTreeMask(test13_19);
1081
1082	std::cout << "11\n";
1083
1084	ClassTreeMask test13_20;
1085	test13_20.exclude(Class(DebugLevel));
1086	std::cout << std::endl;
1087	std::cout << "Mask with excluded DebugLevel:\n";
1088	TestClassTreeMask(test13_20);
1089
1090	std::cout << "12\n";
1091
1092	ClassTreeMask test13_21;
1093	test13_21.excludeSingle(Class(A2));
1094	std::cout << std::endl;
1095	std::cout << "Mask with single-excluded A2:\n";
1096	TestClassTreeMask(test13_21);
1097
1098	test13_21.exclude(Class(A2));
1099	std::cout << std::endl;
1100	std::cout << "Mask with excluded A2:\n";
1101	TestClassTreeMask(test13_21);
1102
1103	test13_21.includeSingle(Class(A2));
1104	std::cout << std::endl;
1105	std::cout << "Previous mask with single-included A2:\n";
1106	TestClassTreeMask(test13_21);
1107
1108	test13_21.includeSingle(Class(A2), false);
1109	std::cout << std::endl;
1110	std::cout << "Previous mask with single-included A2 without clean:\n";
1111	TestClassTreeMask(test13_21);
1112
1113	std::cout << "13\n";
1114	*/
1115	/*
1116	std::cout << "Test 14\n";
1117	std::cout << "1\n";
1118
1119	SubclassIdentifier<A1> test14_1;
1120	test14_1 = Class(A1B1C1);
1121	std::cout << test14_1.getIdentifier()->getName() << std::endl;
1122
1123	SubclassIdentifier<A1> test14_2 = Class(A1B1C2);
1124	std::cout << test14_2.getIdentifier()->getName() << std::endl;
1125
1126	SubclassIdentifier<Interface1> test14_3;
1127	test14_3 = Class(A2B2C1);
1128	std::cout << test14_3.getIdentifier()->getName() << std::endl;
1129
1130	SubclassIdentifier<A1B2> test14_4;
1131	test14_4 = Class(A1B2C1);
1132	std::cout << test14_4.getIdentifier()->getName() << std::endl;
1133
1134	SubclassIdentifier<BaseObject> test14_5 = Class(Test1);
1135	std::cout << test14_5.getIdentifier()->getName() << std::endl;
1136
1137	std::cout << "2\n";
1138	*/
1139
1140	std::cout << "Test 15\n";
1141	std::cout << "1\n";
1142
1143	Level* test15_1 = new Level("levels/sample.oxw");
1144	Loader::open(test15_1);
1145
1146	std::cout << "2\n";
1147
1148	// startRenderLoop();
1149	}
1150
1151	/**
1152	* @return singleton object
1153	*/
1154	Orxonox* Orxonox::getSingleton()
1155	{
1156	if (!singletonRef_)
1157	singletonRef_ = new Orxonox();
1158	return singletonRef_;
1159	}
1160
1161	/**
1162	* error kills orxonox
1163	*/
1164	void Orxonox::die(/* some error code */)
1165	{
1166	//TODO: destroy and destruct everything and print nice error msg
1167	delete this;
1168	}
1169
1170	void Orxonox::standaloneInit(std::string path)
1171	{
1172	ogre_->setConfigPath(path);
1173	ogre_->setup();
1174	root_ = ogre_->getRoot();
1175	if(!ogre_->load()) die(/* unable to load */);
1176
1177	//defineResources();
1178	//setupRenderSystem();
1179	//createRenderWindow();
1180	//initializeResourceGroups();
1181	/*createScene();
1182	setupScene();
1183	setupInputSystem();
1184	createFrameListener();
1185	Factory::createClassHierarchy();
1186	startRenderLoop();*/
1187	}
1188
1189	void Orxonox::playableServer(std::string path)
1190	{
1191	ogre_->setConfigPath(path);
1192	ogre_->setup();
1193	root_ = ogre_->getRoot();
1194	defineResources();
1195	setupRenderSystem();
1196	createRenderWindow();
1197	initializeResourceGroups();
1198	setupInputSystem();
1199	Factory::createClassHierarchy();
1200	createScene();
1201	setupScene();
1202	createFrameListener();
1203	try{
1204	// server_g = new network::Server(); //!< add port and bindadress
1205	// server_g->open(); //!< open server and create listener thread
1206	// if(ogre_ && ogre_->getRoot())
1207	// ogre_->getRoot()->addFrameListener(new network::ServerFrameListener()); // adds a framelistener for the server
1208	COUT(3) << "Info: network framelistener added" << std::endl;
1209	}
1210	catch(...)
1211	{
1212	COUT(1) << "Error: There was a problem initialising the server :(" << std::endl;
1213	}
1214	startRenderLoop();
1215	}
1216
1217	void Orxonox::standalone(){
1218
1219
1220
1221	}
1222
1223	void Orxonox::serverInit(std::string path)
1224	{
1225	COUT(2) << "initialising server" << std::endl;
1226	ogre_->setConfigPath(path);
1227	ogre_->setup();
1228	// server_g = new network::Server(); // FIXME add some settings if wanted
1229	if(!ogre_->load()) die(/* unable to load */);
1230	// FIXME add network framelistener
1231	}
1232
1233	void Orxonox::clientInit(std::string path)
1234	{
1235	COUT(2) << "initialising client" << std::endl;
1236	ogre_->setConfigPath(path);
1237	ogre_->setup();
1238	/* if(serverIp_.compare("")==0)
1239	client_g = new network::Client();
1240	else
1241	client_g = new network::Client(serverIp_, 55556);*/
1242	if(!ogre_->load()) die(/* unable to load */);
1243	// ogre_->getRoot()->addFrameListener(new network::ClientFrameListener());
1244	}
1245
1246	void Orxonox::defineResources()
1247	{
1248	std::string secName, typeName, archName;
1249	Ogre::ConfigFile cf;
1250	#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
1251	cf.load(macBundlePath() + "/Contents/Resources/resources.cfg");
1252	#else
1253	cf.load(dataPath_ + "resources.cfg");
1254	#endif
1255
1256	Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
1257	while (seci.hasMoreElements())
1258	{
1259	secName = seci.peekNextKey();
1260	Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
1261	Ogre::ConfigFile::SettingsMultiMap::iterator i;
1262	for (i = settings->begin(); i != settings->end(); ++i)
1263	{
1264	typeName = i->first;
1265	archName = i->second;
1266	#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
1267	Ogre::ResourceGroupManager::getSingleton().addResourceLocation( std::string(macBundlePath() + "/" + archName), typeName, secName);
1268	#else
1269	Ogre::ResourceGroupManager::getSingleton().addResourceLocation( archName, typeName, secName);
1270	#endif
1271	}
1272	}
1273	}
1274
1275	void Orxonox::setupRenderSystem()
1276	{
1277	if (!root_->restoreConfig() && !root_->showConfigDialog())
1278	throw Ogre::Exception(52, "User canceled the config dialog!", "OrxApplication::setupRenderSystem()");
1279	}
1280
1281	void Orxonox::createRenderWindow()
1282	{
1283	root_->initialise(true, "OrxonoxV2");
1284	}
1285
1286	void Orxonox::initializeResourceGroups()
1287	{
1288	Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
1289	Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
1290	}
1291
1292	/**
1293	*
1294	* @param
1295	*/
1296	void Orxonox::createScene(void)
1297	{
1298	// Init audio
1299	// auMan_ = new audio::AudioManager();
1300
1301	// bulletMgr_ = new BulletManager();
1302
1303	// load this file from config
1304	// loader_ = new loader::LevelLoader("sample.oxw");
1305	// loader_->loadLevel();
1306
1307	// Ogre::Overlay* hudOverlay = Ogre::OverlayManager::getSingleton().getByName("Orxonox/HUD1.2");
1308	// HUD* orxonoxHud;
1309	// orxonoxHud = new HUD();
1310	// orxonoxHud->setEnergyValue(20);
1311	// orxonoxHud->setEnergyDistr(20,20,60);
1312	// hudOverlay->show();
1313
1314	/*
1315	auMan_->ambientAdd("a1");
1316	auMan_->ambientAdd("a2");
1317	auMan_->ambientAdd("a3");
1318	//auMan->ambientAdd("ambient1");
1319	auMan_->ambientStart();*/
1320	}
1321
1322
1323	/**
1324	*
1325	*/
1326	void Orxonox::setupScene()
1327	{
1328	// SceneManager *mgr = ogre_->getSceneManager();
1329
1330
1331	// SceneNode* node = (SceneNode*)mgr->getRootSceneNode()->getChild("OgreHeadNode");
1332	// SceneNode *node = mgr->getRootSceneNode()->createChildSceneNode("OgreHeadNode", Vector3(0,0,0));
1333
1334
1335	/*
1336	particle::ParticleInterface *e = new particle::ParticleInterface(mgr,"engine","Orxonox/strahl");
1337	e->particleSystem_->setParameter("local_space","true");
1338	e->setPositionOfEmitter(0, Vector3(0,-10,0));
1339	e->setDirection(Vector3(0,0,-1));
1340	e->addToSceneNode(node);
1341	*/
1342	}
1343
1344
1345	void Orxonox::setupInputSystem()
1346	{
1347	size_t windowHnd = 0;
1348	std::ostringstream windowHndStr;
1349	OIS::ParamList pl;
1350
1351	// fixes auto repeat problem
1352	#if defined OIS_LINUX_PLATFORM
1353	pl.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
1354	#endif
1355
1356	Ogre::RenderWindow *win = ogre_->getRoot()->getAutoCreatedWindow();
1357	win->getCustomAttribute("WINDOW", &windowHnd);
1358	windowHndStr << windowHnd;
1359	pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
1360	inputManager_ = OIS::InputManager::createInputSystem(pl);
1361
1362	try
1363	{
1364	keyboard_ = static_cast<OIS::Keyboard*>(inputManager_->createInputObject(OIS::OISKeyboard, false));
1365	mouse_ = static_cast<OIS::Mouse*>(inputManager_->createInputObject(OIS::OISMouse, true));
1366	}
1367	catch (const OIS::Exception &e)
1368	{
1369	throw new Ogre::Exception(42, e.eText, "OrxApplication::setupInputSystem");
1370	}
1371	}
1372
1373	// FIXME we actually want to do this differently...
1374	void Orxonox::createFrameListener()
1375	{
1376	TickFrameListener* TickFL = new TickFrameListener();
1377	ogre_->getRoot()->addFrameListener(TickFL);
1378
1379	TimerFrameListener* TimerFL = new TimerFrameListener();
1380	ogre_->getRoot()->addFrameListener(TimerFL);
1381
1382	//if(mode_!=CLIENT) // FIXME just a hack ------- remove this in future
1383	frameListener_ = new OrxListener(keyboard_/, auMan_/, mode_);
1384	ogre_->getRoot()->addFrameListener(frameListener_);
1385	}
1386
1387	void Orxonox::startRenderLoop()
1388	{
1389	// FIXME
1390	// this is a hack!!!
1391	// the call to reset the mouse clipping size should probably be somewhere
1392	// else, however this works for the moment.
1393	unsigned int width, height, depth;
1394	int left, top;
1395	ogre_->getRoot()->getAutoCreatedWindow()->getMetrics(width, height, depth, left, top);
1396
1397	if(mode_!=CLIENT){
1398	const OIS::MouseState &ms = mouse_->getMouseState();
1399	ms.width = width;
1400	ms.height = height;
1401	}
1402	ogre_->getRoot()->startRendering();
1403	}
1404	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: