Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/branches/core2/src/orxonox/Orxonox.cc @ 995

Last change on this file since 995 was 993, checked in by landauf, 17 years ago

added exit command: quits orxonox (no, it's not a hidden segfault )
added exec command: executes files (that contain other commands)

funny: use the log function to write commands into orxonox.log and then use 'exec orxonox.log' - it works. I've even added a recursion-blocker to avoid an (almost) endless loop after logging 'exec orxonox.log'

I'm currently thinking about more complex commands (what about delayed commands? or commands with returnvalue and a pipeline symbol?).

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

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

Download in other formats: