Source: src/cl_script.cc


Annotated List
Files
Globals
Hierarchy
Index
//sripting object

#include "cl_script.h"

EVENT_DRIVER *my_event;
SCRIPT *my_script;
ENGINE *engine;
LUA_WRAPPER *lw;

void SCRIPT::init()
{
	engine_internal = NULL;
	lua = NULL;
	event = NULL;
	my_script = this;
	status = 0;
}

void SCRIPT::connect_engine(ENGINE *e)
{
	engine_internal = e;
	engine = e;
}

void SCRIPT::connect_luawrapper(LUA_WRAPPER *l)
{
	lua = l;
	lw = l;
}

void SCRIPT::connect_event(EVENT_DRIVER *ev)
{
	event = ev;
	my_event = ev;
}

void SCRIPT::register_functions()
{
	lw->reg(open_anim, 	HLP_OPEN_ANIM);
	lw->reg(load_anim, 	HLP_LOAD_ANIM);
	lw->reg(close_anim,	HLP_CLOSE_ANIM);
	
//	lw->reg(create_level,	HLP_CREATE_LEVEL);
	lw->reg(create_object,	HLP_CREATE_OBJECT);
	lw->reg(destroy_object, HLP_DESTROY_OBJECT);
	lw->reg(destroy_all_objects, HLP_DESTROY_ALL_OBJECTS);
//	lw->reg(default_level,	HLP_DEFAULT_LEVEL);
	lw->reg(echo,		HLP_ECHO);
	lw->reg(exec,		HLP_EXEC);
	lw->reg(exec,		HLP_INCLUDE);
	lw->reg(game_type,	HLP_GAME_TYPE);
	lw->reg(modify_xy,	HLP_MODIFY_XY);
	lw->reg(set_anim_as_texture, HLP_SET_ANIM_AS_TEXTURE);
	lw->reg(set_datasrc,	HLP_SET_DATASRC);
	
	lw->reg(rem,		HLP_REM);
	
	lw->reg(play_music,	HLP_PLAY_MUSIC);
	lw->reg(stop_music,	HLP_STOP_MUSIC);
	lw->reg(load_sound,	HLP_LOAD_SOUND);
	lw->reg(play_sound,	HLP_PLAY_SOUND);

	lw->reg(reg,		HLP_REG);

	lw->reg(kill_engine,	HLP_KILLENGINE);
	lw->reg(kill_engine,	HLP_QUIT);
	lw->reg(kill_engine,	HLP_EXIT);

	lw->reg(create_widget,	HLP_CREATE_WIDGET);
	lw->reg(message,	HLP_MESSAGE);

	lw->reg(set_avatar,	HLP_SET_AVATAR);
	
	lw->reg(map_zero,	HLP_MAP_ZERO);
//	lw->reg(map_dimension,	HLP_MAP_DIMENSION);
//	lw->reg(middle_map,	HLP_MIDDLE_MAP);
//	lw->reg(background_map,	HLP_BACKGROUND_MAP);
	lw->reg(redraw,		HLP_REDRAW);
//	lw->reg(printmap,	HLP_PRINT_MAP);
	lw->reg(help,		HLP_HELP);
	
	lw->reg(cmd_expand,	HLP_CMD_EXPAND);
	lw->reg(cmd_noexpand,	HLP_CMD_NOEXPAND);
	lw->reg(version,	HLP_VERSION);
	lw->reg(author,		HLP_AUTHOR);

	lw->reg(create_room,	HLP_CREATE_ROOM);
	lw->reg(change_room,	HLP_CHANGE_ROOM);
	
#ifdef DEVELOP
	lw->reg(tile_list,	HLP_TILE_LIST);
#endif
}

void SCRIPT::import(string s)
{
	int p;
	for_each_file("*.dat",0,import_datafile,p);
}

void SCRIPT::load_data()
{
	string s;
	DATASRC *d;
	d = info_datafile("",engine->data.fname("info"));
	if(d) {
		if(!d->internal) {
			s = engine->data.actual_fname();
			s = s + "#config";
			message("Trying to load data %s",s.c_str());
			lw->do_alleg_file(s);
		} else {
			message("Internal [%s]", s.c_str());
		}
	}
}

