Bloecke-Minigame/Blöcke/Map.cpp

#include "Map.h"
#include <InitDatei.h>
#include <Datei.h>
#include <KSGTDatei.h>
#include <Zeit.h>
#include <Text.h>
#include <TastaturEreignis.h>
#include <MausEreignis.h>

// Inhalt der Map Klasse aus Map.h
// Konstruktor
Map::Map()
{
	map = new RCArray< Array< int > >();
	score = 0;
	breite = 0;
	höhe = 0;
	geschwindigkeit = 0;
	bAnzahl = 0;
	next = 0;
	beendet = 1;
	sr = 1;
	rend = 0;
	ref = 1;
}

// Destruktor
Map::~Map()
{
	speichern();
	map->release();
}

// private
void Map::remove( int x, int y )
{
	if( !map->z( x ) || !map->z( x )->hat( y ) || !map->z( x )->get( y ) )
		return;
	int f = map->z( x )->get( y );
	map->z( x )->set( 0, y );
	if( !f )
		return;
	if( map->z( x - 1 ) && map->z( x - 1 )->hat( y ) && map->z( x - 1 )->get( y ) == f )
		remove( x - 1, y );
	if( map->z( x + 1 ) && map->z( x + 1 )->hat( y ) && map->z( x + 1 )->get( y ) == f )
		remove( x + 1, y );
	if( map->z( x ) && map->z( x )->hat( y - 1 ) && map->z( x )->get( y - 1 ) == f )
		remove( x, y - 1 );
	if( map->z( x ) && map->z( x )->hat( y + 1 ) && map->z( x )->get( y + 1 ) == f )
		remove( x, y + 1 );
}

// nicht constant
void Map::reset()
{
	next = 0;
	beendet = 0;
	score = 0;
	map->leeren();
	InitDatei *opd = new InitDatei( "data/Minigames/Blöcke/data/optionen.ini" );
	if( !opd->laden() )
		DateiPfadErstellen( "data/Minigames/Blöcke/data/optionen.ini" );
	breite = 20;
	if( opd->wertExistiert( "Breite" ) )
		breite = (int)*opd->zWert( "Breite" );
	else
		opd->addWert( "Breite", "20" );
	höhe = 12;
	if( opd->wertExistiert( "Height" ) )
		höhe = (int)*opd->zWert( "Height" );
	else
		opd->addWert( "Height", "12" );
	bAnzahl = 5;
	if( opd->wertExistiert( "Farben" ) )
		bAnzahl = (int)*opd->zWert( "Farben" );
	else
		opd->addWert( "Farben", "5" );
	geschwindigkeit = 4000;
	if( opd->wertExistiert( "Geschwindigkeit" ) )
		geschwindigkeit = (int)*opd->zWert( "Geschwindigkeit" );
	else
		opd->addWert( "Geschwindigkeit", "4000" );
	bool fortsetzen = 0;
	if( opd->wertExistiert( "Fortsetzen" ) )
		fortsetzen = (int)*opd->zWert( "Fortsetzen" ) != 0;
	else
		opd->addWert( "Fortsetzen", "0" );
	opd->speichern();
	opd->release();
	if( fortsetzen && DateiExistiert( "data/Minigames/Blöcke/data/game.save" ) )
	{
		Datei *save = new Datei();
		save->setDatei( "data/Minigames/Blöcke/data/game.save" );
		save->open( Datei::Style::lesen );
		int br = 0;
		int hö = 0;
		save->lese( (char*)&br, 4 );
		save->lese( (char*)&hö, 4 );
		if( br == breite && hö == höhe )
		{
			save->lese( (char*)&score, 4 );
			for( int x = 0; x < breite; x++ )
			{
				map->set( new Array< int >(), x );
				for( int y = 0; y < höhe; y++ )
				{
					int f = 0;
					save->lese( (char*)&f, 4 );
					map->z( x )->set( f, y );
				}
			}
			next = geschwindigkeit / 1000.0;
		}
		save->close();
		save->release();
		int xOff = 0;
		for( int x = 0; x < breite; x++ )
		{
			if( !map->z( x - xOff ) )
				continue;
			Array< int > *row = map->z( x - xOff );
			int yOff = 0;
			for( int y = 0; y < höhe; y++ )
			{
				if( row->hat( y - yOff ) && !row->get( y - yOff ) )
				{
					row->remove( y - yOff );
					yOff++;
				}
			}
			bool del = 1;
			for( int y = 0; y < höhe; y++ )
				del &= !row->hat( y - yOff ) || !row->get( y - yOff );
			if( del )
			{
				map->remove( x - xOff );
				xOff++;
			}
		}
	}
}

void Map::doMausEreignis( MausEreignis &me )
{
	if( beendet )
		return;
	if( me.id == ME_RRechts )
		next = 0;
	if( me.id != ME_RLinks )
		return;
	int x = (int)( me.mx / ( 800.0 / breite ) );
	int y = (int)( höhe - ( me.my / ( 500.0 / höhe ) ) );
	if( !map->z( x ) || !map->z( x )->hat( y ) || !map->z( x )->get( y ) )
		return;
	bool remove = 0;
	int f = map->z( x )->get( y );
	if( map->z( x - 1 ) && map->z( x - 1 )->hat( y ) && map->z( x - 1 )->get( y ) == f )
		remove = 1;
	if( map->z( x + 1 ) && map->z( x + 1 )->hat( y ) && map->z( x + 1 )->get( y ) == f )
		remove = 1;
	if( map->z( x ) && map->z( x )->hat( y - 1 ) && map->z( x )->get( y - 1 ) == f )
		remove = 1;
	if( map->z( x ) && map->z( x )->hat( y + 1 ) && map->z( x )->get( y + 1 ) == f )
		remove = 1;
	if( !remove )
		return;
	rend = 1;
	this->remove( x, y );
	int xOff = 0;
	for( int x = 0; x < breite; x++ )
	{
		if( !map->z( x - xOff ) )
			continue;
		Array< int > *row = map->z( x - xOff );
		int yOff = 0;
		for( int y = 0; y < höhe; y++ )
		{
			if( row->hat( y - yOff ) && !row->get( y - yOff ) )
			{
				row->remove( y - yOff );
				yOff++;
			}
		}
		bool del = 1;
		for( int y = 0; y < höhe; y++ )
			del &= !row->hat( y - yOff ) || !row->get( y - yOff );
		if( del )
		{
			score++;
			map->remove( x - xOff );
			xOff++;
		}
	}
}

