1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 
9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 
37: 
38: 
39: 
40: 
41: 
42: 
43: 
44: 
45: 
46: 
47: 
48: 
49: 
50: 
51: 
52: 
53: 
54: 
55: 
56: 
57: 
58: 
59: 
60: 
61: 
62: 
63: 
64: 
65: 
66: 
67: 
68: 
69: 
70: 
71: 
72: 
73: 
74: 
75: 
76: 
77: 
78: 
79: 
80: 
81: 
82: 
83: 
84: 
85: 
86: 
87: 
88: 
89: 
90: 
91: 
92: 
93: 
94: 
95: 
96: 
97: 
98: 
99: 
100: 
101: 
102: 
103: 
104: 
105: 
106: 
107: 
108: 
109: 
110: 
111: 
112: 
113: 
114: 
115: 
116: 
117: 
118: 
119: 
120: 
121: 
122: 
123: 
124: 
125: 
126: 
127: 
128: 
129: 
130: 
131: 
132: 
133: 
134: 
135: 
136:

//es gibt ein feld.. 2 dimensionaler array..


show = function(){
	zw = "";
	for(k=0; k < feld.length; k++) {
		for(i=0; i < feld[0].length; i++) {
			zw = zw add feld[k][i];
		}
		trace(zw);
		zw = "";
	}
}

//ist eigentlich nur dazu da, um das feld anzuzeigen..
show();

//////////////
//überprüfung:
//////////////

//durchsucht den string "zw" nach "xxxx" oder "oooo" (x = spieler 1, o = spieler 2)..
//wenn dieser string gefunden wird (!=-1), dann gibt es also einen 4er.. -eigentlich
//könnte hier jetzt alles abgebrochen werden..

durchsuchen = function(){
	if(zw.indexOf("xxxx") != -1 || zw.indexOf("oooo") != -1){
		trace("Es hat jmd. eine 4er Reihe!");
	}
}

////////////
//waagerecht
////////////


//trace ist in flash sowas wie "ausgabe".. zum überprüfen von variablen oder ähnlichem..
trace("waagerecht");


//feld wird durchsucht, eine zeile bildet einen string, der mit "durchsuchen" überprüft wird
zw = "";
for(k=0; k < feld.length; k++) {
	for(i=0; i < feld[0].length; i++) {
		zw = zw add feld[k][i];
	}
	trace(zw)
	durchsuchen();
	zw = "";
}

///////////
//senkrecht
///////////


//eigentl. dasselbe wie bei waagerecht.. nur ist jetzt ein string eine spalte, und nicht eine reihe..

trace("senkrecht");
zw = "";
for(k=0; k < feld[0].length; k++) {
	for(i=0; i < feld.length; i++) {
		zw = zw add feld[i][k];
	}
	trace(zw)
	durchsuchen();
	zw = "";
}

/////////////////
//Diagonal nw->so
/////////////////

trace("Diagonal nw->so");


//beide diagonalen durchsuchungen, kann man bestimmt noch optimieren..
//x und y, stellen die start variablen dar.. es fängt somit links unten
//in der ecke mit dem ersten string an.. natürlich brauch man die ersten 3
//und die letzten 3 strings nicht beachten, da sie ja nichtmal 4 "einheiten"
//langs sind..
//der startwert, wandert sozusagen am anfang nach unten (k--), und wenn
//ka dann 0 ist, wandert der startwert nach rechts (x=math.abs(k))
//in der while schleife, kommt es zu der eigentlichen scrägen durchlaufung
//des feldes (x++; y++;)

zw = "";
for(k=feld.length-1; math.abs(k) <= feld.length; k--) {
		if(k==0){
			x = math.abs(k)
			y = 0;
		}else{
			x = 0;
			y = k;
		}
		while(y < feld.length && x < feld[0].length) {
			zw = zw add feld[y][x];
			x++;
			y++;
		}
		trace(+zw);
		durchsuchen();
		zw = "";
}

/////////////////
//Diagonal sw->no
/////////////////

trace("Diagonal sw->no");

//wie vorher, nur das nun der startwert unten rechts ist, er "wandert"
//dann nach oben, und dann nach links..

zw = "";
for(k=feld.length-1; math.abs(k) <= feld.length; k--) {
	if(k<0){
		//trace("123")
		x = feld.length-math.abs(k);
		y = 0;
	}else{
		x = feld.length;
		y = math.abs(k);
	}
	//trace(x+","+y);
	while(y < feld.length && x >= 0) {
		zw = zw add feld[y][x];
		x--;
		y++;
	}
	trace(zw);
	durchsuchen();
	zw = "";
}