#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include "Ausgang.h"
#include "Netz.h"
#include "Rest.h"

float x[18],y[18],xx[13], yy[13];
const char *Zahl[13]={"","1","2","3","4","5","6","7","8","9","10","11","12"};

/********************************************************************************/
/*	Speicheranforderung							*/
/********************************************************************************/

NE Element_neu()
{
	NetzElement *elemzei;
	elemzei=(NetzElement*)malloc(sizeof(NetzElement)*13);
	if(elemzei==NULL)
	{
	 	printf(" Kein Speicher mehr vorhanden!\n");
		exit(0);  	
	}
	return elemzei;
}

/********************************************************************************/
/* Neues Netz generieren (Verschieben)						*/
/********************************************************************************/

NE Verschieben(NetzElement *Feld, int schwgrad)
{
	int zahl=0,a=0,u=1;
	schwgrad=schwgrad*200;
	
/********************************************************************************/
/* Solange Schwierigkeitsgrad nicht 0 ist, wird per Zufallszahlen probiert, ob  */
/* Zahl zu verschieben geht. Dies wird so gemacht, indem man schaut ob die 	*/
/* 3 Zeiger des leeren Feldes auf mindestens 1 Feld zeigen das man verschiebven */
/* moechte. Danach wird jedesmal das Feld aktualisiert.				*/
/********************************************************************************/

	while(schwgrad>=0)
	{
		while(Feld[a].eintrag!=0) a++;
		while(u!=0)
		{
			zahl=rand()%12;
			if (((*Feld[a].zeiger1)!=zahl) && ((*Feld[a].zeiger2)!=zahl))
			{
				if ( (a==0) || (a==2) || (a==6) || (a==10) )
				{
					if((*Feld[a].zeiger3)!=zahl) u=1;	
					else u=0;
				}
				else u=1;
			}
			else u=0;	
		}			
		Feld=Akt_Element(Feld,zahl,a);	
		a=0;
		schwgrad--;
		u=1;
	}
	return Feld;
}

/********************************************************************************/
/* Ausgangsposition=Zielposition						*/
/********************************************************************************/

NE Netz_neu(NetzElement *Feld)
{
	int z,i=12;

/********************************************************************************/
/* Alle felder bekommen den wert von 0 bis 12. Der 1.Zeiger jedes Feldes zeigt  */
/* auf das vorhergehende Feld. Der 2.Zeiger zeigt auf das nachfolgende Feld.    */
/* Der 3. Zeiger wird erstmal ein NULL-Zeiger bei allen. Danch wird fuer das    */
/* Feld in der Mitte die Zeiger gesetz, auf die ihn angrenzenden Felder, und    */
/* von den angrenzenden Feldern wird der 3.Zeiger auf die 0 gezeigt.		*/
/********************************************************************************/

	for (z=0;z<=12;z++)
	{
		Feld[z].eintrag=z;
	}
	for (z=1;z<=12;z++)
	{
		if(z==12) 	Feld[12].zeiger1=&Feld[1].eintrag;
		else
		{
			Feld[z].zeiger1=&Feld[z+1].eintrag;
		}
		Feld[z].zeiger2=&Feld[i].eintrag;
		Feld[z].zeiger3=NULL;
		i=z;
	}
	for(z=2;z<=10;z=z+4)
	{
		Feld[z].zeiger3=&Feld[0].eintrag;
	}
	Feld[0].zeiger1=&Feld[6].eintrag;
	Feld[0].zeiger2=&Feld[2].eintrag;
	Feld[0].zeiger3=&Feld[10].eintrag;
	return Feld;
}

/************************************************************************************************/
/* Aktualisierung des Netzes									*/
/************************************************************************************************/

NE Akt_Element(NetzElement *Feld,int zahl,int i)
{
	int z;

/************************************************************************************************/
/* Feld mit zu verschiebender Zahl wird gesucht. Feldeintraege von leeren Feld und diesem Feld  */
/* werden getauscht. Danach wird Spielfeld aktualisiert, indem man wie bei der Ausgangsposition */
/* alle Zeiger aktualisiert.									*/
/************************************************************************************************/

	for(z=0;z<=12;z++)
	{
		if(Feld[z].eintrag==zahl) break;
		else ;
	}
	Feld[z].eintrag=0;
	Feld[i].eintrag=zahl;
	i=12;
	for (z=1;z<=12;z++)
	{
		if(z==12) 	Feld[12].zeiger1=&Feld[1].eintrag;
		else
		{
			Feld[z].zeiger1=&Feld[z+1].eintrag;
		}
		Feld[z].zeiger2=&Feld[i].eintrag;
		if((z==2) || (z==6) || (z==10)) Feld[z].zeiger3=&Feld[0].eintrag;
		else
		{
			Feld[z].zeiger3=NULL;
		}
		i=z;
	}
	Feld[0].zeiger1=&Feld[2].eintrag;
	Feld[0].zeiger2=&Feld[10].eintrag;
	Feld[0].zeiger3=&Feld[6].eintrag;
	return Feld;
}