void SCRIPT::mode(int i)
{
	status = i;
}

int SCRIPT::mode()
{
	return status;
}




//------------- Internal data structure -----------

void create_object(string name, map< string,int > numbers, map< string, string > strings)
{
	message("Creating object: %s", name.c_str());
	
	if(engine->object.create(name)) {
		engine->object.place(name, numbers["x"], numbers["y"]);
		engine->object.set_anim(name, numbers["animation"], numbers["animpos"], numbers["animspeed"]);
		engine->object.connect_image(name, engine->anim.get(strings["anim"]));

		//object types - Integer
		engine->object.prop(name, OBJ_BORDER_X1, 	numbers[OBJ_BORDER_X1]);
		engine->object.prop(name, OBJ_BORDER_Y1, 	numbers[OBJ_BORDER_Y1]);
		engine->object.prop(name, OBJ_BORDER_X2, 	numbers[OBJ_BORDER_X2]);
		engine->object.prop(name, OBJ_BORDER_Y2, 	numbers[OBJ_BORDER_Y2]);
		engine->object.prop(name, OBJ_ENERGY, 		numbers[OBJ_ENERGY]);
		engine->object.prop(name, OBJ_GROUP, 		numbers[OBJ_GROUP]);
		engine->object.prop(name, OBJ_KEY_LEFT, 	numbers[OBJ_KEY_LEFT]);
		engine->object.prop(name, OBJ_KEY_RIGHT, 	numbers[OBJ_KEY_RIGHT]);
		engine->object.prop(name, OBJ_KEY_DOWN, 	numbers[OBJ_KEY_DOWN]);
		engine->object.prop(name, OBJ_KEY_UP,	 	numbers[OBJ_KEY_UP]);
		engine->object.prop(name, OBJ_SCORE, 		numbers[OBJ_SCORE]);
		engine->object.prop(name, OBJ_SPEED_X, 		numbers[OBJ_SPEED_X]);
		engine->object.prop(name, OBJ_SPEED_Y, 		numbers[OBJ_SPEED_Y]);
		engine->object.prop(name, OBJ_WEIGHT, 		numbers[OBJ_WEIGHT]);

		//object types - Bool
		engine->object.prop(name, OBJ_ACTIVE,		numbers[OBJ_ACTIVE]);
		engine->object.prop(name, OBJ_CONTROL,		numbers[OBJ_CONTROL]);
		engine->object.prop(name, OBJ_DIRECTIONS, 	numbers[OBJ_DIRECTIONS]);
		engine->object.prop(name, OBJ_PICK, 		numbers[OBJ_PICK]);

		//object types - String
		engine->object.prop(name, OBJ_COLLISION,	strings[OBJ_COLLISION]);
		engine->object.prop(name, OBJ_MOTION,		strings[OBJ_MOTION]);
		engine->object.prop(name, OBJ_PARACHUTE,	strings[OBJ_PARACHUTE]);
		engine->object.prop(name, OBJ_ROOM,		strings[OBJ_ROOM]);
		
		engine->object.connect_imgkey(name, strings["animkey"]);
	}
}

//luawrapper read arg of function in backward order

int create_object(lua_State *l)
{
	string name;
	map< string, int > numbers;
	map< string, string > strings;
	
	get_table(l, numbers, strings);
	name = lget_arg_str(l);

	create_object(name, numbers, strings);
	
	return 1;
}


int destroy_object(lua_State *l)
{
	string name;

	name = lget_arg_str(l);

	message("Destroying object: %s", name.c_str());
	engine->object.destroy(name);
	return 0;
}

int destroy_all_objects(lua_State *l)
{
	message("Destroying all objects");
	engine->object.destroy_all();
	return 0;
}

int rem(lua_State *l)	//good old Basic :)
{			//use as comment
	return 0;
}

int modify_xy(lua_State *l)
{
	string name;
	int x,y;

	y = lget_arg_int(l);
	x = lget_arg_int(l);
	name = lget_arg_str(l);

	engine->object.place(name, x, y);
	return 1;
}

int set_datasrc(lua_State *l)
{
	string fname;
	
	fname = lget_arg_str(l);
	engine->data.set(fname);

	return 0;
}

int open_anim(lua_State *l)
{
	int sizex, sizey;
	string fname, name;
	
	sizey = lget_arg_int(l);
	sizex = lget_arg_int(l);
	fname = lget_arg_str(l);
	name = lget_arg_str(l);
	
	engine->anim.create(name);
	engine->anim.open(name, fname, sizex, sizey);
	return 0;
}

int load_anim(lua_State *l)
{
	int x1, y1, x2, y2;
	string name;

	y2 = lget_arg_int(l);
	x2 = lget_arg_int(l);
	y1 = lget_arg_int(l);
	x1 = lget_arg_int(l);
	name = lget_arg_str(l);

	engine->anim.load(name, x1, y1, x2, y2);
	return 0;
}

int close_anim(lua_State *l)
{
	string name;
	
	name = lget_arg_str(l);

	engine->anim.close(name);
	return 0;
}

int set_anim_as_texture(lua_State *l)
{
	string name, aname;
	
	aname = lget_arg_str(l);
	name = lget_arg_str(l);
	engine->anim.set_as_texture(name, aname);
	
	return 0;
}

int game_type(lua_State *l)
{
	string name;
	name = lget_arg_str(l);
	engine->object.game_type(name);
	return 0;
}

int play_music(lua_State *l)
{	
	string name, type;
	
	type = lget_arg_str(l);
	name = engine->data.fname(lget_arg_str(l));

	message("Loading music %s", name.c_str());
	engine->music.play(name, type);
	
	return 0;
}

int stop_music(lua_State *l)
{
	engine->music.stop();
	return 0;
}

int load_sound(lua_State *l)
{

	string name, aname;
	
	aname = lget_arg_str(l);
	name = lget_arg_str(l);

	message("Loading sound %s from %s", name.c_str(), aname.c_str());
	engine->sound.load(name,aname);
	return 0;
}

int play_sound(lua_State *l)
{
	string name;
	name = lget_arg_str(l);
	
	engine->sound.play(name);
	return 0;
}
	
int echo(lua_State *l)
{
	string msg;
	msg = lget_arg_str(l);	
	message("%s\n", msg.c_str());
	return 0;
}

int exec(lua_State *l) 
{
	string fname,dname;
	fname = lget_arg_str(l);
	dname = engine->data.fname(fname);
	if(exists(dname.c_str())) {			//1. try internal file
		fname = dname;
	} else {
		message("Executing external file");	//2. try external file
		if(!exists(fname.c_str())) {
			error("Unable to find file [%s] for execution",
					fname.c_str());
			return 0;
		}
	}
	message("Excuting file %s", fname.c_str());
	lw->do_alleg_file(fname);

	return 0;
}

int reg(lua_State *l)
{
	string name, aname;
	aname = lget_arg_str(l);
	name = lget_arg_str(l);
	engine->event.reg(name, aname);
	message("Event %s -> function %s", name.c_str(), aname.c_str());
	
	return 0;
}


int create_widget(lua_State *l)
{
	string name;
/*	map< string, int > numbers;
	map< string, string > strings;
	
	get_table(l, numbers, strings);
	name = lget_arg_str(l);*/

	engine->widget.create("default");
//	engine->widget_property(name, WIDGET_TEXT_CENTER, numbers[WIDGET_TEXT_CENTER]);
	
	message("Created widget %s", name.c_str());
	
	return 0;
}

int message(lua_State *l)
{
	string name, aname;
	int c = lw->argc();
	
	name = lget_arg_str(l);

	switch(c) {
		case 1: {
			engine->widget.message("",name);
			break;
			}
		case 2: {
			aname = lget_arg_str(l);
			engine->widget.message(aname,name);
			break;
			}
	}

	
	my_script->mode(UNIVERS_DIALOG);
	message("widget %s", name.c_str());
	
	return 0;
}

int kill_engine(lua_State *l)
{
	my_script->mode(UNIVERS_COLAPS);
	return 0;
}

