Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/branches/minigame4DHS14/src/modules/mini4Dgame/Mini4DgameBoard.cc @ 10156

Last change on this file since 10156 was 10156, checked in by richtero, 9 years ago
getting closer to a playable version
File size: 23.4 KB

Line
1	/*
2	* ORXONOX - the hottest 3D action shooter ever to exist
3	* > www.orxonox.net <
4	*
5	*
6	* License notice:
7	*
8	* This program is free software; you can redistribute it and/or
9	* modify it under the terms of the GNU General Public License
10	* as published by the Free Software Foundation; either version 2
11	* of the License, or (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21	*
22	* Author:
23	* Fabian 'x3n' Landau
24	* Co-authors:
25	* ...
26	*
27	*/
28
29	/**
30	@file PongBall.cc
31	@brief Implementation of the PongBall class.
32	*/
33
34	#include "Mini4DgameBoard.h"
35
36	#include "core/CoreIncludes.h"
37	#include "core/GameMode.h"
38
39	#include "gametypes/Gametype.h"
40	#include "graphics/BlinkingBillboard.h"
41
42	#include "core/XMLPort.h"
43
44	#include "Mini4Dgame.h"
45
46	namespace orxonox
47	{
48	RegisterClass(Mini4DgameBoard);
49
50	/**
51	@brief
52	Constructor. Registers and initializes the object.
53	*/
54	Mini4DgameBoard::Mini4DgameBoard(Context* context) : StaticEntity(context)
55	{
56	RegisterObject(Mini4DgameBoard);
57
58	//this->registerVariables();
59
60	//initialize board
61	for(int i=0;i<4;i++){
62	for(int j=0;j<4;j++){
63	for(int k=0;k<4;k++){
64	for(int l=0;l<4;l++){
65	this->board[i][j][k][l]=mini4DgamePlayerColor::none;
66	}
67	}
68	}
69	}
70
71	this->checkGametype();
72	}
73
74	/**
75	@brief
76	Destructor.
77	*/
78	Mini4DgameBoard::~Mini4DgameBoard()
79	{
80	if (this->isInitialized())
81	{
82
83	}
84	}
85
86	//xml port for loading sounds
87	void Mini4DgameBoard::XMLPort(Element& xmlelement, XMLPort::Mode mode)
88	{
89	SUPER(Mini4DgameBoard, XMLPort, xmlelement, mode);
90	}
91
92	/**
93	@brief
94	Register variables to synchronize over the network.
95
96	void Mini4DgameBoard::registerVariables()
97	{
98	registerVariable( this->fieldWidth_ );
99	registerVariable( this->fieldHeight_ );
100	registerVariable( this->batlength_ );
101	registerVariable( this->speed_ );
102	registerVariable( this->relMercyOffset_ );
103	registerVariable( this->batID_[0] );
104	registerVariable( this->batID_[1], VariableDirection::ToClient, new NetworkCallback<PongBall>( this, &PongBall::applyBats) );
105	}
106	*/
107
108	/**
109	@brief checks if the move is valid
110	@param the position where to put the stone plus the player who makes the move
111	*/
112	bool Mini4DgameBoard::isValidMove(const Vector4 move)
113	{
114	return (this->board[(int)move.x][(int)move.y][(int)move.z][(int)move.w] == mini4DgamePlayerColor::none);
115	}
116
117
118
119	/**
120	@brief makes a move on the logic playboard
121	@param the position where to put the stone plus the player who makes the move
122	*/
123	void Mini4DgameBoard::makeMove(const Vector4 move, const int playerColor)
124	{
125	if(this->isValidMove(move))
126	{
127	this->board[(int)move.x][(int)move.y][(int)move.z][(int)move.w] = (mini4DgamePlayerColor::color) playerColor;
128	BlinkingBillboard* bb = new BlinkingBillboard(this->getContext());
129	orxout(user_status) << "Mini4Dgame: move.x " << move.x << endl;
130
131	bb->setPosition(60(int)move.x-90,60(int)move.y-90,60*(int)move.z-90);
132	bb->setFrequency(0.6);
133	bb->setAmplitude(0.1);
134	//bb->setMaterial("Flares/lensflare");
135	bb->setMaterial("Numbers/One");
136	bb->setColour(ColourValue(0,1,0));
137
138	this->attach(bb);
139
140
141	Mini4DgameWinner winner = this->getWinner();
142	if(winner.color_ != mini4DgamePlayerColor::none)
143	{
144	orxout(user_status) << "Mini4Dgame: win!!!!!!!" << endl;
145	//win(winner);
146	}
147	}
148	}
149
150	Mini4DgameWinner Mini4DgameBoard::getWinner()
151	{
152	Mini4DgameWinner winner;
153	winner.color_ = mini4DgamePlayerColor::none;
154
155	//check diagonals rows-columns-height-numbers
156	for(int i=1; i<4; i++)
157	{
158	if(this->board[i][i][i][i]==mini4DgamePlayerColor::none \|\| this->board[0][0][0][0] != this->board[i][i][i][i])
159	break;
160	if(i==3)
161	{
162	winner.color_ = this->board[0][0][0][0];
163	for(int x=0; x<4; x++){
164	winner.winningRow[x] = x;
165	winner.winningColumn[x] = x;
166	winner.winningHeight[x] = x;
167	winner.winningNumber[x] = x;
168	}
169	return winner;
170	}
171	}
172	for(int i=1; i<4; i++)
173	{
174	if(this->board[3-i][i][i][i]==mini4DgamePlayerColor::none \|\| this->board[3][0][0][0] != this->board[3-i][i][i][i])
175	break;
176	if(i==3)
177	{
178	winner.color_ = this->board[3][0][0][0];
179	for(int x=0; x<4; x++){
180	winner.winningRow[x] = 3-x;
181	winner.winningColumn[x] = x;
182	winner.winningHeight[x] = x;
183	winner.winningNumber[x] = x;
184	}
185	return winner;
186	}
187	}
188	for(int i=1; i<4; i++)
189	{
190	if(this->board[i][3-i][i][i]==mini4DgamePlayerColor::none \|\| this->board[0][3][0][0] != this->board[i][3-i][i][i])
191	break;
192	if(i==3)
193	{
194	winner.color_ = this->board[0][3][0][0];
195	for(int x=0; x<4; x++){
196	winner.winningRow[x] = x;
197	winner.winningColumn[x] = 3-x;
198	winner.winningHeight[x] = x;
199	winner.winningNumber[x] = x;
200	}
201	return winner;
202	}
203	}
204	for(int i=1; i<4; i++)
205	{
206	if(this->board[i][i][3-i][i]==mini4DgamePlayerColor::none \|\| this->board[0][0][3][0] != this->board[i][i][3-i][i])
207	break;
208	if(i==3)
209	{
210	winner.color_ = this->board[0][0][3][0];
211	for(int x=0; x<4; x++){
212	winner.winningRow[x] = x;
213	winner.winningColumn[x] = x;
214	winner.winningHeight[x] = 3-x;
215	winner.winningNumber[x] = x;
216	}
217	return winner;
218	}
219	}
220	for(int i=1; i<4; i++)
221	{
222	if(this->board[i][i][i][3-i]==mini4DgamePlayerColor::none \|\| this->board[0][0][0][3] != this->board[i][i][i][3-i])
223	break;
224	if(i==3)
225	{
226	winner.color_ = this->board[0][0][0][3];
227	for(int x=0; x<4; x++){
228	winner.winningRow[x] = x;
229	winner.winningColumn[x] = x;
230	winner.winningHeight[x] = x;
231	winner.winningNumber[x] = 3-x;
232	}
233	return winner;
234	}
235	}
236	for(int i=1; i<4; i++)
237	{
238	if(this->board[3-i][3-i][i][i]==mini4DgamePlayerColor::none \|\| this->board[3][3][0][0] != this->board[3-i][3-i][i][i])
239	break;
240	if(i==3)
241	{
242	winner.color_ = this->board[3][3][0][0];
243	for(int x=0; x<4; x++){
244	winner.winningRow[x] = 3-x;
245	winner.winningColumn[x] = 3-x;
246	winner.winningHeight[x] = x;
247	winner.winningNumber[x] = x;
248	}
249	return winner;
250	}
251	}
252	for(int i=1; i<4; i++)
253	{
254	if(this->board[3-i][i][3-i][i]==mini4DgamePlayerColor::none \|\| this->board[3][0][3][0] != this->board[3-i][i][3-i][i])
255	break;
256	if(i==3)
257	{
258	winner.color_ = this->board[3][0][3][0];
259	for(int x=0; x<4; x++){
260	winner.winningRow[x] = 3-x;
261	winner.winningColumn[x] = x;
262	winner.winningHeight[x] = 3-x;
263	winner.winningNumber[x] = x;
264	}
265	return winner;
266	}
267	}
268	for(int i=1; i<4; i++)
269	{
270	if(this->board[3-i][i][i][3-i]==mini4DgamePlayerColor::none \|\| this->board[3][0][0][3] != this->board[3-i][i][i][3-i])
271	break;
272	if(i==3)
273	{
274	winner.color_ = this->board[3][0][0][3];
275	for(int x=0; x<4; x++){
276	winner.winningRow[x] = 3-x;
277	winner.winningColumn[x] = x;
278	winner.winningHeight[x] = x;
279	winner.winningNumber[x] = 3-x;
280	}
281	return winner;
282	}
283	}
284
285	//check diagonals rows-columns-height
286	for(int l=0; l<4; l++)
287	{
288	for(int i=1; i<4; i++)
289	{
290	if(this->board[i][i][i][l]==mini4DgamePlayerColor::none \|\| this->board[0][0][0][l] != this->board[i][i][i][l])
291	break;
292	if(i==3)
293	{
294	winner.color_ = this->board[0][0][0][l];
295	for(int x=0; x<4; x++){
296	winner.winningRow[x] = x;
297	winner.winningColumn[x] = x;
298	winner.winningHeight[x] = x;
299	winner.winningNumber[x] = l;
300	}
301	return winner;
302	}
303	}
304	for(int i=1; i<4; i++)
305	{
306	if(this->board[3-i][i][i][l]==mini4DgamePlayerColor::none \|\| this->board[3][0][0][l] != this->board[3-i][i][i][l])
307	break;
308	if(i==3)
309	{
310	winner.color_ = this->board[3][0][0][l];
311	for(int x=0; x<4; x++){
312	winner.winningRow[x] = 3-x;
313	winner.winningColumn[x] = x;
314	winner.winningHeight[x] = x;
315	winner.winningNumber[x] = l;
316	}
317	return winner;
318	}
319	}
320	for(int i=1; i<4; i++)
321	{
322	if(this->board[i][3-i][i][l]==mini4DgamePlayerColor::none \|\| this->board[0][3][0][l] != this->board[i][3-i][i][l])
323	break;
324	if(i==3)
325	{
326	winner.color_ = this->board[0][3][0][l];
327	for(int x=0; x<4; x++){
328	winner.winningRow[x] = x;
329	winner.winningColumn[x] = 3-x;
330	winner.winningHeight[x] = x;
331	winner.winningNumber[x] = l;
332	}
333	return winner;
334	}
335	}
336	for(int i=1; i<4; i++)
337	{
338	if(this->board[i][i][3-i][l]==mini4DgamePlayerColor::none \|\| this->board[0][0][3][l] != this->board[i][i][3-i][l])
339	break;
340	if(i==3)
341	{
342	winner.color_ = this->board[0][0][3][l];
343	for(int x=0; x<4; x++){
344	winner.winningRow[x] = x;
345	winner.winningColumn[x] = x;
346	winner.winningHeight[x] = 3-x;
347	winner.winningNumber[x] = l;
348	}
349	return winner;
350	}
351	}
352	}
353
354	//check diagonals rows-columns-numbers
355	for(int l=0; l<4; l++)
356	{
357	for(int i=1; i<4; i++)
358	{
359	if(this->board[i][i][l][i]==mini4DgamePlayerColor::none \|\| this->board[0][0][l][0] != this->board[i][i][l][i])
360	break;
361	if(i==3)
362	{
363	winner.color_ = this->board[0][0][l][0];
364	for(int x=0; x<4; x++){
365	winner.winningRow[x] = x;
366	winner.winningColumn[x] = x;
367	winner.winningHeight[x] = l;
368	winner.winningNumber[x] = x;
369	}
370	return winner;
371	}
372	}
373	for(int i=1; i<4; i++)
374	{
375	if(this->board[3-i][i][l][i]==mini4DgamePlayerColor::none \|\| this->board[3][0][l][0] != this->board[3-i][i][l][i])
376	break;
377	if(i==3)
378	{
379	winner.color_ = this->board[3][0][l][0];
380	for(int x=0; x<4; x++){
381	winner.winningRow[x] = 3-x;
382	winner.winningColumn[x] = x;
383	winner.winningHeight[x] = l;
384	winner.winningNumber[x] = x;
385	}
386	return winner;
387	}
388	}
389	for(int i=1; i<4; i++)
390	{
391	if(this->board[i][3-i][l][i]==mini4DgamePlayerColor::none \|\| this->board[0][3][l][0] != this->board[i][3-i][l][i])
392	break;
393	if(i==3)
394	{
395	winner.color_ = this->board[0][3][l][0];
396	for(int x=0; x<4; x++){
397	winner.winningRow[x] = x;
398	winner.winningColumn[x] = 3-x;
399	winner.winningHeight[x] = l;
400	winner.winningNumber[x] = x;
401	}
402	return winner;
403	}
404	}
405	for(int i=1; i<4; i++)
406	{
407	if(this->board[i][i][l][3-i]==mini4DgamePlayerColor::none \|\| this->board[0][0][l][3] != this->board[i][i][l][3-i])
408	break;
409	if(i==3)
410	{
411	winner.color_ = this->board[0][0][l][3];
412	for(int x=0; x<4; x++){
413	winner.winningRow[x] = x;
414	winner.winningColumn[x] = x;
415	winner.winningHeight[x] = l;
416	winner.winningNumber[x] = 3-x;
417	}
418	return winner;
419	}
420	}
421	}
422
423	//check diagonals rows-height-numbers
424	for(int l=0; l<4; l++)
425	{
426	for(int i=1; i<4; i++)
427	{
428	if(this->board[i][l][i][i]==mini4DgamePlayerColor::none \|\| this->board[0][l][0][0] != this->board[i][l][i][i])
429	break;
430	if(i==3)
431	{
432	winner.color_ = this->board[0][l][0][0];
433	for(int x=0; x<4; x++){
434	winner.winningRow[x] = x;
435	winner.winningColumn[x] = l;
436	winner.winningHeight[x] = x;
437	winner.winningNumber[x] = x;
438	}
439	return winner;
440	}
441	}
442	for(int i=1; i<4; i++)
443	{
444	if(this->board[3-i][l][i][i]==mini4DgamePlayerColor::none \|\| this->board[3][l][0][0] != this->board[3-i][l][i][i])
445	break;
446	if(i==3)
447	{
448	winner.color_ = this->board[3][l][0][0];
449	for(int x=0; x<4; x++){
450	winner.winningRow[x] = 3-x;
451	winner.winningColumn[x] = l;
452	winner.winningHeight[x] = x;
453	winner.winningNumber[x] = x;
454	}
455	return winner;
456	}
457	}
458	for(int i=1; i<4; i++)
459	{
460	if(this->board[i][l][3-i][i]==mini4DgamePlayerColor::none \|\| this->board[0][l][3][0] != this->board[i][l][3-i][i])
461	break;
462	if(i==3)
463	{
464	winner.color_ = this->board[0][l][3][0];
465	for(int x=0; x<4; x++){
466	winner.winningRow[x] = x;
467	winner.winningColumn[x] = l;
468	winner.winningHeight[x] = 3-x;
469	winner.winningNumber[x] = x;
470	}
471	return winner;
472	}
473	}
474	for(int i=1; i<4; i++)
475	{
476	if(this->board[i][l][i][3-i]==mini4DgamePlayerColor::none \|\| this->board[0][l][0][3] != this->board[i][l][i][3-i])
477	break;
478	if(i==3)
479	{
480	winner.color_ = this->board[0][l][0][3];
481	for(int x=0; x<4; x++){
482	winner.winningRow[x] = x;
483	winner.winningColumn[x] = l;
484	winner.winningHeight[x] = x;
485	winner.winningNumber[x] = 3-x;
486	}
487	return winner;
488	}
489	}
490	}
491
492	//check diagonals columns-height-numbers
493	for(int l=0; l<4; l++)
494	{
495	for(int i=1; i<4; i++)
496	{
497	if(this->board[l][i][i][i]==mini4DgamePlayerColor::none \|\| this->board[l][0][0][0] != this->board[l][i][i][i])
498	break;
499	if(i==3)
500	{
501	winner.color_ = this->board[l][0][0][0];
502	for(int x=0; x<4; x++){
503	winner.winningRow[x] = l;
504	winner.winningColumn[x] = x;
505	winner.winningHeight[x] = x;
506	winner.winningNumber[x] = x;
507	}
508	return winner;
509	}
510	}
511	for(int i=1; i<4; i++)
512	{
513	if(this->board[l][3-i][i][i]==mini4DgamePlayerColor::none \|\| this->board[l][3][0][0] != this->board[l][3-i][i][i])
514	break;
515	if(i==3)
516	{
517	winner.color_ = this->board[l][3][0][0];
518	for(int x=0; x<4; x++){
519	winner.winningRow[x] = l;
520	winner.winningColumn[x] = 3-x;
521	winner.winningHeight[x] = x;
522	winner.winningNumber[x] = x;
523	}
524	return winner;
525	}
526	}
527	for(int i=1; i<4; i++)
528	{
529	if(this->board[l][i][3-i][i]==mini4DgamePlayerColor::none \|\| this->board[l][0][3][0] != this->board[l][i][3-i][i])
530	break;
531	if(i==3)
532	{
533	winner.color_ = this->board[l][0][3][0];
534	for(int x=0; x<4; x++){
535	winner.winningRow[x] = l;
536	winner.winningColumn[x] = x;
537	winner.winningHeight[x] = 3-x;
538	winner.winningNumber[x] = x;
539	}
540	return winner;
541	}
542	}
543	for(int i=1; i<4; i++)
544	{
545	if(this->board[l][i][i][3-i]==mini4DgamePlayerColor::none \|\| this->board[l][0][0][3] != this->board[l][i][i][3-i])
546	break;
547	if(i==3)
548	{
549	winner.color_ = this->board[l][0][0][3];
550	for(int x=0; x<4; x++){
551	winner.winningRow[x] = l;
552	winner.winningColumn[x] = x;
553	winner.winningHeight[x] = x;
554	winner.winningNumber[x] = 3-x;
555	}
556	return winner;
557	}
558	}
559	}
560
561	//check 2d diagonals
562	for(int k=0;k<4;k++){
563	for(int l=0;l<4;l++){
564	//rows-columns
565	for(int i=1; i<4; i++)
566	{
567	if(this->board[i][i][k][l]==mini4DgamePlayerColor::none \|\| this->board[0][0][k][l] != this->board[i][i][k][l])
568	break;
569	if(i==3)
570	{
571	winner.color_ = this->board[0][0][k][l];
572	for(int x=0; x<4; x++){
573	winner.winningRow[x] = x;
574	winner.winningColumn[x] = x;
575	winner.winningHeight[x] = k;
576	winner.winningNumber[x] = l;
577	}
578	return winner;
579	}
580	}
581	for(int i=1; i<4; i++)
582	{
583	if(this->board[3-i][i][k][l]==mini4DgamePlayerColor::none \|\| this->board[3][0][k][l] != this->board[3-i][i][k][l])
584	break;
585	if(i==3)
586	{
587	winner.color_ = this->board[3][0][k][l];
588	for(int x=0; x<4; x++){
589	winner.winningRow[x] = 3-x;
590	winner.winningColumn[x] = x;
591	winner.winningHeight[x] = k;
592	winner.winningNumber[x] = l;
593	}
594	return winner;
595	}
596	}
597	//rows-height
598	for(int i=1; i<4; i++)
599	{
600	if(this->board[i][k][i][l]==mini4DgamePlayerColor::none \|\| this->board[0][k][0][l] != this->board[i][k][i][l])
601	break;
602	if(i==3)
603	{
604	winner.color_ = this->board[0][k][0][l];
605	for(int x=0; x<4; x++){
606	winner.winningRow[x] = x;
607	winner.winningColumn[x] = k;
608	winner.winningHeight[x] = x;
609	winner.winningNumber[x] = l;
610	}
611	return winner;
612	}
613	}
614	for(int i=1; i<4; i++)
615	{
616	if(this->board[3-i][k][i][l]==mini4DgamePlayerColor::none \|\| this->board[3][k][0][l] != this->board[3-i][k][i][l])
617	break;
618	if(i==3)
619	{
620	winner.color_ = this->board[3][k][0][l];
621	for(int x=0; x<4; x++){
622	winner.winningRow[x] = 3-x;
623	winner.winningColumn[x] = k;
624	winner.winningHeight[x] = x;
625	winner.winningNumber[x] = l;
626	}
627	return winner;
628	}
629	}
630	//rows-numbers
631	for(int i=1; i<4; i++)
632	{
633	if(this->board[i][k][l][i]==mini4DgamePlayerColor::none \|\| this->board[0][k][l][0] != this->board[i][k][l][i])
634	break;
635	if(i==3)
636	{
637	winner.color_ = this->board[0][k][l][0];
638	for(int x=0; x<4; x++){
639	winner.winningRow[x] = x;
640	winner.winningColumn[x] = k;
641	winner.winningHeight[x] = l;
642	winner.winningNumber[x] = x;
643	}
644	return winner;
645	}
646	}
647	for(int i=1; i<4; i++)
648	{
649	if(this->board[3-i][k][l][i]==mini4DgamePlayerColor::none \|\| this->board[3][k][l][0] != this->board[3-i][k][l][i])
650	break;
651	if(i==3)
652	{
653	winner.color_ = this->board[3][k][l][0];
654	for(int x=0; x<4; x++){
655	winner.winningRow[x] = 3-x;
656	winner.winningColumn[x] = k;
657	winner.winningHeight[x] = l;
658	winner.winningNumber[x] = x;
659	}
660	return winner;
661	}
662	}
663	//column-height
664	for(int i=1; i<4; i++)
665	{
666	if(this->board[k][i][i][l]==mini4DgamePlayerColor::none \|\| this->board[k][0][0][l] != this->board[k][i][i][l])
667	break;
668	if(i==3)
669	{
670	winner.color_ = this->board[k][0][0][l];
671	for(int x=0; x<4; x++){
672	winner.winningRow[x] = k;
673	winner.winningColumn[x] = x;
674	winner.winningHeight[x] = x;
675	winner.winningNumber[x] = l;
676	}
677	return winner;
678	}
679	}
680	for(int i=1; i<4; i++)
681	{
682	if(this->board[k][3-i][i][l]==mini4DgamePlayerColor::none \|\| this->board[k][3][0][l] != this->board[k][3-i][i][l])
683	break;
684	if(i==3)
685	{
686	winner.color_ = this->board[k][3][0][l];
687	for(int x=0; x<4; x++){
688	winner.winningRow[x] = k;
689	winner.winningColumn[x] = 3-x;
690	winner.winningHeight[x] = x;
691	winner.winningNumber[x] = l;
692	}
693	return winner;
694	}
695	}
696	//column-numbers
697	for(int i=1; i<4; i++)
698	{
699	if(this->board[k][i][l][i]==mini4DgamePlayerColor::none \|\| this->board[k][0][l][0] != this->board[k][i][l][i])
700	break;
701	if(i==3)
702	{
703	winner.color_ = this->board[k][0][l][0];
704	for(int x=0; x<4; x++){
705	winner.winningRow[x] = k;
706	winner.winningColumn[x] = x;
707	winner.winningHeight[x] = l;
708	winner.winningNumber[x] = x;
709	}
710	return winner;
711	}
712	}
713	for(int i=1; i<4; i++)
714	{
715	if(this->board[k][3-i][l][i]==mini4DgamePlayerColor::none \|\| this->board[k][3][l][0] != this->board[k][3-i][l][i])
716	break;
717	if(i==3)
718	{
719	winner.color_ = this->board[k][3][l][0];
720	for(int x=0; x<4; x++){
721	winner.winningRow[x] = k;
722	winner.winningColumn[x] = 3-x;
723	winner.winningHeight[x] = l;
724	winner.winningNumber[x] = x;
725	}
726	return winner;
727	}
728	}
729	//height-numbers
730	for(int i=1; i<4; i++)
731	{
732	if(this->board[k][l][i][i]==mini4DgamePlayerColor::none \|\| this->board[k][l][0][0] != this->board[k][l][i][i])
733	break;
734	if(i==3)
735	{
736	winner.color_ = this->board[k][l][0][0];
737	for(int x=0; x<4; x++){
738	winner.winningRow[x] = k;
739	winner.winningColumn[x] = l;
740	winner.winningHeight[x] = x;
741	winner.winningNumber[x] = x;
742	}
743	return winner;
744	}
745	}
746	for(int i=1; i<4; i++)
747	{
748	if(this->board[k][l][3-i][i]==mini4DgamePlayerColor::none \|\| this->board[k][l][3][0] != this->board[k][l][3-i][i])
749	break;
750	if(i==3)
751	{
752	winner.color_ = this->board[k][l][3][0];
753	for(int x=0; x<4; x++){
754	winner.winningRow[x] = k;
755	winner.winningColumn[x] = l;
756	winner.winningHeight[x] = 3-x;
757	winner.winningNumber[x] = x;
758	}
759	return winner;
760	}
761	}
762	}
763	}
764
765	//check rows
766	for(int j=0;j<4;j++){
767	for(int k=0;k<4;k++){
768	for(int l=0;l<4;l++){
769	if(this->board[0][j][k][l]!= mini4DgamePlayerColor::none
770	&& this->board[0][j][k][l]==this->board[1][j][k][l]
771	&& this->board[1][j][k][l]==this->board[2][j][k][l]
772	&& this->board[2][j][k][l]==this->board[3][j][k][l])
773	{
774	winner.color_ = this->board[0][j][k][l];
775	for(int x=0; x<4; x++){
776	winner.winningRow[x] = x;
777	winner.winningColumn[x] = j;
778	winner.winningHeight[x] = k;
779	winner.winningNumber[x] = l;
780	}
781	return winner;
782	}
783	}
784	}
785	}
786
787	//check columns
788	for(int i=0;i<4;i++){
789	for(int k=0;k<4;k++){
790	for(int l=0;l<4;l++){
791	if(this->board[i][0][k][l]!= mini4DgamePlayerColor::none
792	&& this->board[i][0][k][l]==this->board[i][1][k][l]
793	&& this->board[i][1][k][l]==this->board[i][2][k][l]
794	&& this->board[i][2][k][l]==this->board[i][3][k][l])
795	{
796	winner.color_ = this->board[i][0][k][l];
797	for(int x=0; x<4; x++){
798	winner.winningRow[x] = i;
799	winner.winningColumn[x] = x;
800	winner.winningHeight[x] = k;
801	winner.winningNumber[x] = l;
802	}
803	return winner;
804	}
805	}
806	}
807	}
808
809	//check height
810	for(int i=0;i<4;i++){
811	for(int j=0;j<4;j++){
812	for(int l=0;l<4;l++){
813	if(this->board[i][j][0][l]!= mini4DgamePlayerColor::none
814	&& this->board[i][j][0][l]==this->board[i][j][1][l]
815	&& this->board[i][j][1][l]==this->board[i][j][2][l]
816	&& this->board[i][j][2][l]==this->board[i][j][3][l])
817	{
818	winner.color_ = this->board[i][j][0][l];
819	for(int x=0; x<4; x++){
820	winner.winningRow[x] = i;
821	winner.winningColumn[x] = j;
822	winner.winningHeight[x] = x;
823	winner.winningNumber[x] = l;
824	}
825	return winner;
826	}
827	}
828	}
829	}
830
831	//check numbers
832	for(int i=0;i<4;i++){
833	for(int j=0;j<4;j++){
834	for(int k=0;k<4;k++){
835	if(this->board[i][j][k][0]!= mini4DgamePlayerColor::none
836	&& this->board[i][j][k][0]==this->board[i][j][k][1]
837	&& this->board[i][j][k][1]==this->board[i][j][k][2]
838	&& this->board[i][j][k][2]==this->board[i][j][k][3])
839	{
840	winner.color_ = this->board[i][j][k][0];
841	for(int x=0; x<4; x++){
842	winner.winningRow[x] = i;
843	winner.winningColumn[x] = j;
844	winner.winningHeight[x] = k;
845	winner.winningNumber[x] = x;
846	}
847	return winner;
848	}
849	}
850	}
851	}
852	return winner;
853	}
854
855	/**
856	@brief
857	Is called when the gametype has changed.
858	*/
859	void Mini4DgameBoard::changedGametype()
860	{
861	SUPER(Mini4DgameBoard, changedGametype);
862
863	// Check, whether it's still Mini4Dgame.
864	this->checkGametype();
865	}
866
867	/**
868	@brief
869	Checks whether the gametype is Mini4Dgame and if it is, sets its centerpoint.
870	*/
871	void Mini4DgameBoard::checkGametype()
872	{
873	if (this->getGametype() != NULL && this->getGametype()->isA(Class(Mini4Dgame)))
874	{
875	Mini4Dgame* Mini4DgameGametype = orxonox_cast<Mini4Dgame*>(this->getGametype().get());
876	Mini4DgameGametype->setGameboard(this);
877	}
878	}
879	}

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

Download in other formats: