Name of the assigned function and model

function file_skip1line(var handle_file)
{	
	file_asc_write(handle_file, 13); //new line
	file_asc_write(handle_file, 10);
}

...
function write_to_txtblabla() {
  var handle_file = file_open_write (filepath_str);
  file_str_write(handle_file, "Enemy 1");
  file_skip1line(handle_file);
  file_str_write(handle_file, "Enemy 2");
  file_close(handle_file);
}

void save_into_file(){
	
	STRING* read_str = ""; STRING* write_str = ""; 
	STRING* before_str = ""; STRING* after_str = "";
	
	var fhandle = file_open_read("map.dat");
	if(fhandle == NULL){ error("File wasn't found!"); return; }
	
	var len_var = file_length(fhandle);	
	file_str_readto(fhandle, read_str, ";", len_var);	
	file_close(fhandle);
	
	// BEFORE string:
	var start_var = str_stri(read_str, "[ROOM 2]");
	str_cut(before_str, read_str, 0, start_var + 7);
	
	// AFTER string:
	var end_var = str_stri(read_str, "[ROOM 3]");
	str_cut(after_str, read_str, end_var, len_var);
	
	// get the part of the string, where we need to change stuff:
	str_cut(write_str, read_str, start_var + 8, end_var - 1);
	str_cpy(write_str, "THIS IS NOT THE SECOND ROOM!");
	
	// add empty space:
	str_cat(before_str, " ");
	// use that empty space to move pointer to the next line:
	str_setchr(before_str, str_len(before_str), 10);
	
	// add empty space to the stuff we've changed:
	str_cat(write_str, " ");
	// add changes to BEFORE string:
	str_cat(before_str, write_str);
	// use empty space at the end to move pointer to the next line:
	str_setchr(before_str, str_len(before_str), 10);
	// add AFTER str (so the whole string is complete now)
	str_cat(before_str, after_str);
	
	// write this all into the file:
	var fhandle = file_open_write("map.dat");
	file_str_write(fhandle, before_str);
	file_close(fhandle);
}

while (loop through every txt line of your save file) {
  1) get the current line and convert it to a lite-c string
  
  2) use the str_parse functions to get the value of that line

  3) use str_cmpni's to compare it content/description in some big nested if's to determine what to do with the value
}

#include <acknex.h>

#define LEVEL_COUNT        20
#define OBJECTS_MAX        10

FONT *fntArial = "Arial#20";

typedef struct OBJECT
{
	var x;
	var y;
	var z;
	var pan;
	var tilt;
	var roll;
	// and so...
} OBJECT;

OBJECT objects[LEVEL_COUNT][OBJECTS_MAX];

void objects_save ()
{
	file_save ( "saved.dat", objects, sizeof(OBJECT) * LEVEL_COUNT * OBJECTS_MAX );
}

void objects_load ()
{
	if ( !file_exists ( "saved.dat" ) )
		return;
	long size = 0;
	void *buffer = file_load ( "saved.dat", NULL, &size );
	memcpy ( objects, buffer, sizeof(OBJECT) * LEVEL_COUNT * OBJECTS_MAX );
	file_load ( NULL, buffer, &size );
}

void objects_zero ()
{
	memset ( objects, 0, sizeof(OBJECT) * LEVEL_COUNT * OBJECTS_MAX );
}

void evnPan ()
{
	var indexX = floor ( LEVEL_COUNT * mouse_pos.x / screen_size.x );
	var indexY = floor ( OBJECTS_MAX * mouse_pos.y / screen_size.y );
	if ( event_type == EVENT_CLICK )
		objects[indexX][indexY].x += 1;
	else if ( event_type == EVENT_RIGHTCLICK )
		objects[indexX][indexY].x -= 1;
}

void main ()
{
	video_mode = 10;
	mouse_mode = 4;
	enable_mouse = 2;
	wait(1);
	
	PANEL *pan = pan_create ( "", 1 );
	pan->size_x = screen_size.x;
	pan->size_y = screen_size.y;
	var stepX = pan->size_x / LEVEL_COUNT;
	var stepY = pan->size_y / OBJECTS_MAX;
	var y = 0;
	for ( ; y<OBJECTS_MAX; y+=1 )
	{
		var x = 0;
		for ( ; x<LEVEL_COUNT; x+=1 )
		{
			pan_setdigits ( pan, 0, (stepX/2)+x*stepX, (stepY/2)+y*stepY, "%.0f", fntArial, 1, &objects[x][y].x );
		}
	}
	pan->event = evnPan;
	pan->flags |= SHOW;
	
	on_s = objects_save;
	on_l = objects_load;
	on_r = objects_zero;
	
	while ( !key_esc )
		wait (1);
	
	pan_remove ( pan );
	sys_exit ( NULL );
}

#include <acknex.h>

STRING *str = "";

TEXT *txtLevels =
{
	string = ( "level00", "level01" );
}

TEXT *txtConfigs =
{
	string = (
		" -pal palette.pcx -az 0 -el 60 -sunrgb 58 58 58 -ambrgb 19 19 19  -fog1 100 100 100  -fog2 19 39 100  -fog3 100 19 19 -noportals -hiprec -litmapsonly -writelog -mesh -mergeacross -terralit -tesselate -close -solidsky -nodetail -quiet -supsam -threads 4 -gamma 2.25 -phongangle 120  -lmambient 50  -sizeshaded 236 -litres 0.37 -litcomp 0.20 -litmax 255 -litscale 0.68 -radsubdiv 64 -radbounce 3 -bound 56000 -fat 64  48  8  -narrow 32  32  0"
		" -pal palette.pcx -az 0 -el 60 -sunrgb 58 58 58 -ambrgb 19 19 19  -fog1 100 100 100  -fog2 19 39 100  -fog3 100 19 19 -noportals -hiprec -litmapsonly -writelog -mesh -mergeacross -terralit -tesselate -close -solidsky -nodetail -quiet -supsam -threads 4 -gamma 2.25 -phongangle 120  -lmambient 50  -sizeshaded 236 -litres 0.37 -litcomp 0.20 -litmax 255 -litscale 0.68 -radsubdiv 64 -radbounce 3 -bound 56000 -fat 64  48  8  -narrow 32  32  0"
	);
}

typedef struct
{
	char buffer[6000];
	char *chr;
	long size;
} ENT_BUFFER;

ENT_BUFFER entBuffer;

void entBuffer_startup ()
{
	entBuffer.chr = entBuffer.buffer;
	entBuffer.size = 0;
}

void entBufferLevel ( STRING *_str )
{
	long _size = str_len ( _str );
	memcpy ( entBuffer.chr, _str->chars, _size );
	entBuffer.chr += _size;
	*entBuffer.chr = 13;
	entBuffer.chr ++;
	*entBuffer.chr = 10;
	entBuffer.chr ++;
	entBuffer.size += _size + 2;
}

void entBufferAdd ( char *_chr, long _size )
{
	memcpy ( entBuffer.chr, _chr, _size );
	entBuffer.chr += _size;
	entBuffer.size += _size;
}

void main ()
{
	wait(1);
	var levelIndex = 0;
	for ( ; levelIndex<txtLevels->strings; levelIndex+=1 )
	{
		entBufferLevel ( (txtLevels->pstring)[levelIndex] );
		var entIndex = 0;
		str_cpy ( str, (txtLevels->pstring)[levelIndex] );
		str_cat ( str, ".$$M" );
		char *entityBlock = NULL;
		long size;
		char *buffer0 = file_load ( str, NULL, &size );
		char *buffer = buffer0;
		char *bufferLast = buffer + size;
		for ( ; buffer<buffer0+size; buffer++ )
		{
			if ( *buffer == 123 ) // {
			{
				var pos = str_stri ( buffer, "model" );
				if ( pos )
					if ( pos < 10 )
						entityBlock = buffer;
			}
			if ( entityBlock )
			{
				if ( *buffer == 125 ) // }
				{
					long size2 = 3 + (long)buffer - (long)entityBlock;
					entBufferAdd ( entityBlock, size2 );
					long size3 = size;
					size3 -= (long)buffer - (long)buffer0;
					memcpy ( entityBlock, buffer+3, size3 );
					size -= size2;
					buffer = entityBlock - 1;
					entityBlock = NULL;
				}
			}
		}
		
		file_save ( str, buffer0, size );
		file_load ( NULL, buffer0, &size );
		
		str_cat ( str, (txtConfigs->pstring)[levelIndex] );
		exec_wait  ( "wwmp2wmb.exe", str );
	}
	
	file_save ( "level_entities.txt", entBuffer.buffer, entBuffer.size );
	
	sys_exit ( NULL );
}

