/*********************************/
/* MatrixGenerator für ShadowRun */
/* written by Thomas Reinhardt   */
/*                               */
/* Spezielle Funktionen Matrix   */
/*********************************/
#include <time.h>
#include <math.h>
#include <string.h>
#include <exec/interrupts.h>
#include <exec/libraries.h>
#include <exec/lists.h>
#include <exec/memory.h>
#include <exec/nodes.h>
#include <exec/ports.h>
#include <exec/types.h>
#include <intuition/intuition.h>
#include <libraries/dos.h>
#include <libraries/dosextens.h>
#include <proto/dos.h>
#include <proto/exec.h>
#include <proto/graphics.h>
#include <proto/intuition.h>
#include <proto/gadtools.h>
#include <proto/diskfont.h>
#include <stdio.h>
#include <stdlib.h>

#include "MatrixGen.h"
#include "all.h"

extern LONG SaveNamePointer;
extern struct IntuitionBase *IntuitionBase;
extern struct GfxBase *GfxBase;
extern struct Library *DosBase;
extern struct NewScreen MyNewScreen;
extern struct Screen *MyScreen;
extern struct BitMapHeader BMHD;
extern struct ColorRegister Colors[16];
extern struct CommodoreAmiga CAMG;
extern LONG Len,xi,yi,b;
extern ULONG ChunkLen;
extern char *WohinDamit;
extern char GfxName[255];
extern char StatusName[255];
extern char StandardName[255];
extern char DatenFeld[255];
extern BOOL success,AllDone;
extern int i;
extern char inread[5];
extern int cBitmaps,AnzahlKnoten,AusgangsKnoten,AnzahlWichtigeDaten,Stufenwert;
extern int MaxSAN,AusgangsWichtigeDaten;
extern UBYTE xPos,yPos,MaxFarben,Language,OutputType;
extern struct MatrixKomponenten Matrix[12*12];
extern struct MatrixGenType MatrixDatas[1];
extern BOOL CPUInSystem,Beenden,RandomDSValue,CheckLevelCode;
extern BOOL Zufallsstufen,KeineDatenspeicher,StatusFile,PrefsFile,BlaueKnoten;
extern BOOL Schatten,SaveDatenfeld,InstallNoIC,AlwaysICInfo,AlwaysICDS;
extern UBYTE AnzahlCPU,AnzahlSPU,AnzahlDS,AnzahlSAN,AnzahlSN,AnzahlIOP,AnzahlBlueNodes;

void MatrixGenerierung(){
ULONG MGxPos,MGyPos;
	MGxPos=0;
	MGyPos=5;
	MaxSAN--;
	CreateSAN(MGxPos,MGyPos);
	Matrix[MGxPos+MGyPos*12].O=TRUE;
	MGxPos+=1;
	Matrix[MGxPos+MGyPos*12].W=TRUE;
	CreateSPU(MGxPos,MGyPos);
	}

void MatrixKorrektur(){
ULONG x,y,zwsp;
int StartX,EndX,SizeX;
int StartY,EndY,SizeY;
BOOL BackStatus;
	zwsp=0;
	for(y=0;y<12;y++){
		for(x=0;x<12;x++){
			if(Matrix[x+12*y].Type==2) zwsp++;
			}
		}
	if(AnzahlKnoten>0){
		while(AnzahlKnoten>0){
			x=Zufallszahl(1,4);
			switch(x){
				case 4:{StartX=1;
								EndX=11;
								SizeX=1;
								StartY=1;
								EndY=11;
								SizeY=1;
								break;
								}
				case 3:{StartX=1;
								EndX=11;
								SizeX=1;
								StartY=10;
								EndY=0;
								SizeY=-1;
								break;
								}
				case 2:{StartX=10;
								EndX=0;
								SizeX=-1;
								StartY=1;
								EndY=11;
								SizeY=1;
								break;
								}
				case 1:{StartX=10;
								EndX=0;
								SizeX=-1;
								StartY=10;
								EndY=0;
								SizeY=-1;
								break;
								}
				}
			for(y=StartY;(SizeY<0?y>EndY:y<EndY);y=y+SizeY){
				for(x=StartX;(SizeX<0?x>EndX:x<EndX);x=x+SizeX){
					if(Matrix[x+12*y].Type==0){
						BackStatus=FALSE;
						if((BackStatus==FALSE)&&(Editbar(x,y-1)!=0)){
							if((BackStatus=InsertNewNode(x,y,x,y-1))==TRUE){
								Matrix[x+12*(y-1)].S=TRUE;
								Matrix[x+12*y].N=TRUE;
								}
							}
						if((BackStatus==FALSE)&&(Editbar(x+1,y-1)!=0)){
							if((BackStatus=InsertNewNode(x,y,x+1,y-1))==TRUE){
								Matrix[x+1+12*(y-1)].SW=TRUE;
								Matrix[x+12*y].NO=TRUE;
								}
							}
						if((BackStatus==FALSE)&&(Editbar(x+1,y)!=0)){
							if((BackStatus=InsertNewNode(x,y,x+1,y))==TRUE){
								Matrix[x+1+12*y].W=TRUE;
								Matrix[x+12*y].O=TRUE;
								}
							}
						if((BackStatus==FALSE)&&(Editbar(x+1,y+1)!=0)){
							if((BackStatus=InsertNewNode(x,y,x+1,y+1))==TRUE){
								Matrix[x+1+12*(y+1)].NW=TRUE;
								Matrix[x+12*y].SO=TRUE;
								}
							}
						if((BackStatus==FALSE)&&(Editbar(x,y+1)!=0)){
							if((BackStatus=InsertNewNode(x,y,x,y+1))==TRUE){
								Matrix[x+12*(y+1)].N=TRUE;
								Matrix[x+12*y].S=TRUE;
								}
							}
						if((BackStatus==FALSE)&&(Editbar(x-1,y+1)!=0)){
							if((BackStatus=InsertNewNode(x,y,x-1,y+1))==TRUE){
								Matrix[x-1+12*(y+1)].NO=TRUE;
								Matrix[x+12*y].SW=TRUE;
								}
							}
						if((BackStatus==FALSE)&&(Editbar(x-1,y)!=0)){
							if((BackStatus=InsertNewNode(x,y,x-1,y))==TRUE){
								Matrix[x-1+12*y].O=TRUE;
								Matrix[x+12*y].W=TRUE;
								}
							}
						if((BackStatus==FALSE)&&(Editbar(x-1,y-1)!=0)){
							if((BackStatus=InsertNewNode(x,y,x-1,y-1))==TRUE){
								Matrix[x-1+12*(y-1)].SO=TRUE;
								Matrix[x+12*y].NW=TRUE;
								}
							}
						}
					}
				}
			}
		}
	while((AnzahlKnoten<1)&&(CPUInSystem==FALSE)){
		x=Zufallszahl(1,4);
		switch(x){
			case 4:{StartX=0;
							EndX=12;
							SizeX=1;
							StartY=0;
							EndY=12;
							SizeY=1;
							break;
							}
			case 3:{StartX=0;
							EndX=12;
							SizeX=1;
							StartY=11;
							EndY=-1;
							SizeY=-1;
							break;
							}
			case 2:{StartX=11;
							EndX=-1;
							SizeX=-1;
							StartY=0;
							EndY=12;
							SizeY=1;
							break;
							}
			case 1:{StartX=11;
							EndX=-1;
							SizeX=-1;
							StartY=11;
							EndY=-1;
							SizeY=-1;
							break;
							}
			}
		for(y=StartY;(SizeY<0?y>EndY:y<EndY);y=y+SizeY){
			for(x=StartX;(SizeX<0?x>EndX:x<EndX);x=x+SizeX){
				if((x!=1)&&(y!=5)){
					if((Matrix[x+12*y].Type==2)&&(CPUInSystem==FALSE)){
						Matrix[x+12*y].Type=1;
						CPUInSystem=TRUE;
						}
					}
				}
			}
		if(CPUInSystem==FALSE){
			Matrix[1+12*5].Type=1;
			CPUInSystem=TRUE;
			}
		}
	while((zwsp==1)&&(CPUInSystem==FALSE)&&(AnzahlKnoten>0)){
		x=Zufallszahl(1,4);
		switch(x){
			case 4:{StartX=0;
							EndX=12;
							SizeX=1;
							StartY=0;
							EndY=12;
							SizeY=1;
							break;
							}
			case 3:{StartX=0;
							EndX=12;
							SizeX=1;
							StartY=11;
							EndY=-1;
							SizeY=-1;
							break;
							}
			case 2:{StartX=11;
							EndX=-1;
							SizeX=-1;
							StartY=0;
							EndY=12;
							SizeY=1;
							break;
							}
			case 1:{StartX=11;
							EndX=-1;
							SizeX=-1;
							StartY=11;
							EndY=-1;
							SizeY=-1;
							break;
							}
			}
		for(y=StartY;(SizeY<0?y>EndY:y<EndY);y=y+SizeY){
			for(x=StartX;(SizeX<0?x>EndX:x<EndX);x=x+SizeX){
				if((Matrix[x+12*y].Type==2)&&(CPUInSystem==FALSE)){
					Matrix[x+12*y].Type=1;
					CPUInSystem=TRUE;
					}
				}
			}
		}
	CountNodes();
	BackStatus=FALSE;
	while((AnzahlIOP==0)&&(BackStatus==FALSE)){
		x=Zufallszahl(1,4);
		switch(x){
			case 4:{StartX=0;
							EndX=12;
							SizeX=1;
							StartY=0;
							EndY=12;
							SizeY=1;
							break;
							}
			case 3:{StartX=0;
							EndX=12;
							SizeX=1;
							StartY=11;
							EndY=-1;
							SizeY=-1;
							break;
							}
			case 2:{StartX=11;
							EndX=-1;
							SizeX=-1;
							StartY=0;
							EndY=12;
							SizeY=1;
							break;
							}
			case 1:{StartX=11;
							EndX=-1;
							SizeX=-1;
							StartY=11;
							EndY=-1;
							SizeY=-1;
							break;
							}
			}
		for(y=StartY;(SizeY<0?y>EndY:y<EndY);y=y+SizeY){
			for(x=StartX;(SizeX<0?x>EndX:x<EndX);x=x+SizeX){
				if((Matrix[x+12*y].Type==5)&&(BackStatus==FALSE)){
					Matrix[x+12*y].Type=3;
					BackStatus=TRUE;
					CountNodes();
					}
				if((Matrix[x+12*y].Type==6)&&(BackStatus==FALSE)){
					Matrix[x+12*y].Type=3;
					BackStatus=TRUE;
					CountNodes();
					}
				}
			}
		}
	for(y=1;y<11;y++){
		for(x=1;x<11;x++){
			if((Matrix[x+12*y].N==TRUE)&&((Matrix[x+12*(y-1)].N==FALSE)&&(Matrix[x+12*(y-1)].Type==0))) Matrix[x+12*y].N=FALSE;
			if((Matrix[x+12*y].NO==TRUE)&&((Matrix[x+1+12*(y-1)].NO==FALSE)&&(Matrix[x+1+12*(y-1)].Type==0))) Matrix[x+12*y].NO=FALSE;
			if((Matrix[x+12*y].O==TRUE)&&((Matrix[x+1+12*y].O==FALSE)&&(Matrix[x+1+12*y].Type==0))) Matrix[x+12*y].O=FALSE;
			if((Matrix[x+12*y].SO==TRUE)&&((Matrix[x+1+12*(y+1)].SO==FALSE)&&(Matrix[x+1+12*(y+1)].Type==0))) Matrix[x+12*y].SO=FALSE;
			if((Matrix[x+12*y].S==TRUE)&&((Matrix[x+12*(y+1)].S==FALSE)&&(Matrix[x+12*(y+1)].Type==0))) Matrix[x+12*y].S=FALSE;
			if((Matrix[x+12*y].SW==TRUE)&&((Matrix[x-1+12*(y+1)].SW==FALSE)&&(Matrix[x-1+12*(y+1)].Type==0))) Matrix[x+12*y].SW=FALSE;
			if((Matrix[x+12*y].W==TRUE)&&((Matrix[x-1+12*y].W==FALSE)&&(Matrix[x-1+12*y].Type==0))) Matrix[x+12*y].W=FALSE;
			if((Matrix[x+12*y].NW==TRUE)&&((Matrix[x-1+12*(y-1)].NW==FALSE)&&(Matrix[x-1+12*(y-1)].Type==0))) Matrix[x+12*y].NW=FALSE;
			}
		}
	}

BOOL InsertNewNode(ULONG xw1,ULONG yw1,ULONG xw2,ULONG yw2){
BOOL status;
ULONG zwsp;
	status=FALSE;
	if(AnzahlKnoten>0){
		switch(Matrix[xw2+12*yw2].Type){
			case 1:{zwsp=Zufallszahl(1,6);
							if(((zwsp==1)||(zwsp==2)||(zwsp==3))&&(Zufallszahl(1,3)==1)){
								Matrix[xw1+12*yw1].Type=2;
								AnzahlKnotenSenken();
								status=TRUE;
								}
							if(((zwsp==4)||(zwsp==5))&&(Zufallszahl(1,3)==1)){
								Matrix[xw1+12*yw1].Type=4;
								AnzahlKnotenSenken();
								status=TRUE;
								}
							if((zwsp==5)&&(Zufallszahl(1,3)==1)){
								switch(Zufallszahl(1,3)){
									case 1:{Matrix[xw1+12*yw1].Type=3;
													AnzahlKnotenSenken();
													status=TRUE;
													break;
													}
									case 2:{if(MaxSAN>0){
														Matrix[xw1+12*yw1].Type=5;
														AnzahlKnotenSenken();
														MaxSAN--;
														status=TRUE;
														}
													break;
													}
									case 3:{Matrix[xw1+12*yw1].Type=6;
													AnzahlKnotenSenken();
													status=TRUE;
													break;
													}
									}
								}
							break;
							}
			case 2:{zwsp=Zufallszahl(1,6);
							if(((zwsp==1)||(zwsp==2))&&(Zufallszahl(1,3)==1)){
								Matrix[xw1+12*yw1].Type=2;
								AnzahlKnotenSenken();
								status=TRUE;
								}
							if(((zwsp==3)||(zwsp==4))&&(Zufallszahl(1,3)==1)){
								Matrix[xw1+12*yw1].Type=4;
								AnzahlKnotenSenken();
								status=TRUE;
								}
							if(((zwsp==5)||(zwsp==6))&&(Zufallszahl(1,3)==1)){
								switch(Zufallszahl(1,3)){
									case 1:{Matrix[xw1+12*yw1].Type=3;
													AnzahlKnotenSenken();
													status=TRUE;
													break;
													}
									case 2:{if(MaxSAN>0){
														Matrix[xw1+12*yw1].Type=5;
														AnzahlKnotenSenken();
														MaxSAN--;
														status=TRUE;
														}
													break;
													}
									case 3:{Matrix[xw1+12*yw1].Type=6;
													AnzahlKnotenSenken();
													status=TRUE;
													break;
													}
									}
								}
							break;
							}
			case 4:{zwsp=Zufallszahl(1,6);
							if(((zwsp==1)||(zwsp==2)||(zwsp==3)||(zwsp==4))&&(Zufallszahl(1,3)==1)){
								Matrix[xw1+12*yw1].Type=2;
								AnzahlKnotenSenken();
								status=TRUE;
								}
							if(((zwsp==5)||(zwsp==6))&&(Zufallszahl(1,3)==1)){
								Matrix[xw1+12*yw1].Type=4;
								AnzahlKnotenSenken();
								status=TRUE;
								}
							break;
							}
			}
		}
	return status;
	}

ULONG Editbar(ULONG xW,ULONG yW){
ULONG Rueckwert;

	Rueckwert=0;
	if(Matrix[xW+yW*12].Type==1) Rueckwert=1;
	if(Matrix[xW+yW*12].Type==2) Rueckwert=2;
	if(Matrix[xW+yW*12].Type==4) Rueckwert=4;
	return Rueckwert;
	}

void MatrixEditKanten(){
LONG count;
ULONG xWert,yWert;
	count=(ULONG)((Zufallszahl(10,20)*log((double)AusgangsKnoten))/10);
	while(count>0){
		for(yWert=1;yWert<11;yWert++){
			for(xWert=1;xWert<11;xWert++){
				if(Editbar(xWert,yWert)!=0){
					if(Editbar(xWert,yWert-1)){
						if(Zufallszahl(1,6)==1){
							Matrix[xWert+yWert*12].N=TRUE;
							Matrix[xWert+(yWert-1)*12].S=TRUE;
							}
						}
					if(Editbar(xWert+1,yWert-1)){
						if(Zufallszahl(1,6)==1){
							Matrix[xWert+yWert*12].NO=TRUE;
							Matrix[xWert+1+(yWert-1)*12].SW=TRUE;
							}
						}
					if(Editbar(xWert+1,yWert)){
						if(Zufallszahl(1,6)==1){
							Matrix[xWert+yWert*12].O=TRUE;
							Matrix[xWert+1+yWert*12].W=TRUE;
							}
						}
					if(Editbar(xWert+1,yWert+1)){
						if(Zufallszahl(1,6)==1){
							Matrix[xWert+yWert*12].SO=TRUE;
							Matrix[xWert+1+(yWert+1)*12].NW=TRUE;
							}
						}
					if(Editbar(xWert,yWert+1)){
						if(Zufallszahl(1,6)==1){
							Matrix[xWert+yWert*12].S=TRUE;
							Matrix[xWert+(yWert+1)*12].N=TRUE;
							}
						}
					if(Editbar(xWert-1,yWert+1)){
						if(Zufallszahl(1,6)==1){
							Matrix[xWert+yWert*12].SW=TRUE;
							Matrix[xWert-1+(yWert+1)*12].NO=TRUE;
							}
						}
					if(Editbar(xWert-1,yWert)){
						if(Zufallszahl(1,6)==1){
							Matrix[xWert+yWert*12].W=TRUE;
							Matrix[xWert-1+yWert*12].O=TRUE;
							}
						}
					if(Editbar(xWert-1,yWert-1)){
						if(Zufallszahl(1,6)==1){
							Matrix[xWert+yWert*12].NW=TRUE;
							Matrix[xWert-1+(yWert-1)*12].SO=TRUE;
							}
						}
					}
				count--;
				}
			}
		}
	count=(ULONG)((Zufallszahl(10,20)*log((double)AusgangsKnoten))/10);
	while(count>0){
		for(yWert=2;yWert<10;yWert++){
			for(xWert=2;xWert<10;xWert++){
				if(Editbar(xWert,yWert)!=0){
					if(Editbar(xWert,yWert-2)!=0){
						if(Matrix[xWert+12*(yWert-1)].Type==0){
							if(Zufallszahl(1,4)==1){
								Matrix[xWert+yWert*12].N=TRUE;
								Matrix[xWert+(yWert-1)*12].S=TRUE;
								Matrix[xWert+(yWert-1)*12].N=TRUE;
								Matrix[xWert+(yWert-2)*12].S=TRUE;
								}
							}
						}
					if(Editbar(xWert+2,yWert-2)!=0){
						if(Matrix[xWert+1+12*(yWert-1)].Type==0){
							if(Zufallszahl(1,4)==1){
								Matrix[xWert+yWert*12].NO=TRUE;
								Matrix[xWert+1+(yWert-1)*12].SW=TRUE;
								Matrix[xWert+1+(yWert-1)*12].NO=TRUE;
								Matrix[xWert+2+(yWert-2)*12].SW=TRUE;
								}
							}
						}
					if(Editbar(xWert+2,yWert)!=0){
						if(Matrix[xWert+1+12*yWert].Type==0){
							if(Zufallszahl(1,4)==1){
								Matrix[xWert+yWert*12].O=TRUE;
								Matrix[xWert+1+yWert*12].W=TRUE;
								Matrix[xWert+1+yWert*12].O=TRUE;
								Matrix[xWert+2+yWert*12].W=TRUE;
								}
							}
						}
					if(Editbar(xWert+2,yWert+2)!=0){
						if(Matrix[xWert+1+12*(yWert+1)].Type==0){
							if(Zufallszahl(1,4)==1){
								Matrix[xWert+yWert*12].SO=TRUE;
								Matrix[xWert+1+(yWert+1)*12].NW=TRUE;
								Matrix[xWert+1+(yWert+1)*12].SO=TRUE;
								Matrix[xWert+2+(yWert+2)*12].NW=TRUE;
								}
							}
						}
					if(Editbar(xWert,yWert+2)!=0){
						if(Matrix[xWert+12*(yWert+1)].Type==0){
							if(Zufallszahl(1,4)==1){
								Matrix[xWert+yWert*12].S=TRUE;
								Matrix[xWert+(yWert+1)*12].N=TRUE;
								Matrix[xWert+(yWert+1)*12].S=TRUE;
								Matrix[xWert+(yWert+2)*12].N=TRUE;
								}
							}
						}
					if(Editbar(xWert-2,yWert+2)!=0){
						if(Matrix[xWert-1+12*(yWert+1)].Type==0){
							if(Zufallszahl(1,4)==1){
								Matrix[xWert+yWert*12].SW=TRUE;
								Matrix[xWert-1+(yWert+1)*12].NO=TRUE;
								Matrix[xWert-1+(yWert+1)*12].SW=TRUE;
								Matrix[xWert-2+(yWert+2)*12].NO=TRUE;
								}
							}
						}
					if(Editbar(xWert-2,yWert)!=0){
						if(Matrix[xWert-1+12*yWert].Type==0){
							if(Zufallszahl(1,4)==1){
								Matrix[xWert+yWert*12].W=TRUE;
								Matrix[xWert-1+yWert*12].O=TRUE;
								Matrix[xWert-1+yWert*12].W=TRUE;
								Matrix[xWert-2+yWert*12].O=TRUE;
								}
							}
						}
					if(Editbar(xWert-2,yWert-2)!=0){
						if(Matrix[xWert-1+12*(yWert-1)].Type==0){
							if(Zufallszahl(1,4)==1){
								Matrix[xWert+yWert*12].NW=TRUE;
								Matrix[xWert-1+(yWert-1)*12].SO=TRUE;
								Matrix[xWert-1+(yWert-1)*12].NW=TRUE;
								Matrix[xWert-2+(yWert-2)*12].SO=TRUE;
								}
							}
						}
					}
				}
			}
		count--;
		}
	}

void MatrixStufe(){
ULONG xx,yy;
	if(Zufallsstufen==TRUE){
		for(yy=0;yy<12;yy++){
			for(xx=0;xx<12;xx++){
				if(Matrix[xx+12*yy].Type>0){
					Matrix[xx+12*yy].Secure=BerechneStufe();
					while((Matrix[xx+12*yy].Type==1)&&(Matrix[xx+12*yy].Secure==2)) Matrix[xx+12*yy].Secure=BerechneStufe();
					if(Matrix[xx+12*yy].Secure==2) while(Matrix[xx+12*yy].Stufe<2) Matrix[xx+12*yy].Stufe=Berechne1W6();
					if(Matrix[xx+12*yy].Secure==3) Matrix[xx+12*yy].Stufe=Berechne1W6()+1;
					if(Matrix[xx+12*yy].Secure==4) Matrix[xx+12*yy].Stufe=Berechne1W6()+2;
					if(Matrix[xx+12*yy].Secure==5) Matrix[xx+12*yy].Stufe=BerechneStufenwert()+BerechneStufenwert();
					if(Matrix[xx+12*yy].Secure==6) Matrix[xx+12*yy].Stufe=BerechneStufenwert()+BerechneStufenwert()+2;
					if(Matrix[xx+12*yy].Secure==7) Matrix[xx+12*yy].Stufe=BerechneStufenwert()+BerechneStufenwert()+4;
					}
				}
			}
		}
	else{
		for(yy=0;yy<12;yy++){
			for(xx=0;xx<12;xx++){
				if(Matrix[xx+12*yy].Type>0){
					Matrix[xx+12*yy].Stufe=BerechneStufenwert();
					if((Zufallszahl(1,6)==1)&&(Matrix[xx+12*yy].Secure>2)){
						Matrix[xx+12*yy].Secure--;
						if((Matrix[xx+12*yy].Type==1)&&(Matrix[xx+12*yy].Secure==2)){
							Matrix[xx+12*yy].Secure++;
							}
						}
					if((Zufallszahl(1,6)==6)&&(Matrix[xx+12*yy].Secure<5)){
						Matrix[xx+12*yy].Secure++;
						if((Matrix[xx+12*yy].Type==1)&&(Matrix[xx+12*yy].Secure>MaxFarben)){
							Matrix[xx+12*yy].Secure=MaxFarben;
							}
						}
					}
				}
			}
		}
	}

void MatrixDatenspeicher(){
ULONG xx,yy,ergebnis,GrundWert,GrundSize;
	if(KeineDatenspeicher==FALSE){
		for(yy=0;yy<12;yy++){
			for(xx=0;xx<12;xx++){
				if((Matrix[xx+12*yy].Type==4)&&(Matrix[xx+12*yy].Secure>2)){
					GrundWert=0;
					GrundSize=0;
					switch(Matrix[xx+12*yy].Secure){
						case 3:
									ergebnis=Berechne2W6();
									switch(ergebnis){
										case 2:
											GrundWert=0;
											GrundSize=0;
											break;
										case 3:
										case 4:
											GrundWert=50;
											GrundSize=Berechne2W6();
											break;
										case 5:
										case 6:
										case 7:
											GrundWert=1000;
											GrundSize=Berechne2W6();
											break;
										case 8:
										case 9:
										case 10:
											GrundWert=5000;
											GrundSize=Berechne2W6();
											break;
										case 11:
											GrundWert=10000;
											GrundSize=Berechne2W6();
											break;
										case 12:
											GrundWert=0;
											GrundSize=0;
											break;
										}
									break;
						case 4:
									ergebnis=Berechne2W6();
									switch(ergebnis){
										case 2:
											GrundWert=0;
											GrundSize=0;
											break;
										case 3:
										case 4:
											GrundWert=1000;
											GrundSize=Berechne2W6();
											break;
										case 5:
										case 6:
										case 7:
											GrundWert=2500;
											GrundSize=Berechne2W6();
											break;
										case 8:
										case 9:
										case 10:
											GrundWert=10000;
											GrundSize=Berechne2W6();
											break;
										case 11:
											GrundWert=50000;
											GrundSize=Berechne2W6();
											break;
										case 12:
											GrundWert=0;
											GrundSize=0;
											break;
										}
									break;
						case 5:
									ergebnis=Berechne2W6();
									switch(ergebnis){
										case 2:
											GrundWert=0;
											GrundSize=0;
											break;
										case 3:
										case 4:
											GrundWert=2500;
											GrundSize=Berechne2W6();
											break;
										case 5:
										case 6:
										case 7:
											GrundWert=5000;
											GrundSize=Berechne2W6();
											break;
										case 8:
										case 9:
										case 10:
											GrundWert=50000;
											GrundSize=Berechne2W6();
											break;
										case 11:
											GrundWert=100000;
											GrundSize=Berechne2W6();
											break;
										case 12:
											GrundWert=0;
											GrundSize=0;
											break;
										}
									break;
						case 6:
									ergebnis=Berechne2W6();
									switch(ergebnis){
										case 2:
											GrundWert=0;
											GrundSize=0;
											break;
										case 3:
										case 4:
											GrundWert=5000;
											GrundSize=Berechne2W6();
											break;
										case 5:
										case 6:
										case 7:
											GrundWert=25000;
											GrundSize=Berechne2W6();
											break;
										case 8:
										case 9:
										case 10:
											GrundWert=100000;
											GrundSize=Berechne2W6();
											break;
										case 11:
											GrundWert=200000;
											GrundSize=Berechne2W6();
											break;
										case 12:
											GrundWert=0;
											GrundSize=0;
											break;
										}
									break;
						case 7:
									ergebnis=Berechne2W6();
									switch(ergebnis){
										case 2:
											GrundWert=0;
											GrundSize=0;
											break;
										case 3:
										case 4:
											GrundWert=25000;
											GrundSize=Berechne2W6();
											break;
										case 5:
										case 6:
										case 7:
											GrundWert=50000;
											GrundSize=Berechne2W6();
											break;
										case 8:
										case 9:
										case 10:
											GrundWert=200000;
											GrundSize=Berechne2W6();
											break;
										case 11:
											GrundWert=500000;
											GrundSize=Berechne2W6();
											break;
										case 12:
											GrundWert=0;
											GrundSize=0;
											break;
										}
									break;
						}
					if(RandomDSValue==TRUE) Matrix[xx+12*yy].Datenwert=((GrundWert/10)*Zufallszahl(900,1100))/100;
					else Matrix[xx+12*yy].Datenwert=GrundWert;
					if((RandomDSValue==TRUE)&&(GrundWert>0)){
						Matrix[xx+12*yy].Datensize=GrundSize*10+Zufallszahl(0,10)-5;
						if(Matrix[xx+12*yy].Datensize<0) Matrix[xx+12*yy].Datensize=1;
						}
					else Matrix[xx+12*yy].Datensize=GrundSize*10;
					}
				}
			}
		}
	CountNodes();
	CountBlueDS();
	while((AnzahlWichtigeDaten>0)&&(AnzahlWichtigeDaten>(AusgangsWichtigeDaten-(AnzahlDS-AnzahlBlueNodes)))){
		for(yy=0;yy<12;yy++){
			for(xx=0;xx<12;xx++){
				if((Matrix[xx+12*yy].Type==4)&&(AnzahlWichtigeDaten>0)&&(Matrix[xx+12*yy].WichtigeDaten==FALSE)){
					if((Zufallszahl(1,15)>10)&&(Matrix[xx+12*yy].Secure>2)){
						Matrix[xx+12*yy].WichtigeDaten=TRUE;
						AnzahlWichtigeDaten--;
						}
					}
				}
			}
		}
	}

void MatrixNummerierung(){
ULONG x1,y1,Korrekt;
BOOL MakePrint;
char AusText[10];
	for(y1=0;y1<12;y1++){
		for(x1=0;x1<12;x1++){
			MakePrint=FALSE;
			switch(Matrix[x1+y1*12].Type){
				case 2:{sprintf(AusText,"%i",Matrix[x1+12*y1].Nummer);
								MakePrint=TRUE;
								Korrekt=0;
								if(Matrix[x1+12*y1].ICType>0) Korrekt=2;
								break;
								}
				case 3:{sprintf(AusText,"%i",Matrix[x1+12*y1].Nummer);
								MakePrint=TRUE;
								Korrekt=4;
								break;
								}
				case 4:{sprintf(AusText,"%i",Matrix[x1+12*y1].Nummer);
								MakePrint=TRUE;
								Korrekt=0;
								if(Matrix[x1+12*y1].ICType>0) Korrekt=2;
								break;
								}
				case 5:{sprintf(AusText,"%i",Matrix[x1+12*y1].Nummer);
								MakePrint=TRUE;
								Korrekt=0;
								if(Matrix[x1+12*y1].ICType>0) Korrekt=0;
								break;
								}
				case 6:{sprintf(AusText,"%i",Matrix[x1+12*y1].Nummer);
								MakePrint=TRUE;
								Korrekt=0;
								if(Matrix[x1+12*y1].ICType>0) Korrekt=2;
								break;
								}
				}
			if(MakePrint==TRUE) AusgabeText(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset+Korrekt,1,AusText);
			}
		}
	}

void MatrixDarstellung(){
ULONG x1,y1;
	for(y1=0;y1<12;y1++){
		for(x1=0;x1<12;x1++){
			switch(Matrix[x1+y1*12].Type){
				case 1:{DrawCPU(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset,Matrix[x1+y1*12].Secure);
								break;
								}
				case 2:{DrawSPU(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset,Matrix[x1+y1*12].Secure);
								break;
								}
				case 3:{DrawIOP(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset,Matrix[x1+y1*12].Secure);
								break;
								}
				case 4:{DrawDS(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset,Matrix[x1+y1*12].Secure);
								break;
								}
				case 5:{DrawSAN(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset,Matrix[x1+y1*12].Secure);
								break;
								}
				case 6:{DrawSN(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset,Matrix[x1+y1*12].Secure);
								break;
								}
				}
			}
		}
	for(y1=0;y1<12;y1++){
		for(x1=0;x1<12;x1++){
			if((Matrix[x1+y1*12].N==TRUE)&&(y1>0)){
				if(((Matrix[x1+y1*12].Type==4)||(Matrix[x1+y1*12].Type==6)||(Matrix[x1+y1*12].Type==3)||(Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&((Matrix[x1+(y1-1)*12].Type==2)||(Matrix[x1+(y1-1)*12].Type==4)||(Matrix[x1+(y1-1)*12].Type==3)||(Matrix[x1+(y1-1)*12].Type==6)||(Matrix[x1+(y1-1)*12].Type==1))){
					DrawLinie(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset-11,x1*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset+11);
					}
				if((Matrix[x1+y1*12].Type==5)&&((Matrix[x1+(y1-1)*12].Type==2)||(Matrix[x1+(y1-1)*12].Type==4)||(Matrix[x1+(y1-1)*12].Type==1))){
					DrawLinie(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset-6,x1*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset+11);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==4)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+(y1-1)*12].Type==5)){
					DrawLinie(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset-11,x1*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset+6);
					}
/*Leer*/
				if(((Matrix[x1+y1*12].Type==4)||(Matrix[x1+y1*12].Type==6)||(Matrix[x1+y1*12].Type==3)||(Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset-11,x1*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==5)&&(Matrix[x1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset-6,x1*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==4)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset-11,x1*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				}
			if((Matrix[x1+y1*12].NO==TRUE)&&(x1<11)&&(y1>0)){
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&((Matrix[x1+1+(y1-1)*12].Type==2)||(Matrix[x1+1+(y1-1)*12].Type==1))){
					DrawLinie(x1*xVerschiebung+xOffset+12,y1*yVerschiebung+yOffset-9,(x1+1)*xVerschiebung+xOffset-12,(y1-1)*yVerschiebung+yOffset+9);
					}
				if((Matrix[x1+y1*12].Type==4)&&(Matrix[x1+1+(y1-1)*12].Type==4)){
					DrawLinie(x1*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset-9,(x1+1)*xVerschiebung+xOffset-11,(y1-1)*yVerschiebung+yOffset+9);
					}
				if((Matrix[x1+y1*12].Type==3)&&((Matrix[x1+1+(y1-1)*12].Type==1)||(Matrix[x1+1+(y1-1)*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset+6,y1*yVerschiebung+yOffset-5,(x1+1)*xVerschiebung+xOffset-12,(y1-1)*yVerschiebung+yOffset+9);
					}
				if((Matrix[x1+y1*12].Type==4)&&((Matrix[x1+1+(y1-1)*12].Type==1)||(Matrix[x1+1+(y1-1)*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset-9,(x1+1)*xVerschiebung+xOffset-12,(y1-1)*yVerschiebung+yOffset+9);
					}
				if((Matrix[x1+y1*12].Type==5)&&((Matrix[x1+1+(y1-1)*12].Type==2)||(Matrix[x1+1+(y1-1)*12].Type==1))){
					DrawLinie(x1*xVerschiebung+xOffset+10,y1*yVerschiebung+yOffset-6,(x1+1)*xVerschiebung+xOffset-12,(y1-1)*yVerschiebung+yOffset+9);
					}
				if((Matrix[x1+y1*12].Type==6)&&((Matrix[x1+1+(y1-1)*12].Type==1)||(Matrix[x1+1+(y1-1)*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset+9,y1*yVerschiebung+yOffset-7,(x1+1)*xVerschiebung+xOffset-12,(y1-1)*yVerschiebung+yOffset+9);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+(y1-1)*12].Type==3)){
					DrawLinie(x1*xVerschiebung+xOffset+12,y1*yVerschiebung+yOffset-9,(x1+1)*xVerschiebung+xOffset-13,(y1-1)*yVerschiebung+yOffset+11);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+(y1-1)*12].Type==4)){
					DrawLinie(x1*xVerschiebung+xOffset+12,y1*yVerschiebung+yOffset-9,(x1+1)*xVerschiebung+xOffset-11,(y1-1)*yVerschiebung+yOffset+9);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+(y1-1)*12].Type==5)){
					DrawLinie(x1*xVerschiebung+xOffset+12,y1*yVerschiebung+yOffset-9,(x1+1)*xVerschiebung+xOffset-10,(y1-1)*yVerschiebung+yOffset+6);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+(y1-1)*12].Type==6)){
					DrawLinie(x1*xVerschiebung+xOffset+12,y1*yVerschiebung+yOffset-9,(x1+1)*xVerschiebung+xOffset-9,(y1-1)*yVerschiebung+yOffset+7);
					}
/*Leer*/
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+12,y1*yVerschiebung+yOffset-9,(x1+1)*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==3)&&(Matrix[x1+1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+6,y1*yVerschiebung+yOffset-5,(x1+1)*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==4)&&(Matrix[x1+1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset-9,(x1+1)*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==5)&&(Matrix[x1+1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+10,y1*yVerschiebung+yOffset-6,(x1+1)*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==6)&&(Matrix[x1+1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+9,y1*yVerschiebung+yOffset-7,(x1+1)*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+12,y1*yVerschiebung+yOffset-9,(x1+1)*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				}
			if((Matrix[x1+y1*12].O==TRUE)&&(x1<11)){
				if(((Matrix[x1+y1*12].Type==5)||(Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&((Matrix[x1+1+y1*12].Type==2)||(Matrix[x1+1+y1*12].Type==5)||(Matrix[x1+1+y1*12].Type==1))){
					DrawLinie(x1*xVerschiebung+xOffset+16,y1*yVerschiebung+yOffset,(x1+1)*xVerschiebung+xOffset-16,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==4)&&(Matrix[x1+1+y1*12].Type==4)){
					DrawLinie(x1*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset,(x1+1)*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==4)&&((Matrix[x1+1+y1*12].Type==1)||(Matrix[x1+1+y1*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset,(x1+1)*xVerschiebung+xOffset-16,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==3)&&((Matrix[x1+1+y1*12].Type==1)||(Matrix[x1+1+y1*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset+8,y1*yVerschiebung+yOffset,(x1+1)*xVerschiebung+xOffset-16,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==6)&&((Matrix[x1+1+y1*12].Type==1)||(Matrix[x1+1+y1*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset,(x1+1)*xVerschiebung+xOffset-16,y1*yVerschiebung+yOffset);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+y1*12].Type==4)){
					DrawLinie(x1*xVerschiebung+xOffset+16,y1*yVerschiebung+yOffset,(x1+1)*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+y1*12].Type==3)){
					DrawLinie(x1*xVerschiebung+xOffset+16,y1*yVerschiebung+yOffset,(x1+1)*xVerschiebung+xOffset-8,y1*yVerschiebung+yOffset);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+y1*12].Type==6)){
					DrawLinie(x1*xVerschiebung+xOffset+16,y1*yVerschiebung+yOffset,(x1+1)*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset);
					}
/*Leer*/
				if(((Matrix[x1+y1*12].Type==5)||(Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+y1*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+16,y1*yVerschiebung+yOffset,(x1+1)*xVerschiebung+xOffset,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==4)&&(Matrix[x1+1+y1*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset,(x1+1)*xVerschiebung+xOffset,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==3)&&(Matrix[x1+1+y1*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+8,y1*yVerschiebung+yOffset,(x1+1)*xVerschiebung+xOffset,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==6)&&(Matrix[x1+1+y1*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset,(x1+1)*xVerschiebung+xOffset,y1*yVerschiebung+yOffset);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+y1*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+16,y1*yVerschiebung+yOffset,(x1+1)*xVerschiebung+xOffset,y1*yVerschiebung+yOffset);
					}
				}
			if((Matrix[x1+y1*12].SO==TRUE)&&(y1<11)&&(x1<11)){
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&((Matrix[x1+1+(y1+1)*12].Type==2)||(Matrix[x1+1+(y1+1)*12].Type==1))){
					DrawLinie(x1*xVerschiebung+xOffset+12,y1*yVerschiebung+yOffset+9,(x1+1)*xVerschiebung+xOffset-12,(y1+1)*yVerschiebung+yOffset-9);
					}
				if((Matrix[x1+y1*12].Type==4)&&(Matrix[x1+1+(y1+1)*12].Type==4)){
					DrawLinie(x1*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset+9,(x1+1)*xVerschiebung+xOffset-11,(y1+1)*yVerschiebung+yOffset-9);
					}
				if((Matrix[x1+y1*12].Type==3)&&((Matrix[x1+1+(y1+1)*12].Type==1)||(Matrix[x1+1+(y1+1)*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset+13,y1*yVerschiebung+yOffset+11,(x1+1)*xVerschiebung+xOffset-12,(y1+1)*yVerschiebung+yOffset-9);
					}
				if((Matrix[x1+y1*12].Type==4)&&((Matrix[x1+1+(y1+1)*12].Type==1)||(Matrix[x1+1+(y1+1)*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset+9,(x1+1)*xVerschiebung+xOffset-12,(y1+1)*yVerschiebung+yOffset-9);
					}
				if((Matrix[x1+y1*12].Type==5)&&((Matrix[x1+1+(y1+1)*12].Type==2)||(Matrix[x1+1+(y1+1)*12].Type==1))){
					DrawLinie(x1*xVerschiebung+xOffset+10,y1*yVerschiebung+yOffset+6,(x1+1)*xVerschiebung+xOffset-12,(y1+1)*yVerschiebung+yOffset-9);
					}
				if((Matrix[x1+y1*12].Type==6)&&((Matrix[x1+1+(y1+1)*12].Type==1)||(Matrix[x1+1+(y1+1)*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset+9,y1*yVerschiebung+yOffset+7,(x1+1)*xVerschiebung+xOffset-12,(y1+1)*yVerschiebung+yOffset-9);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+(y1+1)*12].Type==3)){
					DrawLinie(x1*xVerschiebung+xOffset+12,y1*yVerschiebung+yOffset+9,(x1+1)*xVerschiebung+xOffset-6,(y1+1)*yVerschiebung+yOffset-4);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+(y1+1)*12].Type==4)){
					DrawLinie(x1*xVerschiebung+xOffset+12,y1*yVerschiebung+yOffset+9,(x1+1)*xVerschiebung+xOffset-11,(y1+1)*yVerschiebung+yOffset-9);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+(y1+1)*12].Type==5)){
					DrawLinie(x1*xVerschiebung+xOffset+12,y1*yVerschiebung+yOffset+9,(x1+1)*xVerschiebung+xOffset-10,(y1+1)*yVerschiebung+yOffset-6);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+(y1+1)*12].Type==6)){
					DrawLinie(x1*xVerschiebung+xOffset+12,y1*yVerschiebung+yOffset+9,(x1+1)*xVerschiebung+xOffset-9,(y1+1)*yVerschiebung+yOffset-7);
					}
/*Leer*/
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+1+(y1+1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+12,y1*yVerschiebung+yOffset+9,(x1+1)*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==4)&&(Matrix[x1+1+(y1+1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset+9,(x1+1)*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==3)&&(Matrix[x1+1+(y1+1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+13,y1*yVerschiebung+yOffset+11,(x1+1)*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==5)&&(Matrix[x1+1+(y1+1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+10,y1*yVerschiebung+yOffset+6,(x1+1)*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==6)&&(Matrix[x1+1+(y1+1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset+9,y1*yVerschiebung+yOffset+7,(x1+1)*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset);
					}
				}
			if((Matrix[x1+y1*12].S==TRUE)&&(y1<11)){
				if(((Matrix[x1+y1*12].Type==4)||(Matrix[x1+y1*12].Type==6)||(Matrix[x1+y1*12].Type==3)||(Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&((Matrix[x1+(y1+1)*12].Type==2)||(Matrix[x1+(y1+1)*12].Type==4)||(Matrix[x1+(y1+1)*12].Type==1)||(Matrix[x1+(y1+1)*12].Type==6)||(Matrix[x1+(y1+1)*12].Type==3))){
					DrawLinie(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset+11,x1*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset-11);
					}
				if((Matrix[x1+y1*12].Type==5)&&((Matrix[x1+(y1-1)*12].Type==2)||(Matrix[x1+(y1-1)*12].Type==4)||(Matrix[x1+(y1+1)*12].Type==1))){
					DrawLinie(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset+6,x1*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset-11);
					}
				if(((Matrix[x1+y1*12].Type==4)||(Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+(y1+1)*12].Type==5)){
					DrawLinie(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset+11,x1*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset-6);
					}
/*Leer*/
				if(((Matrix[x1+y1*12].Type==4)||(Matrix[x1+y1*12].Type==6)||(Matrix[x1+y1*12].Type==3)||(Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1+(y1+1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset+11,x1*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==5)&&(Matrix[x1+(y1+1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset,y1*yVerschiebung+yOffset+6,x1*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset);
					}
				}
			if((Matrix[x1+y1*12].SW==TRUE)&&(x1>0)&&(y1<11)){
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&((Matrix[x1-1+(y1+1)*12].Type==2)||(Matrix[x1-1+(y1+1)*12].Type==1))){
					DrawLinie(x1*xVerschiebung+xOffset-12,y1*yVerschiebung+yOffset+9,(x1-1)*xVerschiebung+xOffset+12,(y1+1)*yVerschiebung+yOffset-9);
					}
				if((Matrix[x1+y1*12].Type==4)&&(Matrix[x1-1+(y1+1)*12].Type==4)){
					DrawLinie(x1*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset+9,(x1-1)*xVerschiebung+xOffset+11,(y1+1)*yVerschiebung+yOffset-9);
					}
				if((Matrix[x1+y1*12].Type==3)&&((Matrix[x1-1+(y1+1)*12].Type==1)||(Matrix[x1-1+(y1+1)*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset-13,y1*yVerschiebung+yOffset+11,(x1-1)*xVerschiebung+xOffset+12,(y1+1)*yVerschiebung+yOffset-9);
					}
				if((Matrix[x1+y1*12].Type==4)&&((Matrix[x1-1+(y1+1)*12].Type==1)||(Matrix[x1-1+(y1+1)*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset+9,(x1-1)*xVerschiebung+xOffset+12,(y1+1)*yVerschiebung+yOffset-9);
					}
				if((Matrix[x1+y1*12].Type==5)&&((Matrix[x1-1+(y1+1)*12].Type==2)||(Matrix[x1-1+(y1+1)*12].Type==1))){
					DrawLinie(x1*xVerschiebung+xOffset-10,y1*yVerschiebung+yOffset+6,(x1-1)*xVerschiebung+xOffset+12,(y1+1)*yVerschiebung+yOffset-9);
					}
				if((Matrix[x1+y1*12].Type==6)&&((Matrix[x1-1+(y1+1)*12].Type==1)||(Matrix[x1-1+(y1+1)*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset-9,y1*yVerschiebung+yOffset+7,(x1-1)*xVerschiebung+xOffset+12,(y1+1)*yVerschiebung+yOffset-9);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1-1+(y1+1)*12].Type==3)){
					DrawLinie(x1*xVerschiebung+xOffset-12,y1*yVerschiebung+yOffset+9,(x1-1)*xVerschiebung+xOffset+6,(y1+1)*yVerschiebung+yOffset-5);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1-1+(y1+1)*12].Type==4)){
					DrawLinie(x1*xVerschiebung+xOffset-12,y1*yVerschiebung+yOffset+9,(x1-1)*xVerschiebung+xOffset+11,(y1+1)*yVerschiebung+yOffset-9);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1-1+(y1+1)*12].Type==5)){
					DrawLinie(x1*xVerschiebung+xOffset-12,y1*yVerschiebung+yOffset+9,(x1-1)*xVerschiebung+xOffset+10,(y1+1)*yVerschiebung+yOffset-6);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1-1+(y1+1)*12].Type==6)){
					DrawLinie(x1*xVerschiebung+xOffset-12,y1*yVerschiebung+yOffset+9,(x1-1)*xVerschiebung+xOffset+9,(y1+1)*yVerschiebung+yOffset-7);
					}
/*Leer*/
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1-1+(y1+1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-12,y1*yVerschiebung+yOffset+9,(x1-1)*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==3)&&(Matrix[x1-1+(y1+1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-13,y1*yVerschiebung+yOffset+11,(x1-1)*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==4)&&(Matrix[x1-1+(y1+1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset+9,(x1-1)*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==5)&&(Matrix[x1-1+(y1+1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-10,y1*yVerschiebung+yOffset+6,(x1-1)*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==6)&&(Matrix[x1-1+(y1+1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-9,y1*yVerschiebung+yOffset+7,(x1-1)*xVerschiebung+xOffset,(y1+1)*yVerschiebung+yOffset);
					}
				}
			if((Matrix[x1+y1*12].W==TRUE)&&(x1>0)){
				if(((Matrix[x1+y1*12].Type==5)||(Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&((Matrix[x1-1+y1*12].Type==2)||(Matrix[x1-1+y1*12].Type==5)||(Matrix[x1-1+y1*12].Type==1))){
					DrawLinie(x1*xVerschiebung+xOffset-16,y1*yVerschiebung+yOffset,(x1-1)*xVerschiebung+xOffset+16,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==4)&&(Matrix[x1-1+y1*12].Type==4)){
					DrawLinie(x1*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset,(x1-1)*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==4)&&((Matrix[x1-1+y1*12].Type==1)||(Matrix[x1-1+y1*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset,(x1-1)*xVerschiebung+xOffset+16,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==3)&&((Matrix[x1-1+y1*12].Type==1)||(Matrix[x1-1+y1*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset-8,y1*yVerschiebung+yOffset,(x1-1)*xVerschiebung+xOffset+15,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==6)&&((Matrix[x1-1+y1*12].Type==1)||(Matrix[x1-1+y1*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset,(x1-1)*xVerschiebung+xOffset+16,y1*yVerschiebung+yOffset);
					}
				if(((Matrix[x1+y1*12].Type==1)||(Matrix[x1+y1*12].Type==2))&&(Matrix[x1-1+y1*12].Type==4)){
					DrawLinie(x1*xVerschiebung+xOffset-16,y1*yVerschiebung+yOffset,(x1-1)*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset);
					}
				if(((Matrix[x1+y1*12].Type==1)||(Matrix[x1+y1*12].Type==2))&&(Matrix[x1-1+y1*12].Type==3)){
					DrawLinie(x1*xVerschiebung+xOffset-16,y1*yVerschiebung+yOffset,(x1-1)*xVerschiebung+xOffset+8,y1*yVerschiebung+yOffset);
					}
				if(((Matrix[x1+y1*12].Type==1)||(Matrix[x1+y1*12].Type==2))&&(Matrix[x1-1+y1*12].Type==6)){
					DrawLinie(x1*xVerschiebung+xOffset-16,y1*yVerschiebung+yOffset,(x1-1)*xVerschiebung+xOffset+11,y1*yVerschiebung+yOffset);
					}
/*Leer*/
				if(((Matrix[x1+y1*12].Type==5)||(Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1-1+y1*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-16,y1*yVerschiebung+yOffset,(x1-1)*xVerschiebung+xOffset,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==4)&&(Matrix[x1-1+y1*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset,(x1-1)*xVerschiebung+xOffset,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==3)&&(Matrix[x1-1+y1*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-8,y1*yVerschiebung+yOffset,(x1-1)*xVerschiebung+xOffset,y1*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==6)&&(Matrix[x1-1+y1*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset,(x1-1)*xVerschiebung+xOffset,y1*yVerschiebung+yOffset);
					}
				}
			if((Matrix[x1+y1*12].NW==TRUE)&&(x1>0)&&(y1>0)){
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&((Matrix[x1-1+(y1-1)*12].Type==2)||(Matrix[x1-1+(y1-1)*12].Type==1))){
					DrawLinie(x1*xVerschiebung+xOffset-12,y1*yVerschiebung+yOffset-9,(x1-1)*xVerschiebung+xOffset+12,(y1-1)*yVerschiebung+yOffset+9);
					}
				if((Matrix[x1+y1*12].Type==4)&&(Matrix[x1-1+(y1-1)*12].Type==4)){
					DrawLinie(x1*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset-9,(x1-1)*xVerschiebung+xOffset+11,(y1-1)*yVerschiebung+yOffset+9);
					}
				if((Matrix[x1+y1*12].Type==3)&&((Matrix[x1-1+(y1-1)*12].Type==1)||(Matrix[x1-1+(y1-1)*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset-6,y1*yVerschiebung+yOffset-4,(x1-1)*xVerschiebung+xOffset+12,(y1-1)*yVerschiebung+yOffset+9);
					}
				if((Matrix[x1+y1*12].Type==4)&&((Matrix[x1-1+(y1-1)*12].Type==1)||(Matrix[x1-1+(y1-1)*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset-9,(x1-1)*xVerschiebung+xOffset+12,(y1-1)*yVerschiebung+yOffset+9);
					}
				if((Matrix[x1+y1*12].Type==5)&&((Matrix[x1-1+(y1-1)*12].Type==2)||(Matrix[x1-1+(y1-1)*12].Type==1))){
					DrawLinie(x1*xVerschiebung+xOffset-10,y1*yVerschiebung+yOffset-6,(x1-1)*xVerschiebung+xOffset+12,(y1-1)*yVerschiebung+yOffset+9);
					}
				if((Matrix[x1+y1*12].Type==6)&&((Matrix[x1-1+(y1-1)*12].Type==1)||(Matrix[x1-1+(y1-1)*12].Type==2))){
					DrawLinie(x1*xVerschiebung+xOffset-9,y1*yVerschiebung+yOffset-7,(x1-1)*xVerschiebung+xOffset+12,(y1-1)*yVerschiebung+yOffset+9);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1-1+(y1-1)*12].Type==3)){
					DrawLinie(x1*xVerschiebung+xOffset-12,y1*yVerschiebung+yOffset-9,(x1-1)*xVerschiebung+xOffset+13,(y1-1)*yVerschiebung+yOffset+11);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1-1+(y1-1)*12].Type==4)){
					DrawLinie(x1*xVerschiebung+xOffset-12,y1*yVerschiebung+yOffset-9,(x1-1)*xVerschiebung+xOffset+11,(y1-1)*yVerschiebung+yOffset+9);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1-1+(y1-1)*12].Type==5)){
					DrawLinie(x1*xVerschiebung+xOffset-12,y1*yVerschiebung+yOffset-9,(x1-1)*xVerschiebung+xOffset+10,(y1-1)*yVerschiebung+yOffset+6);
					}
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1-1+(y1-1)*12].Type==6)){
					DrawLinie(x1*xVerschiebung+xOffset-12,y1*yVerschiebung+yOffset-9,(x1-1)*xVerschiebung+xOffset+9,(y1-1)*yVerschiebung+yOffset+7);
					}
/*Leer*/
				if(((Matrix[x1+y1*12].Type==2)||(Matrix[x1+y1*12].Type==1))&&(Matrix[x1-1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-12,y1*yVerschiebung+yOffset-9,(x1-1)*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==3)&&(Matrix[x1-1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-6,y1*yVerschiebung+yOffset-4,(x1-1)*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==4)&&(Matrix[x1-1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-11,y1*yVerschiebung+yOffset-9,(x1-1)*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==5)&&(Matrix[x1-1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-10,y1*yVerschiebung+yOffset-6,(x1-1)*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				if((Matrix[x1+y1*12].Type==6)&&(Matrix[x1-1+(y1-1)*12].Type==0)){
					DrawLinie(x1*xVerschiebung+xOffset-9,y1*yVerschiebung+yOffset-7,(x1-1)*xVerschiebung+xOffset,(y1-1)*yVerschiebung+yOffset);
					}
				}
			}
		}
	for(y1=0;y1<12;y1++){
		for(x1=0;x1<12;x1++){
			if(Matrix[x1+12*y1].ICType>0){
				if(Matrix[x1+12*y1].Type==1) DrawIC(x1*xVerschiebung+xOffset+15,y1*yVerschiebung+yOffset+3);
				if(Matrix[x1+12*y1].Type==2) DrawIC(x1*xVerschiebung+xOffset+15,y1*yVerschiebung+yOffset-2);
				if(Matrix[x1+12*y1].Type==3) DrawIC(x1*xVerschiebung+xOffset+15,y1*yVerschiebung+yOffset);
				if(Matrix[x1+12*y1].Type==4) DrawIC(x1*xVerschiebung+xOffset+15,y1*yVerschiebung+yOffset-2);
				if(Matrix[x1+12*y1].Type==5) DrawIC(x1*xVerschiebung+xOffset+7,y1*yVerschiebung+yOffset+3);
				if(Matrix[x1+12*y1].Type==6) DrawIC(x1*xVerschiebung+xOffset+15,y1*yVerschiebung+yOffset-2);
				}
			}
		}
	}

void MatrixInstallIC(){
ULONG xx,yy,TestWert;
BOOL ICInstallen;
	if(InstallNoIC==FALSE){
		for(yy=0;yy<12;yy++){
			for(xx=0;xx<12;xx++){
				if(Matrix[xx+12*yy].Type>0){
					ICInstallen=FALSE;
					TestWert=Zufallszahl(1,6);
					if((Matrix[xx+12*yy].Secure==3)&&((TestWert==1)||((AlwaysICDS==TRUE)&&(Matrix[xx+12*yy].Type==4)))) ICInstallen=TRUE;
					if((Matrix[xx+12*yy].Secure==4)&&((TestWert>=1)&&(TestWert<=2))||((AlwaysICDS==TRUE)&&(Matrix[xx+12*yy].Type==4))) ICInstallen=TRUE;
					if((Matrix[xx+12*yy].Secure==5)&&((TestWert>=1)&&(TestWert<=3))||((AlwaysICDS==TRUE)&&(Matrix[xx+12*yy].Type==4))) ICInstallen=TRUE;
					if((Matrix[xx+12*yy].Secure==6)&&((TestWert>=1)&&(TestWert<=4))||((AlwaysICDS==TRUE)&&(Matrix[xx+12*yy].Type==4))) ICInstallen=TRUE;
					if((Matrix[xx+12*yy].Secure==7)&&((TestWert>=1)&&(TestWert<=5))||((AlwaysICDS==TRUE)&&(Matrix[xx+12*yy].Type==4))) ICInstallen=TRUE;
					if(ICInstallen==TRUE){
						ICInstallen=FALSE;
						TestWert=Zufallszahl(1,6)+Zufallszahl(1,6);
						if((Matrix[xx+12*yy].Secure==3)&&(TestWert>=2)&&(TestWert<=8)) Matrix[xx+12*yy].ICType=1;		/* weiss */
						if((Matrix[xx+12*yy].Secure==3)&&(TestWert>=9)&&(TestWert<=11)) Matrix[xx+12*yy].ICType=2;	/* grau */
						if((Matrix[xx+12*yy].Secure==3)&&(TestWert>=12)&&(TestWert<=12)) Matrix[xx+12*yy].ICType=3;	/* schwarz */
						if((Matrix[xx+12*yy].Secure==4)&&(TestWert>=2)&&(TestWert<=7)) Matrix[xx+12*yy].ICType=1;		/* weiss */
						if((Matrix[xx+12*yy].Secure==4)&&(TestWert>=8)&&(TestWert<=10)) Matrix[xx+12*yy].ICType=2;	/* grau */
						if((Matrix[xx+12*yy].Secure==4)&&(TestWert>=11)&&(TestWert<=12)) Matrix[xx+12*yy].ICType=3;	/* schwarz */
						if((Matrix[xx+12*yy].Secure==5)&&(TestWert>=2)&&(TestWert<=6)) Matrix[xx+12*yy].ICType=1;		/* weiss */
						if((Matrix[xx+12*yy].Secure==5)&&(TestWert>=6)&&(TestWert<=10)) Matrix[xx+12*yy].ICType=2;	/* grau */
						if((Matrix[xx+12*yy].Secure==5)&&(TestWert>=11)&&(TestWert<=12)) Matrix[xx+12*yy].ICType=3;	/* schwarz */
						if((Matrix[xx+12*yy].Secure==6)&&(TestWert>=2)&&(TestWert<=5)) Matrix[xx+12*yy].ICType=1;		/* weiss */
						if((Matrix[xx+12*yy].Secure==6)&&(TestWert>=5)&&(TestWert<=9)) Matrix[xx+12*yy].ICType=2;		/* grau */
						if((Matrix[xx+12*yy].Secure==6)&&(TestWert>=10)&&(TestWert<=12)) Matrix[xx+12*yy].ICType=3;	/* schwarz */
						if((Matrix[xx+12*yy].Secure==7)&&(TestWert>=2)&&(TestWert<=4)) Matrix[xx+12*yy].ICType=1;		/* weiss */
						if((Matrix[xx+12*yy].Secure==7)&&(TestWert>=4)&&(TestWert<=9)) Matrix[xx+12*yy].ICType=2;		/* grau */
						if((Matrix[xx+12*yy].Secure==7)&&(TestWert>=10)&&(TestWert<=12)) Matrix[xx+12*yy].ICType=3;	/* schwarz */
						TestWert=Zufallszahl(1,6)+Zufallszahl(1,6);
						if((Matrix[xx+12*yy].ICType==1)&&(TestWert>=2)&&(TestWert<=2)) Matrix[xx+12*yy].ICArt=1;		/* Falle */
						if((Matrix[xx+12*yy].ICType==1)&&(TestWert>=3)&&(TestWert<=7)) Matrix[xx+12*yy].ICArt=2;		/* Zugang */
						if((Matrix[xx+12*yy].ICType==1)&&(TestWert>=8)&&(TestWert<=11)) Matrix[xx+12*yy].ICArt=3;		/* BarriereIC/WirbelIC */
						if((Matrix[xx+12*yy].ICType==1)&&(TestWert>=12)&&(TestWert<=12)) Matrix[xx+12*yy].ICArt=4;	/* Falle */
						if((Matrix[xx+12*yy].ICType==2)&&(TestWert>=2)&&(TestWert<=4)) Matrix[xx+12*yy].ICArt=1;		/* Blaster */
						if((Matrix[xx+12*yy].ICType==2)&&(TestWert>=5)&&(TestWert<=6)) Matrix[xx+12*yy].ICArt=2;		/* Aufspüren */
						if((Matrix[xx+12*yy].ICType==2)&&(TestWert>=7)&&(TestWert<=8)) Matrix[xx+12*yy].ICArt=3;		/* Killer */
						if((Matrix[xx+12*yy].ICType==2)&&(TestWert>=9)&&(TestWert<=11)) Matrix[xx+12*yy].ICArt=4;		/* Teerbaby */
						if((Matrix[xx+12*yy].ICType==2)&&(TestWert>=12)&&(TestWert<=12)) Matrix[xx+12*yy].ICArt=5;	/* Teergrube */
						if((Matrix[xx+12*yy].ICType>0)&&(Matrix[xx+12*yy].Secure==2)) Matrix[xx+12*yy].ICStufe=Zufallszahl(2,6);
						if((Matrix[xx+12*yy].ICType>0)&&(Matrix[xx+12*yy].Secure==3)) Matrix[xx+12*yy].ICStufe=Zufallszahl(2,6);
						if((Matrix[xx+12*yy].ICType>0)&&(Matrix[xx+12*yy].Secure==4)) Matrix[xx+12*yy].ICStufe=Zufallszahl(1,6)+Zufallszahl(1,6);
						if((Matrix[xx+12*yy].ICType>0)&&(Matrix[xx+12*yy].Secure==5)) Matrix[xx+12*yy].ICStufe=Zufallszahl(1,6)+Zufallszahl(1,6)+1;
						if((Matrix[xx+12*yy].ICType>0)&&(Matrix[xx+12*yy].Secure==6)) Matrix[xx+12*yy].ICStufe=Zufallszahl(1,6)+Zufallszahl(1,6)+Zufallszahl(1,6);
						if((Matrix[xx+12*yy].ICType>0)&&(Matrix[xx+12*yy].Secure==7)) Matrix[xx+12*yy].ICStufe=Zufallszahl(1,6)+Zufallszahl(1,6)+Zufallszahl(1,6)+3;
						}
					}
				if((Matrix[xx+12*yy].Type==4)&&(Matrix[xx+12*yy].WichtigeDaten==TRUE)){
					if(AlwaysICInfo==TRUE){
						Matrix[xx+12*yy].WDICType=1;
						Matrix[xx+12*yy].WDICArt=3;
						if(Matrix[xx+12*yy].Secure==2) Matrix[xx+12*yy].WDICStufe=Zufallszahl(2,6);
						if(Matrix[xx+12*yy].Secure==3) Matrix[xx+12*yy].WDICStufe=Zufallszahl(2,6);
						if(Matrix[xx+12*yy].Secure==4) Matrix[xx+12*yy].WDICStufe=Zufallszahl(1,6)+Zufallszahl(1,6);
						if(Matrix[xx+12*yy].Secure==5) Matrix[xx+12*yy].WDICStufe=Zufallszahl(1,6)+Zufallszahl(1,6)+1;
						if(Matrix[xx+12*yy].Secure==6) Matrix[xx+12*yy].WDICStufe=Zufallszahl(1,6)+Zufallszahl(1,6)+Zufallszahl(1,6);
						if(Matrix[xx+12*yy].Secure==7) Matrix[xx+12*yy].WDICStufe=Zufallszahl(1,6)+Zufallszahl(1,6)+Zufallszahl(1,6)+3;
						}
					else{
						if(Zufallszahl(1,6)==1){
							Matrix[xx+12*yy].WDICType=1;
							Matrix[xx+12*yy].WDICArt=3;
							if(Matrix[xx+12*yy].Secure==2) Matrix[xx+12*yy].WDICStufe=Zufallszahl(2,6);
							if(Matrix[xx+12*yy].Secure==3) Matrix[xx+12*yy].WDICStufe=Zufallszahl(2,6);
							if(Matrix[xx+12*yy].Secure==4) Matrix[xx+12*yy].WDICStufe=Zufallszahl(1,6)+Zufallszahl(1,6);
							if(Matrix[xx+12*yy].Secure==5) Matrix[xx+12*yy].WDICStufe=Zufallszahl(1,6)+Zufallszahl(1,6)+1;
							if(Matrix[xx+12*yy].Secure==6) Matrix[xx+12*yy].WDICStufe=Zufallszahl(1,6)+Zufallszahl(1,6)+Zufallszahl(1,6);
							if(Matrix[xx+12*yy].Secure==7) Matrix[xx+12*yy].WDICStufe=Zufallszahl(1,6)+Zufallszahl(1,6)+Zufallszahl(1,6)+3;
							}
						}
					}
				}
			}
		}
	}

void MatrixCheckLevelCode(){
int xx,yy;
int HighestSecure,HighestStufe;
	if(CheckLevelCode==TRUE){
		HighestSecure=0;
		HighestStufe=0;
		for(yy=0;yy<12;yy++){
			for(xx=0;xx<12;xx++){
				if(Matrix[xx+12*yy].Secure>HighestSecure) HighestSecure=Matrix[xx+12*yy].Secure;
				if(Matrix[xx+12*yy].Stufe>HighestStufe) HighestStufe=Matrix[xx+12*yy].Stufe;
				}
			}
		printf("Stufe : %i\n",HighestStufe);
		printf("Secure: %i\n",HighestSecure);
		for(yy=0;yy<12;yy++){
			for(xx=0;xx<12;xx++){
				if(Matrix[xx+12*yy].Secure<(HighestSecure-2)) Matrix[xx+12*yy].Secure=Zufallszahl((HighestSecure-2),HighestSecure);
				if(Matrix[xx+12*yy].Stufe<(HighestStufe/2)) Matrix[xx+12*yy].Stufe=Zufallszahl((HighestStufe/2),HighestStufe);
				}
			}
		}
	}