Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

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

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

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

Download in other formats: