Sorry your browser is not supported!

class piece // Individual piece
{
public:

	int angle;	// Initial angle
	int sides;	// Number of sides

/*
-------------------------------------------------
Sides
-------------------------------------------------
2 = Los
3 = Tri
4 = Quad
6 = Hex
-------------------------------------------------
*/

	int position;	// Starting random position
	int status;		// Piece status

/*
-------------------------------------------------
Status
-------------------------------------------------
0 = Unexistent
1 = Playable
2 = Locked
3 = Unlit
4 = Hiden
*/

	int layer;	// Piece layer for layered puzzles

	float X; // X on world
	float Y; // Y on world

	void create ( int object, int level );
};

class level // Each level
{
public:

	int lastPiece;
	int time;
	int currentLevel;

	piece levelPiece [ 100 ];

	void loadLevel	();
	void initLevel	();
	void addPiece	();
};

// Includes

# pragma once

#include "DarkGDK.h"
#include "stdio.h"

#include "classes.h"
#include "construction.h"
#include "edit.h"
#include "game.h"
#include "levels.h"
#include "menus.h"
#include "test.h"

// Piece functions

void piece::create ( int object, int level )
{
	object = ( level * 100 ) + object; // Final Object Number

	if ( status != 0 )
	{
		dbCloneObject		( object, sides );
		dbTextureObject		( object, 4 );
		dbPositionObject	( object, 0, 0, 0 );
	}
}

// Level functions

void level::loadLevel ()
{
	// Open file regarding the level

	char file [ 512 ];

	sprintf ( file, "%d.lvl", currentLevel );

	dbOpenToRead ( 1, file ); // Open the file for reading

	// Init variables and write it to file
	
	lastPiece = dbReadByte ( 1 );

	for ( int a = 0; a < 100; a++ )
	{
		levelPiece [ a ].X			= dbReadFloat		( 1 );
		levelPiece [ a ].Y			= dbReadFloat		( 1 );
		levelPiece [ a ].angle		= dbReadByte		( 1 );
		levelPiece [ a ].layer		= dbReadByte		( 1 );
		levelPiece [ a ].sides		= dbReadByte		( 1 );
		levelPiece [ a ].status		= dbReadByte		( 1 );
		levelPiece [ a ].position	= dbReadByte		( 1 );

		levelPiece [ a ].create ( a, currentLevel );
	}

	dbCloseFile ( 1 );
}

void level::initLevel ()
{
	// Open file regarding the level

	char file [ 512 ];

	sprintf ( file, "%d.lvl", currentLevel );

	if ( dbFileExist ( file ) ) dbDeleteFile ( file ); // Delete the file if it exists

	dbOpenToWrite ( 1, file ); // Open the file for reading

	// Init variables and write it to file
	
	lastPiece = 0; dbWriteByte ( 1, lastPiece );

	for ( int a = 0; a < 100; a++ )
	{
		levelPiece [ a ].X			= 0; dbWriteFloat	( 1, levelPiece [ a ].X );
		levelPiece [ a ].Y			= 0; dbWriteFloat	( 1, levelPiece [ a ].Y );
		levelPiece [ a ].angle		= 0; dbWriteByte	( 1, levelPiece [ a ].angle );
		levelPiece [ a ].layer		= 0; dbWriteByte	( 1, levelPiece [ a ].layer );
		levelPiece [ a ].sides		= 0; dbWriteByte	( 1, levelPiece [ a ].sides );
		levelPiece [ a ].status		= 0; dbWriteByte	( 1, levelPiece [ a ].status );
		levelPiece [ a ].position	= 0; dbWriteByte	( 1, levelPiece [ a ].position );
	}

	dbCloseFile ( 1 );
}

void level::addPiece ()
{
	lastPiece++;

	while ( levelPiece [ lastPiece ].sides == 0 )
	{
		int sides = sidesChooser();

		switch ( sides )
		{
		case 2	:levelPiece [ lastPiece ].sides = 2; break;
		case 3	:levelPiece [ lastPiece ].sides = 3; break;
		case 4	:levelPiece [ lastPiece ].sides = 4; break;
		case 5	:levelPiece [ lastPiece ].sides = 6; break;
		default	:levelPiece [ lastPiece ].sides = 0; break;
		}

		dbSync();
	}

	levelPiece [ lastPiece ].create ( lastPiece, currentLevel );

	clearMenu();
}

#ifndef __file_function_H__
#define __file_function_H__
#include <string>
#include <vector>


/* Made my own file functions since the ones in dgsdk didn't seam to function
 * properly. will add some encrytion functions aswell for the save menu.
 * i have open for write, read, and appened. and so far can handel string's,
 * int's and float's. i am using fprintf right now and that may change.
 */


int open_write(std::string strFileName);
int open_read(std::string strFileName);
int open_appened();

int close_file(std::string mode);

int write_string(std::string i);
int write_int(int i);
int write_float(float i);

std::string read_string();
int read_int();
float read_float();

bool file_eof(std::string mode);


#endif

#include "stdafx.h"
#include "file_functions.h"
#include <cstdio>
#include <fstream>

std::ofstream fout; // file output object
std::ifstream fin; // file input object
int open_write(std::string strFileName)
{
	fout.open(strFileName.c_str());
	return 1; //XXX add error checking.
}

int open_read(std::string strFileName)
{
	if (!fin.is_open())
	{
		fin.open(strFileName.c_str());
		return 1;
	}
	else
	{
		return 0; // file all ready open.
	}
}

int open_appened(std::string strFileName)
{
	fout.open(strFileName.c_str(), std::ios::app);
	return 1; //XXX add error checking.
}

int close_file(std::string mode)
{
	if (mode != "read")
	{
		fout.close();
		return 2;
	}else
	{
		fin.close();
		return 1;
	}
	return 0;
}

int write_string(std::string i)
{
	fout << i << "\n";
	return 1; //XXX add error checking.
}

int write_int(int i)
{
	fout << i << "\n";
	return 1; //XXX add error checking.
}

int write_float(float i)
{
	fout << i << "\n";
	return 1; //XXX add error checking.
}



std::string read_string()
{
	char buffer[100] = ""; // Buffer
	std::string buffer_str = "";
	fin >> buffer;
	buffer_str = buffer; // convert char back to string
	return buffer_str;
}

int read_int()
{
	int buffer_int = 0;
	fin >> buffer_int;
	return buffer_int;
}

float read_float()
{
	float buffer_float = 0.0f;
	fin >> buffer_float;	
	return buffer_float; //XXX add error checking.
}

bool file_eof(std::string mode)
{
	if (mode != "read")
	{
		return fout.good();
	}else
	{
		return fin.good();
		fin.good();
	}
}