/************************************************************************************************/
/* Loeschen des Netzes										*/
/************************************************************************************************/

void Loeschen(NetzElement *Feld)
{
	free(Feld);
}

/************************************************************************************************/
/* Abbruch falls Spielende erreicht ist							        */
/************************************************************************************************/

int Ziel2(NetzElement *Feld)
{
	int i;
	for(i=0;i<12;i++)
	{
		if(Feld[i].eintrag==i);
		else break;
	}
	return i;
}

/************************************************************************************************/
/* Ausgabe des aktuellen Spielbildes.								*/
/************************************************************************************************/

void Spielbild(NetzElement *Feld,int zahl)
{
	int i,j=12,r;
	textsize(1.5,1.5);
	Punkte(xx,yy,x,y);
	Bild(xx,yy,x,y,zahl);
	color(0);
	
/************************************************************************************************/
/* 4 for-Schleifen um die Feldeintraege auf die richtige Position zu setzen, da Feldeintraege   */
/* nicht in der Reihenfolge sind, wie Punkte gesetzt werden. Grafische Ausgabe der Zahlen auf   */
/* die entsprechende Position.									*/
/************************************************************************************************/
 
	for(i=0;i<=2;i++)
	{
		move2((xx[i]-0.5),yy[i]-0.75);
		for(r=0;r<=12;r++)
		{
			if(Feld[j].eintrag==r) drawstr(Zahl[r]); 	 			
			else ;
  		}
 		j--;
	}
	j=0;
	for(i=3;i<=3;i++)
	{
		move2((xx[i]-0.5),yy[i]-0.75);
		for(r=0;r<=12;r++)
		{
			if(Feld[j].eintrag==r) drawstr(Zahl[r]);   			 	
			else ;
	    	} 
	}
	j=2;
	for(i=4;i<=5;i++)
	{
		move2((xx[i]-0.5),yy[i]-0.75);
		for(r=0;r<=12;r++)
		{
			if(Feld[j].eintrag==r) drawstr(Zahl[r]);    		 	
			else ;  	
		}
		j--;
	}
	j=9;
	for(i=6;i<=12;i++)
	{
		move2((xx[i]-0.5),yy[i]-0.75);
		for(r=0;r<=12;r++)
		{
			if(Feld[j].eintrag==r) drawstr(Zahl[r]);   		 	
			else ; 		
		}
		j--;
	}					
}

/************************************************************************************************/
/* Spiel an sich										*/
/************************************************************************************************/
int Spielen(int schwgrad)
{	
	int a=0,u=1,zahl=0,zi=0,zuege=0;
	char string[2];
	
/************************************************************************************************/
/* Netzelement generieren. Neues Feld erzeugen. Spielausgangssituation erzeugen. Spielbild aus- */
/* geben. Danach wird ueberprueft welche Zahl verschoben werden soll. Falls Zahl nicht zu ver-  */
/* schieben geht wird nix gemacht, Abbruch mit irgendeiner anderen Taste.			*/
/************************************************************************************************/

	NetzElement *Feld;
	Feld=Element_neu();
	Feld=Netz_neu(Feld);
	Feld=Verschieben(Feld,schwgrad);
	Spielbild(Feld,0);
	while(zi!=12)
	{
		while(Feld[a].eintrag!=0) a++;
		while(u!=0)
		{
			Spielbild(Feld,zahl);
			color(3);
			move2(-1.,-10.);
			getstring(3,string);
			zahl=atoi(string);
			if(zahl==13)
			{
				Loeschen(Feld);Hauptmenue();return 0;   	 	 	  
			}  		  		

/***********************************************************************************************/
/* Falls kein Zeiger vom leeren Feld, auf das Feld zeigt, wo Zahl verschoben werden soll, wird */
/* nix gemacht, ansonsten wird Zahl verschoben. Spiel wird solange ausgefuert bis Zielposition */
/* erreicht ist.									       */
/***********************************************************************************************/
	
			if (((*Feld[a].zeiger1)!=zahl) && ((*Feld[a].zeiger2)!=zahl)) 		 			
			{
				if ( (a==0) || (a==2) || (a==6) || (a==10) )
				{
					if((*Feld[a].zeiger3)!=zahl)
					{
						u=1;
					}	
					else u=0;
				}
				else
				{
					u=1;
				}
			}
			else u=0;					
		}
		zuege++;
		Feld=Akt_Element(Feld,zahl,a);	
		Spielbild(Feld,zahl);
		a=0;
		u=1;
		zi=Ziel2(Feld);
	}
	Loeschen(Feld);
	color(0);
	return zuege;
}