void Map::doTastaturEreignis( TastaturEreignis &te )
{
	if( te.id == TE_Release )
		next = 0;
}

bool Map::tick( double tickVal )
{
	bool ret = rend;
	rend = 0;
	if( beendet )
		return ret;
	if( sr )
		srand( (int)time( 0 ) );
	sr = 0;
	next -= tickVal;
	if( next < 0 )
	{
		next = geschwindigkeit / 1000.0;
		Array< int > *n = new Array< int >();
		for( int i = 0; i < höhe; i++ )
		{
			int val = rand() % bAnzahl;
			switch( val )
			{
			case 0:
				n->set( 0xFFFF0000, i );
				break;
			case 1:
				n->set( 0xFF00FF00, i );
				break;
			case 2:
				n->set( 0xFF0000FF, i );
				break;
			case 3:
				n->set( 0xFFFFFF00, i );
				break;
			case 4:
				n->set( 0xFF00FFFF, i );
				break;
			case 5:
				n->set( 0xFFFF00FF, i );
				break;
			case 6:
				n->set( 0xFFFFFFFF, i );
				break;
			case 7:
				n->set( 0xFFFF5555, i );
				break;
			case 8:
				n->set( 0xFF55FF55, i );
				break;
			case 9:
				n->set( 0xFF5555FF, i );
				break;
			default:
				n->set( 0xFF000000, i );
				break;
			}
		}
		map->add( n, 0 );
		if( map->z( breite ) )
		{
			Array< int > *row = map->z( breite );
			for( int i = 0; i < höhe; i++ )
			{
				if( row->hat( i ) )
					beendet |= row->get( i ) != 0;
			}
			if( beendet )
			{
				KSGTDatei *stb = new KSGTDatei( "data/Minigames/Blöcke/data/score.ksgt" );
				if( !stb->laden() )
					DateiPfadErstellen( "data/Minigames/Blöcke/data/score.ksgt" );
				RCArray< Text > *zeile = new RCArray< Text >();
				Zeit *zeit = getZeit();
				zeile->add( zeit->getZeit( "y-m-d h:i:s" ) );
				zeit->release();
				Text *scoreT = new Text();
				scoreT->append( score );
				zeile->add( scoreT );
				Text *breiteT = new Text();
				breiteT->append( breite );
				zeile->add( breiteT );
				Text *höheT = new Text();
				höheT->append( höhe );
				zeile->add( höheT );
				Text *geschwindigkeitT = new Text();
				geschwindigkeitT->append( geschwindigkeit );
				zeile->add( geschwindigkeitT );
				Text *bAnzahlT = new Text();
				bAnzahlT->append( bAnzahl );
				zeile->add( bAnzahlT );
				stb->addZeile( 6, zeile );
				zeile->release();
				stb->speichern();
				stb->release();
                DateiRemove( "data/Minigames/Blöcke/data/game.save" );
			}
		}
		map->remove( breite );
		ret = 1;
	}
	return ret;
}

void Map::render( Bild &zRObj )
{
	for( int x = 0; x < breite; x++ )
	{
		if( !map->z( x ) )
			continue;
		Array< int > *row = map->z( x );
		for( int y = 0; y < höhe; y++ )
		{
			if( !row->hat( y ) )
				continue;
			int xs = (int)( x * ( 800.0 / breite ) );
			int ys = (int)( ( höhe - y - 1 ) * ( 500.0 / höhe ) );
			int xe = (int)( ( x + 1 ) * ( 800.0 / breite ) );
			int ye = (int)( ( höhe - y ) * ( 500.0 / höhe ) );
			zRObj.fillRegion( xs, ys, xe - xs, ye - ys, row->get( y ) );
		}
	}
}

// constant
void Map::speichern() const
{
	if( !beendet )
	{
		Datei *d = new Datei();
		d->setDatei( "data/Minigames/Blöcke/data/game.save" );
		d->erstellen();
		d->open( Datei::Style::schreiben );
		d->schreibe( (char*)&breite, 4 );
		d->schreibe( (char*)&höhe, 4 );
		d->schreibe( (char*)&score, 4 );
		for( int x = 0; x < breite; x++ )
		{
			for( int y = 0; y < höhe; y++ )
			{
				int f = 0;
				if( map->z( x ) && map->z( x )->hat( y ) )
					f = map->z( x )->get( y );
				d->schreibe( (char*)&f, 4 );
			}
		}
		d->close();
		d->release();
	}
	else
		DateiRemove( "data/Minigames/Blöcke/data/game.save" );
}

int Map::getScore() const
{
	return score;
}

bool Map::istBeendet() const
{
	return beendet;
}

// Reference Counting
Map *Map::getThis()
{
	ref++;
	return this;
}

Map *Map::release()
{
	ref--;
	if( !ref )
		delete this;
	return 0;
}