int set_avatar(lua_State *l)
{
	string name;
	name = lget_arg_str(l);
	message("Setting %s as avatar", name.c_str());
	engine->object.set_avatar(name);
	
	return 0;
}

int map_zero(lua_State *l)
{
	string s;
	char c;
	s = lget_arg_str(l);
	c = s[0];
	message("Setting map zero to %c", c);
	engine->rooms.zero(c);
	
	return 0;
}

int help(lua_State *l)
{
	string name;
	
	switch(lw->argc()) {
		case 0: {
				message(lw->list_desc_functions());
				break;
			}
		case 1: {
				name = lw->get_str().c_str();
				message(lw->help_function(name));
				break;
			}
		default: {
				error("Wrong parameters");
			}
	}
	return 0;
}

DATASRC *info_datafile(string filename, string fname)
{
	DATASRC *d;
	if(lw->do_alleg_file(fname) == 1) {
		d = new DATASRC;
		d->author 	= lw->get_str("author");
		d->title	= lw->get_str("title");
		d->engine	= lw->get_str("engine");
		d->internal	= lw->get_int("internal");
		d->name		= lw->get_str("name");
		d->file		= filename;
		return d;
	} else {
		return NULL;
	}
}

void import_datafile(const char *filename, int attrib, int param)
{
	string fname, name;
	DATASRC *d;

#ifdef HARD_DEBUG
	cout << "Found file: " << filename << endl;
#endif
	fname = filename;
	fname += "#info";
	d = info_datafile(filename, fname);
	if (d!=NULL) {
		engine->data.add(name, d);
#ifdef DEBUG
		engine->data.print_info(name);
#endif
		engine->data.create(d->name, d->file);
	} else {
		cout << "Not datadisc. Skipping" << endl;
	}
}


int redraw(lua_State *l)
{
	my_event->add(EC_REDRAW);
	return 0;
}

/*
int printmap(lua_State *l)
{
	engine->level.print_text_maps();
	return 0;
}
*/
int cmd_expand(lua_State *l)
{
	my_event->add(EC_EXPAND);
	return 0;
}

int cmd_noexpand(lua_State *l)
{
	my_event->add(EC_NOEXPAND);
	return 0;
}

int version(lua_State *l)
{
	message("%s v.:%s",STR_ENGINE, STR_VERSION);
	message("%s", STR_URL);
	return 0;
}

int author(lua_State *l)
{
	message("%s",STR_AUTHOR);
	return 0;
}


int change_room(lua_State *l)
{
	string name;
	name = lget_arg_str(l);
	message("Changing room to %s", name.c_str());
	engine->stage.connect_data(engine->data.actual());
	engine->stage.select(name);
	return 0;
}


int create_room(lua_State *l)
{
	string name;
	map< string, int > numbers;
	map< string, string > strings;
	map< string, deque > tables;
	
	get_table(l, numbers, strings,tables);
	name = lget_arg_str(l);

	message("Creating room [%s]",name.c_str());
	create_room(name, numbers, strings, tables);

	return 1;
}


void create_room(string name, map< string,int > &numbers, map< string, string > &strings,
		map< string, deque > &tables)
{
	map::iterator i;
	map >::iterator j;
/*	for(i=strings.begin();i!=strings.end();i++) {
		cout << "[" << i->first << "]=[" << i->second << "]"<rooms.create(name);
	message("Trying to set size");
	engine->rooms.layer_size(name, numbers["width"], numbers["height"]);
	message(" Done");
	engine->rooms.tile_bg(name, tables["layer0"]);
	engine->rooms.tile_mid(name, tables["layer1"]);
	engine->rooms.tile_fg(name, tables["layer2"]);
	message(" - done");
/*	for(j=tables.begin();j!=tables.end();j++) {
		cout << "(" << j->first << ")" << endl;
	}*/
}

//Developer function
int tile_list(lua_State *l)
{
	engine->stage.tile_list();
	wait();
	my_event->add(EC_REDRAW);
	
	return 1;
}


Generated by: georgik on armada on Sat Jul 24 07:07:15 2004, using kdoc 2.0a54.