From 10a0e290ac07524dc129cc2b227b0f9e95df0f8e Mon Sep 17 00:00:00 2001 From: Ben Beltran Date: Mon, 16 Apr 2012 09:39:52 -0500 Subject: first commit --- actor.cpp | 1020 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1020 insertions(+) create mode 100755 actor.cpp (limited to 'actor.cpp') diff --git a/actor.cpp b/actor.cpp new file mode 100755 index 0000000..12e5353 --- /dev/null +++ b/actor.cpp @@ -0,0 +1,1020 @@ +#include "stdafx.h" + +Actor::Actor(int xpos, int ypos, const char *spritepath, const char *scriptpath, Map *map, Audio *audio, Game_overwatch *ow, CLuaVirtualMachine& vm) : CLuaScript(vm){ + this->init(xpos,ypos,spritepath,scriptpath,NULL,LEFT,true,map,audio,ow,vm); +} + +Actor::Actor(int xpos, int ypos, const char *spritepath, const char *scriptpath, Actor *dad, Direction dir, bool phys, Map *map, Audio *audio, Game_overwatch *ow, CLuaVirtualMachine& vm) : CLuaScript(vm){ + this->init(xpos,ypos,spritepath,scriptpath,dad,dir,phys,map,audio,ow,vm); +} + +Actor::~Actor(){ + SDL_FreeSurface(sprite); + if(parent != NULL){ + parent->remove_bullet(); + } + overwatch->move_out(this); +} + +void Actor::init(int xpos, int ypos, const char *spritepath, const char *scriptpath, Actor *dad, Direction dir, bool phys, Map *map, Audio *aud, Game_overwatch *ow, CLuaVirtualMachine& vm){ + //Set Values from constructor + x = xpos; + y = ypos; + overwatch = ow; + audio = aud; + currentmap = map; + physics = phys; + parent = dad; + currentdirection = dir; + walk_time = 0; + + //sprite + SDL_Surface *raw_sprite = IMG_Load(spritepath); + sprite = SDL_DisplayFormat(raw_sprite); + SDL_FreeSurface(raw_sprite); + Uint32 colorkey = SDL_MapRGB(sprite->format, 255, 0, 255); + SDL_SetColorKey(sprite, SDL_SRCCOLORKEY | SDL_RLEACCEL, colorkey); //le ponemos al buddy el colorkey para las transparencias + w = sprite->w/SPRITE_FRAMES_W; //el ancho de nuestro spritesheet + h = sprite->h/SPRITE_FRAMES_H; //lo alto de nuestro spritesheet + + //Lua API. + m_iMethodBase = RegisterFunction ("get_x"); + RegisterFunction ("get_y"); + RegisterFunction ("get_w"); + RegisterFunction ("get_h"); + RegisterFunction ("get_clip_x"); + RegisterFunction ("get_clip_y"); + RegisterFunction ("get_currentframe"); + RegisterFunction ("get_oldclip"); + RegisterFunction ("get_vertical_speed"); + RegisterFunction ("get_falltime"); + RegisterFunction ("get_speed"); + RegisterFunction ("get_ownspeed"); + RegisterFunction ("get_totalspeed"); + RegisterFunction ("set_x"); + RegisterFunction ("set_y"); + RegisterFunction ("set_w"); + RegisterFunction ("set_h"); + RegisterFunction ("set_clip_x"); + RegisterFunction ("set_clip_y"); + RegisterFunction ("set_currentframe"); + RegisterFunction ("set_oldclip"); + RegisterFunction ("set_vertical_speed"); + RegisterFunction ("set_falltime"); + RegisterFunction ("set_speed"); + RegisterFunction ("set_ownspeed"); + RegisterFunction ("set_totalspeed"); + RegisterFunction ("get_currentdirection"); + RegisterFunction ("set_currentdirection"); + RegisterFunction ("can_move"); + RegisterFunction ("get_collision"); + RegisterFunction ("set_collision"); + RegisterFunction ("get_map_sx"); + RegisterFunction ("get_map_sy"); + RegisterFunction ("set_map_sx"); + RegisterFunction ("set_map_sy"); + RegisterFunction ("get_cfg_max_map_w"); + RegisterFunction ("get_cfg_max_map_h"); + RegisterFunction ("get_cfg_screen_width"); + RegisterFunction ("get_cfg_screen_height"); + RegisterFunction ("get_leftkey"); + RegisterFunction ("get_rightkey"); + RegisterFunction ("get_zkey"); + RegisterFunction ("get_xkey"); + RegisterFunction ("get_jumplock"); + RegisterFunction ("get_shootlock"); + RegisterFunction ("set_jumplock"); + RegisterFunction ("set_shootlock"); + RegisterFunction ("set_dying"); + RegisterFunction ("add_bullet"); + RegisterFunction ("get_shotcount"); + RegisterFunction ("set_physics"); + RegisterFunction ("set_enemy"); + RegisterFunction ("set_controllable"); + RegisterFunction ("get_ckey"); + RegisterFunction ("get_switchlock"); + RegisterFunction ("set_switchlock"); + RegisterFunction ("set_noclip"); + RegisterFunction ("load_clip"); + RegisterFunction ("play_sfx"); + RegisterFunction ("play_bgm"); + RegisterFunction ("stop_bgm"); + RegisterFunction ("get_cfg_tile_w"); + RegisterFunction ("get_cfg_tile_h"); + RegisterFunction ("accelerate"); + RegisterFunction ("get_walk_time"); + RegisterFunction ("set_walk_time"); + RegisterFunction ("decelerate"); + + + //lua compile. + this->CompileFile("scripts/globals.lua"); + this->CompileFile (scriptpath); + + //lua sync. + this->SelectScriptFunction ("sync"); + this->Go (); + + + //default values. + oldclip = 0; + vertical_speed = 0.0; + falltime = 0.0; + speed = 0.0; + ownspeed = 0.0; + clip_x = 0; + clip_y = 0; + currentframe = 0; + jumplock = false; + shootlock = false; + dying = false; + shotcount = 0; + + //using ENUM direction as colliding vector index. + colliding[UP], colliding[DOWN], colliding[LEFT], colliding[RIGHT] = false; + + overwatch->move_in(this); +} + +//The Lua ScriptCalling Index. +int Actor::ScriptCalling (CLuaVirtualMachine& vm, int iFunctionNumber){ + switch (iFunctionNumber - m_iMethodBase) + { + case 0: + return lget_x(vm); + break; + + case 1: + return lget_y(vm); + break; + + case 2: + return lget_w(vm); + break; + + case 3: + return lget_h(vm); + break; + + case 4: + return lget_clip_x(vm); + break; + + case 5: + return lget_clip_y(vm); + break; + + case 6: + return lget_currentframe(vm); + break; + + case 7: + return lget_oldclip(vm); + break; + + case 8: + return lget_vertical_speed(vm); + break; + + case 9: + return lget_falltime(vm); + break; + + case 10: + return lget_speed(vm); + break; + + case 11: + return lget_ownspeed(vm); + break; + + case 12: + return lget_totalspeed(vm); + break; + case 13: + return lset_x(vm); + break; + + case 14: + return lset_y(vm); + break; + + case 15: + return lset_w(vm); + break; + + case 16: + return lset_h(vm); + break; + + case 17: + return lset_clip_x(vm); + break; + + case 18: + return lset_clip_y(vm); + break; + + case 19: + return lset_currentframe(vm); + break; + + case 20: + return lset_oldclip(vm); + break; + + case 21: + return lset_vertical_speed(vm); + break; + + case 22: + return lset_falltime(vm); + break; + + case 23: + return lset_speed(vm); + break; + + case 24: + return lset_ownspeed(vm); + break; + + case 25: + return lset_totalspeed(vm); + break; + + case 26: + return lget_currentdirection(vm); + break; + + case 27: + return lset_currentdirection(vm); + break; + + case 28: + return lcan_move(vm); + break; + + case 29: + return lget_collision(vm); + break; + + case 30: + return lset_collision(vm); + break; + + case 31: + return lget_map_sx(vm); + break; + + case 32: + return lget_map_sy(vm); + break; + + case 33: + return lset_map_sx(vm); + break; + + case 34: + return lset_map_sy(vm); + break; + + case 35: + return lget_cfg_max_map_w(vm); + break; + + case 36: + return lget_cfg_max_map_h(vm); + break; + + case 37: + return lget_cfg_screen_width(vm); + break; + + case 38: + return lget_cfg_screen_height(vm); + break; + + case 39: + return lget_leftkey(vm); + break; + + case 40: + return lget_rightkey(vm); + break; + + case 41: + return lget_zkey(vm); + break; + + case 42: + return lget_xkey(vm); + break; + + case 43: + return lget_jumplock(vm); + break; + + case 44: + return lget_shootlock(vm); + break; + + case 45: + return lset_jumplock(vm); + break; + + case 46: + return lset_shootlock(vm); + break; + + case 47: + return lset_dying(vm); + break; + + case 48: + return ladd_bullet(vm); + break; + + case 49: + return lget_shotcount(vm); + break; + + case 50: + return lset_physics(vm); + break; + + case 51: + return lset_enemy(vm); + break; + + case 52: + return lset_controllable(vm); + break; + + case 53: + return lget_ckey(vm); + break; + + case 54: + return lget_switchlock(vm); + break; + + case 55: + return lset_switchlock(vm); + break; + + case 56: + return lset_noclip(vm); + break; + + case 57: + return lload_clip(vm); + break; + + case 58: + return lplay_sfx(vm); + break; + + case 59: + return lplay_bgm(vm); + break; + + case 60: + return lstop_bgm(vm); + break; + + case 61: + return lget_cfg_tile_w(vm); + break; + + case 62: + return lget_cfg_tile_h(vm); + break; + case 63: + return laccelerate(vm); + break; + case 64: + return lget_walk_time(vm); + break; + case 65: + return lset_walk_time(vm); + break; + case 66: + return ldecelerate(vm); + break; + } + return 0; + } + +void Actor::HandleReturns (CLuaVirtualMachine& vm, const char *strFunc){ + +} + +void Actor::animate(){ + + //check for conditions. + if (ownspeed != 0) { + animating = true; + }else{ + animating = false; + } + + + //then do stuff + if (animating) { + if(currentframe <= MOVEMENT_FREQ){ + currentframe++; + }else{ + currentframe = 0; + } + + if(currentframe==0){ + if(clip_x >= (w*SPRITE_FRAMES_W)-w){ + animup = false; + } + if(clip_x == 0){ + animup = true; + } + if(animup){clip_x += w;}else{ clip_x -= w;} + } + } +} + +void Actor::move(){ + if (!colliding[DOWN]) { + speed = 0; + } + totalspeed = speed + ownspeed; + if (noclip) { + x += totalspeed; + }else{ + if (totalspeed > 0 && this->can_move(RIGHT, x, y) ) { + x += totalspeed; + } + if (totalspeed < 0 && this->can_move(LEFT, x, y) ) { + x += totalspeed; + } + } +} + +bool Actor::can_move(Direction direction, int xpos, int ypos){ + if(direction == UP){ + if(currentmap->get_passability((xpos+5-currentmap->get_sx()),(ypos-1-currentmap->get_sy())) == 1 || currentmap->get_passability((xpos+w-5-currentmap->get_sx()),(ypos-1-currentmap->get_sy())) == 1 || colliding[UP]){ + return false; + } + } + if(direction == RIGHT){ + if(currentmap->get_passability((xpos+w-currentmap->get_sx()),(ypos+(h*.25)-currentmap->get_sy())) == 1 || currentmap->get_passability((xpos+w-currentmap->get_sx()),(ypos+h-1-currentmap->get_sy())) == 1 || colliding[RIGHT]){ + return false; + } + } + if(direction == DOWN){ + if(currentmap->get_passability((xpos+5-currentmap->get_sx()),(ypos+h-currentmap->get_sy())) == 1 || currentmap->get_passability((xpos+w-5-currentmap->get_sx()),(ypos+h-currentmap->get_sy())) == 1 || colliding[DOWN]){ + return false; + } + } + if(direction == LEFT){ + if(currentmap->get_passability((xpos-currentmap->get_sx()),(ypos+(h*.25)-currentmap->get_sy())) == 1 || currentmap->get_passability((xpos-currentmap->get_sx()),(ypos+h-1-currentmap->get_sy())) == 1 || colliding[LEFT]){ + return false; + } + } + return true; +} + +bool Actor::can_die(){ + + if(currentmap->get_tile((x-currentmap->get_sx()),(y-1-currentmap->get_sy())) == 2 || currentmap->get_tile((x+w-currentmap->get_sx()),(y-1-currentmap->get_sy())) == 2){ + return true; + } + if(currentmap->get_tile((x+1+w-currentmap->get_sx()),(y-currentmap->get_sy())) == 2 || currentmap->get_tile((x+1+w-currentmap->get_sx()),(y+h-currentmap->get_sy())) == 2){ + return true; + } + if(currentmap->get_tile((x-currentmap->get_sx()),(y+1+h-currentmap->get_sy())) == 2 || currentmap->get_tile((x+w-currentmap->get_sx()),(y+1+h-currentmap->get_sy())) == 2){ + return true; + } + if(currentmap->get_tile((x-1-currentmap->get_sx()),(y-currentmap->get_sy())) == 2 || currentmap->get_tile((x-1-currentmap->get_sx()),(y+h-currentmap->get_sy())) == 2){ + return true; + } + return false; +} + +void Actor::add_bullet(const char* sprite, const char* script){ + shotcount++; + if (currentdirection == LEFT) { + new Actor(x-14, y+10,sprite, script, this, LEFT, false, currentmap, audio, overwatch, m_vm); + } + if (currentdirection == RIGHT) { + new Actor(x+w+4, y+10,sprite, script, this, RIGHT, false, currentmap, audio, overwatch, m_vm); + } +} + +void Actor::remove_bullet(){ + shotcount--; +} + +void Actor::accelerate(float accel, float max_speed){ + + if ( (accel > 0 && ownspeed == max_speed && max_speed < 0) || (accel < 0 && ownspeed == max_speed && max_speed > 0) ){ + walk_time = 0; + } + + //reset the time if we were deccelerating. + if (walk_time < 0) { + walk_time = 0; + } + + walk_time += 1; //increase the time, because we are accelerating. + + if((ownspeed >= max_speed && max_speed > 0) || (ownspeed <= max_speed && max_speed < 0)){ + ownspeed = max_speed; + }else{ + ownspeed = ownspeed + accel*walk_time; + } +} + +void Actor::decelerate(float accel){ + if(ownspeed != 0 && falltime == 0){ + if (walk_time > 0) { + walk_time = 0; + } + walk_time -= 1; //increase the time, because we are accelerating. + + //Stay at 0 + if (ownspeed > 0) { + ownspeed = ownspeed + accel*walk_time; + if (ownspeed < 0){ + ownspeed = 0; //if we go too far, just settle with 0. + } + } + if (ownspeed < 0) { + ownspeed = ownspeed - accel*walk_time; + if (ownspeed > 0){ + ownspeed = 0; //if we go too far, just settle with 0. + } + } + } +} + +//internal accessors + +int Actor::get_x(void){ return x; } +void Actor::set_x(int newval){ x = newval; } +int Actor::get_y(void){ return y; } +void Actor::set_y(int newval){ y = newval; } +int Actor::get_w(void){ return w; } +void Actor::set_w(int newval){ w = newval; } +int Actor::get_h(void){ return h; } +void Actor::set_h(int newval){ h = newval; } +int Actor::get_clip_x(void){ return clip_x; } +void Actor::set_clip_x(int newval){ clip_x = newval; } +int Actor::get_clip_y(void){ return clip_y; } +void Actor::set_clip_y(int newval){ clip_y = newval; } +int Actor::get_currentframe(void){ return currentframe; } +void Actor::set_currentframe(int newval){ currentframe = newval; } +int Actor::get_oldclip(void){ return oldclip; } +void Actor::set_oldclip(int newval){ oldclip = newval; } +float Actor::get_vertical_speed(void){ return vertical_speed; } +void Actor::set_vertical_speed(float newval){ vertical_speed = newval;} +float Actor::get_vertical_acc(void){ return vertical_acc; } +void Actor::set_vertical_acc(float newval){ vertical_acc = newval;} +float Actor::get_falltime(void){ return falltime; } +void Actor::set_falltime(float newval){ falltime = newval; } +SDL_Surface * Actor::get_sprite(void){ return sprite; } +float Actor::get_speed(void){ return speed; } +void Actor::set_speed(float newval){ speed = newval;} +float Actor::get_ownspeed(void){ return ownspeed; } +void Actor::set_ownspeed(float newval){ ownspeed = newval;} +float Actor::get_totalspeed(void){ return totalspeed; } +void Actor::set_totalspeed(float newval){ totalspeed = newval;} +float Actor::get_horizontal_acc(void){ return vertical_acc; } +void Actor::set_horizontal_acc(float newval){ vertical_acc = newval;} +Direction Actor::get_currentdirection(void){ return currentdirection; } +Enemy Actor::get_enemy(void){ return enemy; } +int Actor::get_leftkey(void){ return leftkey; } +void Actor::set_leftkey(int newval){ leftkey = newval; } +int Actor::get_rightkey(void){ return rightkey; } +void Actor::set_rightkey(int newval){ rightkey = newval; } +int Actor::get_zkey(void){ return zkey; } +void Actor::set_zkey(int newval){ zkey = newval; } +int Actor::get_xkey(void){ return xkey; } +void Actor::set_xkey(int newval){ xkey = newval; } +bool Actor::get_physics(void){ return physics; } +void Actor::set_physics(bool newval){ physics = newval; } +void Actor::set_collision(bool col, int corner){ + colliding[corner] = col; +} +bool Actor::get_controllable(void){ return controllable; } +bool Actor::get_collision(int corner){ + return colliding[corner]; +} +bool Actor::get_dying(void){ return dying; } +void Actor::set_dying(bool newval){ dying = newval; } +void Actor::set_ckey(int newval){ ckey = newval; } +bool Actor::get_noclip(void){ return noclip; } + +//lua accessors (get) +int Actor::lget_x(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, x); + return 1; +} + +int Actor::lget_y(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, y); + return 1; +} + +int Actor::lget_w(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, w); + return 1; +} + +int Actor::lget_h(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, h); + return 1; +} + +int Actor::lget_clip_x(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, clip_x); + return 1; +} + +int Actor::lget_clip_y(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, clip_y); + return 1; +} + +int Actor::lget_currentframe(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, currentframe); + return 1; +} + +int Actor::lget_oldclip(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, oldclip); + return 1; +} + +int Actor::lget_vertical_speed(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, vertical_speed); + return 1; +} + +int Actor::lget_falltime(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, falltime); + return 1; +} + +int Actor::lget_speed(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, speed); + return 1; +} + +int Actor::lget_ownspeed(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, ownspeed); + return 1; +} + +int Actor::lget_totalspeed(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, totalspeed); + return 1; +} + +int Actor::lget_currentdirection(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, currentdirection); + return 1; +} + +int Actor::lget_collision(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushboolean (state, colliding[(int) lua_tonumber (state, -1)]); + return 1; +} + +int Actor::lget_map_sx(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, currentmap->get_sx()); + return 1; +} + +int Actor::lget_map_sy(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, currentmap->get_sy()); + return 1; +} + +int Actor::lget_cfg_max_map_w(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, MAX_MAP_W); + return 1; +} + +int Actor::lget_cfg_max_map_h(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, MAX_MAP_H); + return 1; +} + +int Actor::lget_cfg_tile_h(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, TILE_HEIGHT); + return 1; +} + +int Actor::lget_cfg_screen_height(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, SCREEN_HEIGHT); + return 1; +} + +int Actor::lget_leftkey(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, leftkey); + return 1; +} + +int Actor::lget_rightkey(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, rightkey); + return 1; +} + +int Actor::lget_zkey(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, zkey); + return 1; +} + +int Actor::lget_xkey(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, xkey); + return 1; +} + +int Actor::lget_jumplock(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushboolean (state, jumplock); + return 1; +} + +int Actor::lget_shootlock(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushboolean (state, shootlock); + return 1; +} + +int Actor::lget_shotcount(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, shotcount); + return 1; +} + +int Actor::lget_ckey(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, ckey); + return 1; +} + +int Actor::lget_switchlock(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushboolean (state, switchlock); + return 1; +} + +int Actor::lget_cfg_tile_w(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, TILE_WIDTH); + return 1; +} + +int Actor::lget_cfg_screen_width(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, SCREEN_WIDTH); + return 1; +} + +int Actor::lget_walk_time(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushnumber (state, walk_time); + return 1; +} + +//lua accessors (set) +int Actor::lset_x(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + x = (int) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_y(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + y = (int) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_w(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + w = (int) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_h(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + h = (int) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_clip_x(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + clip_x = (int) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_clip_y(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + clip_y = (int) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_currentframe(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + currentframe = (int) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_oldclip(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + oldclip = (int) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_vertical_speed(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + vertical_speed = (float) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_falltime(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + falltime = (float) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_speed(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + speed = (float) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_ownspeed(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + ownspeed = (float) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_totalspeed(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + totalspeed = (float) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_currentdirection(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + currentdirection = (Direction) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_collision(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + colliding[(int) lua_tonumber (state, -1)] = (bool) lua_toboolean(state, -2); + return 0; +} + +int Actor::lset_map_sx(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + currentmap->set_sx((int) lua_tonumber (state, -1)); + return 0; +} + +int Actor::lset_map_sy(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + currentmap->set_sy((int) lua_tonumber (state, -1)); + return 0; +} + +int Actor::lset_jumplock(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + jumplock = (bool) lua_toboolean (state, -1); + return 0; +} + +int Actor::lset_shootlock(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + shootlock = (bool) lua_toboolean (state, -1); + return 0; +} + +int Actor::lset_dying(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + dying = (bool) lua_toboolean (state, -1); + return 0; +} + +int Actor::lset_physics(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + physics = (bool) lua_toboolean (state, -1); + return 0; +} + +int Actor::lset_enemy(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + enemy = (Enemy) lua_tonumber (state, -1); + return 0; +} + +int Actor::lset_controllable(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + controllable = (bool) lua_toboolean (state, -1); + return 0; +} + +int Actor::lset_switchlock(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + switchlock = (bool) lua_toboolean (state, -1); + return 0; +} + +int Actor::lset_noclip(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + noclip = (bool) lua_toboolean (state, -1); + return 0; +} + +int Actor::lset_walk_time(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + walk_time = (int) lua_tonumber (state, -1); + return 0; +} + + +//misc lua methods + +int Actor::lcan_move(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + lua_pushboolean(state,this->can_move((Direction) lua_tonumber (state, -3), (int) lua_tonumber (state, -2), (int) lua_tonumber (state, -1))); + return 1; +} + +int Actor::ladd_bullet(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + this->add_bullet((const char*) lua_tostring (state, -2), (const char*) lua_tostring (state, -1)); + return 1; +} + +int Actor::lload_clip(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + audio->load_clip((const char*) lua_tostring (state, -1)); + return 1; +} + +int Actor::lplay_sfx(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + audio->play_sfx((const char*) lua_tostring (state, -1)); + return 1; +} + +int Actor::lplay_bgm(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + audio->play_bgm((const char*) lua_tostring (state, -1)); + return 1; +} + +int Actor::lstop_bgm(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + audio->stop_bgm((const char*) lua_tostring (state, -1)); + return 1; +} + +int Actor::laccelerate(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + this->accelerate((float) lua_tonumber (state, -2), (float) lua_tonumber (state, -1)); + return 1; +} + +int Actor::ldecelerate(CLuaVirtualMachine& vm){ + lua_State *state = (lua_State *) vm; + this->decelerate((float) lua_tonumber (state, -1)); + return 1; +} \ No newline at end of file -- cgit