#include <acknex.h>

// -----------------------------------------------------------------------------------------------------

STRING *strFilename = NULL;
STRING *strOptions = "";

// -----------------------------------------------------------------------------------------------------

// Levels
TEXT *txtLevels =
{
	string = ( 
		"level00.$$M", 
		"level01.$$M"
	);
}

// Compilation configurations for each level
// They can be copied from 'buildlog.txt' file created by WED compilation process
TEXT *txtConfigs =
{
	string = (
		" -pal palette.pcx -az 0 -el 60 -sunrgb 58 58 58 -ambrgb 19 19 19  -fog1 100 100 100  -fog2 19 39 100  -fog3 100 19 19 -noportals -hiprec -litmapsonly -writelog -mesh -mergeacross -terralit -tesselate -close -solidsky -nodetail -quiet -supsam -threads 4 -gamma 2.25 -phongangle 120  -lmambient 50  -sizeshaded 236 -litres 0.37 -litcomp 0.20 -litmax 255 -litscale 0.68 -radsubdiv 64 -radbounce 3 -bound 56000 -fat 64  48  8  -narrow 32  32  0"
		" -pal palette.pcx -az 0 -el 60 -sunrgb 58 58 58 -ambrgb 19 19 19  -fog1 100 100 100  -fog2 19 39 100  -fog3 100 19 19 -noportals -hiprec -litmapsonly -writelog -mesh -mergeacross -terralit -tesselate -close -solidsky -nodetail -quiet -supsam -threads 4 -gamma 2.25 -phongangle 120  -lmambient 50  -sizeshaded 236 -litres 0.37 -litcomp 0.20 -litmax 255 -litscale 0.68 -radsubdiv 64 -radbounce 3 -bound 56000 -fat 64  48  8  -narrow 32  32  0"
	);
}

// -----------------------------------------------------------------------------------------------------

// A buffer and a position and size control in order to hold all the entity related data
typedef struct
{
	char buffer[6000];
	char *chr;
	long size;
} ENT_BUFFER;

ENT_BUFFER entBuffer;

void entBuffer_startup ()
{
	entBuffer.chr = entBuffer.buffer;
	entBuffer.size = 0;
}

// Add a string to the entities buffer
void entBufferAddString ( STRING *_str )
{
	long _size = str_len ( _str );
	memcpy ( entBuffer.chr, _str->chars, _size );
	entBuffer.chr += _size;
	*entBuffer.chr = 13; // [Enter]
	entBuffer.chr ++;
	*entBuffer.chr = 10; // Linebreak
	entBuffer.chr ++;
	entBuffer.size += _size + 2;
}

// Add a char buffer to the entities buffer
void entBufferAdd ( char *_chr, long _size )
{
	memcpy ( entBuffer.chr, _chr, _size );
	entBuffer.chr += _size;
	entBuffer.size += _size;
}

// -----------------------------------------------------------------------------------------------------

void main ()
{
	wait(1);
	var levelIndex = 0;
	// Loop through all levels
	for ( ; levelIndex<txtLevels->strings; levelIndex+=1 )
	{
		// Get the pointer to the level name string
		strFilename = (txtLevels->pstring)[levelIndex];
		// Check the existence of the level file
		if ( !file_exists ( strFilename ) )
		{
			str_cpy ( strFilename, " file not found!" );
			error ( strFilename );
			break;
		}
		// Add level name to entities buffer
		entBufferAddString ( strFilename );
		
		// A variable will contain the size of the file buffer
		long sizeFile;
		// Load the file into a buffer allocated by the engine
		char *bufferStart = file_load ( strFilename, NULL, &sizeFile );
		// Make a copy of the file buffer in order to restore the file after compiling
		char *bufferBackup = sys_malloc ( sizeFile );
		memcpy ( bufferBackup, bufferStart, sizeFile );
		
		// A pointer to hold the starting byte of a detected entity
		char *entityBlock = NULL;
		// A variable will contain the size of the modified file buffer. It is same as the original file buffer size at the beginning
		long sizeResult = sizeFile;
		// A pointer to go through the buffer
		char *buffer = bufferStart;
		// Go through the buffer byte by byte
		for ( ; buffer<bufferStart+sizeResult; buffer++ )
		{
			// If a description of a model has been previously detected
			if ( entityBlock )
			{
				// If the pointed byte is a closing bracket
				if ( *buffer == 125 ) // }
				{
					// Compute the size of the entity description block
					long sizeBlock = 3 + (long)buffer - (long)entityBlock;
					// Add the entity block to the entities buffer
					entBufferAdd ( entityBlock, sizeBlock );
					// Compute the size of the remaining buffer
					long sizeRemaining = sizeResult - ( (long)buffer - (long)bufferStart );
					// Move the remaining buffer to the starting byte of the entity, so the entity is completelly removed from the file buffer
					memcpy ( entityBlock, buffer+3, sizeRemaining );
					// Reduce the size of the file buffer by the size of the entity block
					sizeResult -= sizeBlock;
					// Move the buffer cheking pointer to the start of the remaining buffer, as it has been moved
					buffer = entityBlock - 1;
					// Remove previously saved starting byte
					entityBlock = NULL;
				}
			}
			else // If a description of a model has not been previously detected
			{
				// If the pointed byte is an opening bracket
				if ( *buffer == 123 ) // {
				{
					// Look for the word 'model' into the remaining buffer
					var pos = str_stri ( buffer, "model" );
					// If it exists
					if ( pos )
					{
						// If it exists near the opening bracket
						if ( pos < 10 )
						{
							// Save the the actual byte as the starting byte of the description of a model
							entityBlock = buffer;
						}
					}
					else // If it does not exists
					{
						// There is no reason to continue looking into the buffer
						// Break the loop
						break;
					}
				}
			}
		}
		
		// Save the modified buffer, with no models, in order to compile the empty level
		file_save ( strFilename, bufferStart, sizeResult );
		
		// Build the configuration for compiling process
		str_cpy ( strOptions, strFilename );
		str_cat ( strOptions, (txtConfigs->pstring)[levelIndex] );
		// Compile the level
		exec_wait  ( "wwmp2wmb.exe", strOptions );
		
		// Restore the level file to its initial state
		file_save ( strFilename, bufferBackup, sizeFile );
		// Remove the level buffer
		file_load ( NULL, bufferStart, &sizeFile );
		// Remove the level buffer copy
		sys_free ( bufferBackup );
	}
	
	// If everything went fine
	if ( levelIndex == txtLevels->strings )
	{
		// Save the entities buffer 
		file_save ( "level_entities.txt", entBuffer.buffer, entBuffer.size );
	}
	
	// Exit the program ;)
	sys_exit ( NULL );
}

//For loading/reading (go to next line and read)
function read_line(var handle) {
	str_cpy(tmp_str, ""); //reset previous read lines
	file_str_readto(handle, tmp_str, "\n", 10000); //read next line
	str_trim(tmp_str); //remove spaces from value
	str_trunc(tmp_str, 1); //remove \n (/remove delimiter)
}

//For saving/writing (write blank to next line)
function skip_line(var handle) {	
	file_asc_write(handle, 13); //new line
	file_asc_write(handle, 10);
}