Context Navigation

Orxonox.cc @ 817

Last change on this file since 817 was 817, checked in by landauf, 16 years ago

big update:

reimplemented direct-child and direct-parent list and several related functions (get-iterator, get-list)
reimplemented isDirectChildOf- and isDirectParentOf-functions in Identifier, SubclassIdentifier and OrxonoxClass
renamed isDirectlyA to isExactlyA in Identifier, SubclassIdentifier and OrxonoxClass

ClassTreeMask works now with interfaces and has more possibilities (parameters for overwriting of previous rules and cleaning after adding a new function)

ObjectList's begin() and end() functions use ClassManager to avoid problems with libraries
the Factory got functions to return begin() and end() iterator for the identifier-map
overloaded << operator to put identifier-lists on the stream

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

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

Context Navigation

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

Download in other formats: