/*********************************/
/* MatrixGenerator für ShadowRun */
/* written by Thomas Reinhardt   */
/*                               */
/* Berechnungsfunktionen         */
/*********************************/
#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;
extern UBYTE xPos,yPos,MaxFarben,Language,OutputType;
extern struct MatrixKomponenten Matrix[12*12];
extern struct MatrixGenType MatrixDatas[1];
extern BOOL CPUInSystem,Beenden,RandomDSValue;
extern BOOL Zufallsstufen,KeineDatenspeicher,StatusFile,PrefsFile,BlaueKnoten;
extern BOOL Schatten,SaveDatenfeld,InstallNoIC,AlwaysICInfo;
extern UBYTE AnzahlCPU,AnzahlSPU,AnzahlDS,AnzahlSAN,AnzahlSN,AnzahlIOP,AnzahlBlueNodes;

void CreateSPU(ULONG x,ULONG y){
	if(Beenden==FALSE){
		Matrix[x+y*12].Type=2;
		Matrix[x+y*12].Belegt=TRUE;
		AnzahlKnotenSenken();
		if((Zufallszahl(1,6)==1)&&((x+0)>=0)&&((y-1)>=0)&&((x+0)<12)&&((y-1)<12)){
			if(CreateSPUKnoten(x,y-1)) Matrix[x+y*12].N=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x+1)<12)&&((y-1)>=0)&&((x+1)>=0)&&((y-1)<12)){
			if(CreateSPUKnoten(x+1,y-1)) Matrix[x+y*12].NO=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x+1)<12)&&((y+0)>=0)&&((x+1)>=0)&&((y+0)<12)){
			if(CreateSPUKnoten(x+1,y)) Matrix[x+y*12].O=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x+1)<12)&&((y+1)<12)&&((x+1)>=0)&&((y+1)>=0)){
			if(CreateSPUKnoten(x+1,y+1)) Matrix[x+y*12].SO=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x+0)>=0)&&((y+1)<12)&&((x+0)<12)&&((y+1)>=0)){
			if(CreateSPUKnoten(x,y+1)) Matrix[x+y*12].S=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x-1)>=0)&&((y+1)<12)&&((x-1)<12)&&((y+1)>=0)){
			if(CreateSPUKnoten(x-1,y+1)) Matrix[x+y*12].SW=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x-1)>=0)&&((y+0)>=0)&&((x-1)<12)&&((y+0)<12)){
			if(CreateSPUKnoten(x-1,y)) Matrix[x+y*12].W=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x-1)>=0)&&((y-1)>=0)&&((x-1)<12)&&((y-1)<12)){
			if(CreateSPUKnoten(x-1,y-1)) Matrix[x+y*12].NW=TRUE;
			}
		}
	}

void CreateCPU(ULONG x,ULONG y){
	if(Beenden==FALSE){
		Matrix[x+y*12].Type=1;
		Matrix[x+y*12].Belegt=TRUE;
		CPUInSystem=TRUE;
		AnzahlKnotenSenken();
		if((Zufallszahl(1,6)==1)&&((x+0)>=0)&&((y-1)>=0)&&((x+0)<12)&&((y-1)<12)){
			if(CreateCPUKnoten(x,y-1)) Matrix[x+y*12].N=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x+1)<12)&&((y-1)>=0)&&((x+1)>=0)&&((y-1)<12)){
			if(CreateCPUKnoten(x+1,y-1)) Matrix[x+y*12].NO=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x+1)<12)&&((y+0)>=0)&&((x+1)>=0)&&((y+0)<12)){
			if(CreateCPUKnoten(x+1,y)) Matrix[x+y*12].O=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x+1)<12)&&((y+1)<12)&&((x+1)>=0)&&((y+1)>=0)){
			if(CreateCPUKnoten(x+1,y+1)) Matrix[x+y*12].SO=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x+0)>=0)&&((y+1)<12)&&((x+0)<12)&&((y+1)>=0)){
			if(CreateCPUKnoten(x,y+1)) Matrix[x+y*12].S=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x-1)>=0)&&((y+1)<12)&&((x-1)<12)&&((y+1)>=0)){
			if(CreateCPUKnoten(x-1,y+1)) Matrix[x+y*12].SW=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x-1)>=0)&&((y+0)>=0)&&((x-1)<12)&&((y+0)<12)){
			if(CreateCPUKnoten(x-1,y)) Matrix[x+y*12].W=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x-1)>=0)&&((y-1)>=0)&&((x-1)<12)&&((y-1)<12)){
			if(CreateCPUKnoten(x-1,y-1)) Matrix[x+y*12].NW=TRUE;
			}
		}
	}

void CreateSN(ULONG x,ULONG y){
	if(Beenden==FALSE){
		Matrix[x+y*12].Type=6;
		Matrix[x+y*12].Belegt=TRUE;
		AnzahlKnotenSenken();
		}
	}

void CreateSAN(ULONG x,ULONG y){
	if((Beenden==FALSE)&&(MaxSAN>0)){
		Matrix[x+y*12].Type=5;
		MaxSAN--;
		Matrix[x+y*12].Belegt=TRUE;
		AnzahlKnotenSenken();
		}
	}

void CreateIOP(ULONG x,ULONG y){
	if(Beenden==FALSE){
		Matrix[x+y*12].Type=3;
		Matrix[x+y*12].Belegt=TRUE;
		AnzahlKnotenSenken();
		}
	}

void CreateDS(ULONG x,ULONG y){
	if(Beenden==FALSE){
		Matrix[x+y*12].Type=4;
		Matrix[x+y*12].Belegt=TRUE;
		AnzahlKnotenSenken();
		if((Zufallszahl(1,6)==1)&&((x+0)>=0)&&((y-1)>=0)&&((x+0)<12)&&((y-1)<12)){
			if(CreateDSKnoten(x,y-1)) Matrix[x+y*12].N=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x+1)<12)&&((y-1)>=0)&&((x+1)>=0)&&((y-1)<12)){
			if(CreateDSKnoten(x+1,y-1)) Matrix[x+y*12].NO=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x+1)<12)&&((y+0)>=0)&&((x+1)>=0)&&((y+0)<12)){
			if(CreateDSKnoten(x+1,y)) Matrix[x+y*12].O=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x+1)<12)&&((y+1)<12)&&((x+1)>=0)&&((y+1)>=0)){
			if(CreateDSKnoten(x+1,y+1)) Matrix[x+y*12].SO=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x+0)>=0)&&((y+1)<12)&&((x+0)<12)&&((y+1)>=0)){
			if(CreateDSKnoten(x,y+1)) Matrix[x+y*12].S=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x-1)>=0)&&((y+1)<12)&&((x-1)<12)&&((y+1)>=0)){
			if(CreateDSKnoten(x-1,y+1)) Matrix[x+y*12].SW=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x-1)>=0)&&((y+0)>=0)&&((x-1)<12)&&((y+0)<12)){
			if(CreateDSKnoten(x-1,y)) Matrix[x+y*12].W=TRUE;
			}
		if((Zufallszahl(1,6)==1)&&((x-1)>=0)&&((y-1)>=0)&&((x-1)<12)&&((y-1)<12)){
			if(CreateDSKnoten(x-1,y-1)) Matrix[x+y*12].NW=TRUE;
			}
		}
	}

BOOL CreateSPUKnoten(ULONG PosX,ULONG PosY){
ULONG zwsp,count;
BOOL status;
	status=FALSE;
	if(Matrix[PosX+PosY*12].Belegt==FALSE){
		zwsp=Zufallszahl(1,6);
		switch(zwsp){
			case 1:{
				if(AnzahlKnoten>0) status=TRUE;
				if(CPUInSystem==FALSE) CreateCPU(PosX,PosY);
				else CreateSPU(PosX,PosY);
				break;
				}
			case 2:{
				if(AnzahlKnoten>0) status=TRUE;
				CreateSPU(PosX,PosY);
				break;
				}
			case 3:{
				if(AnzahlKnoten>0) status=TRUE;
				CreateDS(PosX,PosY);
				break;
				}
			case 4:{
				if(AnzahlKnoten>0) status=TRUE;
				CreateDS(PosX,PosY);
				break;
				}
			case 5:{
				if(AnzahlKnoten>0) status=TRUE;
				count=Zufallszahl(1,3);
				if(count==1) CreateIOP(PosX,PosY);
				if(count==2) CreateSAN(PosX,PosY);
				if(count==3) CreateSN(PosX,PosY);
				break;
				}
			case 6:{
				if(AnzahlKnoten>0) status=TRUE;
				count=Zufallszahl(1,3);
				if(count==1) CreateIOP(PosX,PosY);
				if(count==2) CreateSAN(PosX,PosY);
				if(count==3) CreateSN(PosX,PosY);
				break;
				}
			}
		}
	return status;
	}

BOOL CreateCPUKnoten(ULONG PosX,ULONG PosY){
ULONG zwsp,count;
BOOL status;
	status=FALSE;
	if(Matrix[PosX+PosY*12].Belegt==FALSE){
		zwsp=Zufallszahl(1,6);
		switch(zwsp){
			case 1:{
				if(AnzahlKnoten>0) status=TRUE;
				CreateSPU(PosX,PosY);
				break;
				}
			case 2:{
				if(AnzahlKnoten>0) status=TRUE;
				CreateSPU(PosX,PosY);
				break;
				}
			case 3:{
				if(AnzahlKnoten>0) status=TRUE;
				CreateSPU(PosX,PosY);
				break;
				}
			case 4:{
				if(AnzahlKnoten>0) status=TRUE;
				CreateDS(PosX,PosY);
				break;
				}
			case 5:{
				if(AnzahlKnoten>0) status=TRUE;
				CreateDS(PosX,PosY);
				break;
				}
			case 6:{
				if(AnzahlKnoten>0) status=TRUE;
				count=Zufallszahl(1,3);
				if(count==1) CreateIOP(PosX,PosY);
				if(count==2) CreateSAN(PosX,PosY);
				if(count==3) CreateSN(PosX,PosY);
				break;
				}
			}
		}
	return status;
	}

BOOL CreateDSKnoten(ULONG PosX,ULONG PosY){
ULONG zwsp;
BOOL status;
	status=FALSE;
	if(Matrix[PosX+PosY*12].Belegt==FALSE){
		zwsp=Zufallszahl(1,6);
		switch(zwsp){
			case 1:{
				if(AnzahlKnoten>0) status=TRUE;
				if(CPUInSystem==FALSE) CreateCPU(PosX,PosY);
				else CreateSPU(PosX,PosY);
				break;
				}
			case 2:{
				if(AnzahlKnoten>0) status=TRUE;
				if(CPUInSystem==FALSE) CreateCPU(PosX,PosY);
				else CreateSPU(PosX,PosY);
				break;
				}
			case 3:{
				if(AnzahlKnoten>0) status=TRUE;
				CreateSPU(PosX,PosY);
				break;
				}
			case 4:{
				if(AnzahlKnoten>0) status=TRUE;
				CreateSPU(PosX,PosY);
				break;
				}
			case 5:{
				if(AnzahlKnoten>0) status=TRUE;
				CreateSPU(PosX,PosY);
				break;
				}
			case 6:{
				if(AnzahlKnoten>0) status=TRUE;
				CreateDS(PosX,PosY);
				break;
				}
			}
		}
	return status;
	}

void AnzahlKnotenSenken(){
	AnzahlKnoten-=1;
	if(AnzahlKnoten<1){
		Beenden=TRUE;
		}
	}

void CountNodes(){
ULONG xx,yy;
	AnzahlCPU=0;
	AnzahlSPU=0;
	AnzahlDS=0;
	AnzahlIOP=0;
	AnzahlSAN=0;
	AnzahlSN=0;
	for(yy=0;yy<12;yy++){
		for(xx=0;xx<12;xx++){
			switch(Matrix[xx+yy*12].Type){
				case 1:{AnzahlCPU++;
								Matrix[xx+12*yy].Nummer=AnzahlCPU;
								break;
								}
				case 2:{AnzahlSPU++;
								Matrix[xx+12*yy].Nummer=AnzahlSPU;
								break;
								}
				case 3:{AnzahlIOP++;
								Matrix[xx+12*yy].Nummer=AnzahlIOP;
								break;
								}
				case 4:{AnzahlDS++;
								Matrix[xx+12*yy].Nummer=AnzahlDS;
								break;
								}
				case 5:{AnzahlSAN++;
								Matrix[xx+12*yy].Nummer=AnzahlSAN;
								break;
								}
				case 6:{AnzahlSN++;
								Matrix[xx+12*yy].Nummer=AnzahlSN;
								break;
								}
				}
			}
		}
	}

void CountBlueDS(){
ULONG xx,yy;
	AnzahlBlueNodes=0;
	for(yy=0;yy<12;yy++){
		for(xx=0;xx<12;xx++){
			if((Matrix[xx+yy*12].Secure==2)&&(Matrix[xx+12*yy].Type==4)) AnzahlBlueNodes++;
			}
		}
	}

ULONG Berechne1W6(){
ULONG ergebnis;
	ergebnis=Zufallszahl(1,6);
	return ergebnis;
	}

ULONG Berechne2W6(){
ULONG ergebnis;
	ergebnis=Zufallszahl(1,6)+Zufallszahl(1,6);
	return ergebnis;
	}

ULONG BerechneStufe(){
ULONG ergebnis,returnwert;
	ergebnis=0;
	if((Zufallszahl(1,10)==1)&&(BlaueKnoten==TRUE)){
		returnwert=2; /* blue */
		}
	else{
		if(MaxFarben>=7){
			ergebnis=Berechne2W6();
			switch(ergebnis){
				case 6: /* gruen */
				case 8:
							returnwert=3;
							break;
				case 7: /* orange */
				case 9:
				case 10:
							returnwert=4;
							break;
				case 4: /* rot */
				case 5:
							returnwert=5;
							break;
				case 3: /* purpur */
				case 11:
							returnwert=6;
							break;
				case 2: /* schwarz */
				case 12:
							returnwert=7;
							break;
				}
			}
		if(MaxFarben<7){
			ergebnis=Berechne1W6();
			switch(ergebnis){
				case 1: /* gruen */
				case 2:
							returnwert=3;
							break;
				case 3: /* orange */
				case 4:
				case 5:
							returnwert=4;
							break;
				case 6: /* rot */
							returnwert=5;
							break;
				}
			}
		}
	return returnwert;
	}

ULONG BerechneStufenwert(){
ULONG ergebnis;
	ergebnis=0;
	ergebnis+=Zufallszahl(1,6);
	ergebnis+=Zufallszahl(1,6);
	ergebnis=ergebnis/2;
	return ergebnis;
	}

LONG Zufallszahl(UWORD minW,UWORD maxW){
LONG DBL=1;
	DBL=(rand()/(RAND_MAX/(maxW+1-minW)))+minW;
	return (LONG)(DBL);
	}

ULONG CountMoneyDS(){
ULONG ergebnis,xx,yy;
	ergebnis=0;
	for(yy=0;yy<12;yy++){
		for(xx=0;xx<12;xx++){
			if(Matrix[xx+12*yy].Type==4){
				ergebnis+=Matrix[xx+12*yy].Datenwert*Matrix[xx+12*yy].Datensize;
				}
			}
		}
	return ergebnis;
	}	

int GetStufe(ULONG Number,ULONG Type){
ULONG xx,yy;
int returnwert;
	returnwert=0;
	for(yy=0;yy<12;yy++){
		for(xx=0;xx<12;xx++){
			if((Matrix[xx+12*yy].Nummer==Number)&&(Matrix[xx+12*yy].Type==Type)){
				returnwert=Matrix[xx+12*yy].Stufe;
				}
			}
		}
	return returnwert;
	}

int GetType(ULONG Number,ULONG Type){
ULONG xx,yy;
int returnwert;
	returnwert=0;
	for(yy=0;yy<12;yy++){
		for(xx=0;xx<12;xx++){
			if((Matrix[xx+12*yy].Nummer==Number)&&(Matrix[xx+12*yy].Type==Type)){
				returnwert=Matrix[xx+12*yy].Secure;
				}
			}
		}
	return returnwert;
	}

int GetDatenWert(ULONG Number,ULONG Type){
ULONG xx,yy;
int returnwert;
	returnwert=0;
	for(yy=0;yy<12;yy++){
		for(xx=0;xx<12;xx++){
			if((Matrix[xx+12*yy].Nummer==Number)&&(Matrix[xx+12*yy].Type==Type)){
				returnwert=Matrix[xx+12*yy].Datenwert;
				}
			}
		}
	return returnwert;
	}

int GetDatenSize(ULONG Number,ULONG Type){
ULONG xx,yy;
int returnwert;
	returnwert=0;
	for(yy=0;yy<12;yy++){
		for(xx=0;xx<12;xx++){
			if((Matrix[xx+12*yy].Nummer==Number)&&(Matrix[xx+12*yy].Type==Type)){
				returnwert=Matrix[xx+12*yy].Datensize;
				}
			}
		}
	return returnwert;
	}

int GetTypeName(ULONG Number,ULONG Type){
int returnwert;
	returnwert=0;
	switch(GetType(Number,Type)){
		case 2:{
			returnwert=1;
			if(Language==1) returnwert=2;
			break;
			}
		case 3:{
			returnwert=3;
			if(Language==1) returnwert=4;
			break;
			}
		case 4:{
			returnwert=5;
			if(Language==1) returnwert=6;
			break;
			}
		case 5:{
			returnwert=7;
			if(Language==1) returnwert=8;
			break;
			}
		case 6:{
			returnwert=9;
			if(Language==1) returnwert=10;
			break;
			}
		case 7:{
			returnwert=11;
			if(Language==1) returnwert=12;
			break;
			}
		}
	return returnwert;
	}

int GetIceArt(ULONG Number,ULONG Type){
ULONG xx,yy;
int returnwert;
	returnwert=0;
	for(yy=0;yy<12;yy++){
		for(xx=0;xx<12;xx++){
			if((Matrix[xx+12*yy].Nummer==Number)&&(Matrix[xx+12*yy].Type==Type)){
				returnwert=Matrix[xx+12*yy].ICArt;
				}
			}
		}
	return returnwert;
	}

int GetIceType(ULONG Number,ULONG Type){
ULONG xx,yy;
int returnwert;
	returnwert=0;
	for(yy=0;yy<12;yy++){
		for(xx=0;xx<12;xx++){
			if((Matrix[xx+12*yy].Nummer==Number)&&(Matrix[xx+12*yy].Type==Type)){
				returnwert=Matrix[xx+12*yy].ICType;
				}
			}
		}
	return returnwert;
	}

int GetIceStufe(ULONG Number,ULONG Type){
ULONG xx,yy;
int returnwert;
	returnwert=0;
	for(yy=0;yy<12;yy++){
		for(xx=0;xx<12;xx++){
			if((Matrix[xx+12*yy].Nummer==Number)&&(Matrix[xx+12*yy].Type==Type)){
				returnwert=Matrix[xx+12*yy].ICStufe;
				}
			}
		}
	return returnwert;
	}

int GetWDIceStufe(ULONG Number,ULONG Type){
ULONG xx,yy;
int returnwert;
	returnwert=0;
	for(yy=0;yy<12;yy++){
		for(xx=0;xx<12;xx++){
			if((Matrix[xx+12*yy].Nummer==Number)&&(Matrix[xx+12*yy].Type==Type)){
				returnwert=Matrix[xx+12*yy].WDICStufe;
				}
			}
		}
	return returnwert;
	}

int GetIceName(ULONG Number,ULONG Type){
int returnwert,is,it;
	returnwert=0;
	if(Language==1) returnwert=1;
	is=GetIceArt(Number,Type);
	it=GetIceType(Number,Type);
	if((it==1)&&(is==1)){
		returnwert=2;
		if(Language==1) returnwert=3;
		}
	if((it==1)&&(is==2)){
		returnwert=4;
		if(Language==1) returnwert=5;
		}
	if((it==1)&&(is==3)){
		returnwert=6;
		if(Language==1) returnwert=7;
		if(Type==4) returnwert+=2;
		}
	if((it==1)&&(is==4)){
		returnwert=2;
		if(Language==1) returnwert=3;
		}
	if((it==2)&&(is==1)){
		returnwert=10;
		if(Language==1) returnwert=11;
		}
	if((it==2)&&(is==2)){
		returnwert=12;
		if(Language==1) returnwert=13;
		}
	if((it==2)&&(is==3)){
		returnwert=14;
		if(Language==1) returnwert=15;
		}
	if((it==2)&&(is==4)){
		returnwert=16;
		if(Language==1) returnwert=17;
		}
	if((it==2)&&(is==5)){
		returnwert=18;
		if(Language==1) returnwert=19;
		}
	if(it==3){
		returnwert=20;
		if(Language==1) returnwert=21;
		}
	return returnwert;
	}

int GetIceNameType(ULONG Number,ULONG Type){
int returnwert,it;
	returnwert=0;
	it=GetIceType(Number,Type);
	if(it==1){
		returnwert=1;
		if(Language==1) returnwert=2;
		}
	if(it==2){
		returnwert=3;
		if(Language==1) returnwert=4;
		}
	if(it==3){
		returnwert=5;
		if(Language==1) returnwert=6;
		}
	return returnwert;
	}

int GetDataInfoWert(ULONG Number,ULONG Type){
int returnwert,xx,yy;
	returnwert=0;
	for(yy=0;yy<12;yy++){
		for(xx=0;xx<12;xx++){
			if((Matrix[xx+12*yy].Nummer==Number)&&(Matrix[xx+12*yy].Type==Type)){
				if(Matrix[xx+12*yy].WichtigeDaten==TRUE){
					returnwert=3;
					if(Language==1) returnwert=4;
					}
				else{
					returnwert=1;
					if(Language==1) returnwert=2;
					}
				}
			}
		}
	return returnwert;
	}

BOOL GetWD(ULONG Number,ULONG Type){
ULONG xx,yy;
BOOL returnwert;
	returnwert=FALSE;
	for(yy=0;yy<12;yy++){
		for(xx=0;xx<12;xx++){
			if((Matrix[xx+12*yy].Nummer==Number)&&(Matrix[xx+12*yy].Type==Type)){
				if(Matrix[xx+12*yy].WDICType>0) returnwert=TRUE;
				else returnwert=FALSE;
				}
			}
		}
	return returnwert;
	}