static void Ai_solve_path (LIScrArgs* args)
{
int i;
LIAiPath* path;
LIExtModule* module;
LIMatVector point;
LIMatVector start;
LIMatVector end;
module = liscr_script_get_userdata (args->script, LIEXT_SCRIPT_AI);
if (!liscr_args_gets_vector (args, "start", &start))
return;
if (!liscr_args_gets_vector (args, "start", &start) ||
!liscr_args_gets_vector (args, "target", &end))
return;
/* Solve the path. */
path = liai_manager_solve_path (module->ai, &start, &end);
if (path == NULL)
return;
/* Store the path to a table. */
liscr_args_set_output (args, LISCR_ARGS_OUTPUT_TABLE_FORCE);
for (i = 0 ; i < liai_path_get_length (path) ; i++)
{
liai_path_get_point (path, i, &point);
liscr_args_seti_vector (args, &point);
}
liai_path_free (path);
}
static void Camera_get_viewport (LIScrArgs* args)
{
LIExtCamera* camera;
camera = args->self;
liscr_args_set_output (args, LISCR_ARGS_OUTPUT_TABLE);
liscr_args_seti_float (args, camera->view.viewport[0]);
liscr_args_seti_float (args, camera->view.viewport[1]);
liscr_args_seti_float (args, camera->view.viewport[2]);
liscr_args_seti_float (args, camera->view.viewport[3]);
}
static void Camera_get_projection (LIScrArgs* args)
{
int i;
LIExtCamera* camera;
LIMatMatrix matrix;
camera = args->self;
liext_camera_get_projection (camera, &matrix);
liscr_args_set_output (args, LISCR_ARGS_OUTPUT_TABLE);
for (i = 0 ; i < 16 ; i++)
liscr_args_seti_float (args, matrix.m[i]);
}
static void Terrain_get_column (LIScrArgs* args)
{
int i;
int vtx_x;
int vtx_z;
int grid_x;
int grid_z;
LIExtTerrainColumn* column;
LIExtTerrainStick* stick;
/* Get the arguments. */
if (!liscr_args_geti_int (args, 0, &grid_x) || grid_x < 0)
return;
if (!liscr_args_geti_int (args, 1, &grid_z) || grid_z < 0)
return;
/* Get the column. */
column = liext_terrain_get_column (args->self, grid_x, grid_z);
if (column == NULL)
return;
/* Pack the sticks into a table. */
liscr_args_set_output (args, LISCR_ARGS_OUTPUT_TABLE_FORCE);
for (stick = column->sticks ; stick != NULL ; stick = stick->next)
{
i = 0;
lua_newtable (args->lua);
#define PUSHNUM(v) lua_pushnumber (args->lua, ++i);\
lua_pushnumber (args->lua, v);\
lua_settable (args->lua, -3);
PUSHNUM (stick->material);
PUSHNUM (stick->height);
for (vtx_z = 0 ; vtx_z < 2 ; vtx_z++)
{
for (vtx_x = 0 ; vtx_x < 2 ; vtx_x++)
{
PUSHNUM (stick->vertices[vtx_x][vtx_z].offset);
PUSHNUM (stick->vertices[vtx_x][vtx_z].splatting);
PUSHNUM (stick->vertices[vtx_x][vtx_z].normal.x);
PUSHNUM (stick->vertices[vtx_x][vtx_z].normal.y);
PUSHNUM (stick->vertices[vtx_x][vtx_z].normal.z);
}
}
#undef PUSHNUM
liscr_args_seti_stack (args);
}
}
static void Thread_pop_message (LIScrArgs* args)
{
LIMaiMessage* message;
LIExtThread* self;
LIEngModel* model;
/* Pop the name. */
self = args->self;
message = limai_program_pop_message (self->program, LIMAI_MESSAGE_QUEUE_PROGRAM);
if (message == NULL)
return;
/* Return the message. */
liscr_args_set_output (args, LISCR_ARGS_OUTPUT_TABLE);
liscr_args_sets_string (args, "name", message->name);
switch (message->type)
{
case LIMAI_MESSAGE_TYPE_EMPTY:
liscr_args_sets_string (args, "type", "empty");
break;
case LIMAI_MESSAGE_TYPE_MODEL:
liscr_args_sets_string (args, "type", "model");
model = lieng_model_new_model (self->program->parent->engine, message->model);
if (model != NULL)
{
message->model = NULL;
model->script = liscr_data_new (args->script, args->lua, model, LISCR_SCRIPT_MODEL, lieng_model_free);
if (model->script != NULL)
liscr_args_sets_stack (args, "model");
else
lieng_model_free (model);
}
break;
case LIMAI_MESSAGE_TYPE_STRING:
liscr_args_sets_string (args, "type", "string");
liscr_args_sets_string (args, "string", message->string);
break;
}
/* Free the message. */
limai_message_free (message);
}
static void Voxel_find_blocks (LIScrArgs* args)
{
int sx;
int sy;
int sz;
int index;
int line;
int stamp;
float radius;
LIAlgRange sectors;
LIAlgRange blocks;
LIAlgRange range;
LIAlgRangeIter iter0;
LIAlgRangeIter iter1;
LIExtModule* module;
LIMatVector min;
LIMatVector max;
LIMatVector point;
LIMatVector size;
LIVoxBlock* block;
LIVoxSector* sector;
/* Initialize arguments. */
if (!liscr_args_gets_vector (args, "point", &point))
return;
liscr_args_gets_float (args, "radius", &radius);
liscr_args_set_output (args, LISCR_ARGS_OUTPUT_TABLE_FORCE);
module = liscr_script_get_userdata (args->script, LIEXT_SCRIPT_VOXEL);
line = module->voxels->blocks_per_line * module->voxels->sectors->count;
/* Calculate sight volume. */
size = limat_vector_init (radius, radius, radius);
min = limat_vector_subtract (point, size);
max = limat_vector_add (point, size);
sectors = lialg_range_new_from_aabb (&min, &max, module->voxels->sectors->width);
sectors = lialg_range_clamp (sectors, 0, module->voxels->sectors->count - 1);
blocks = lialg_range_new_from_aabb (&min, &max, module->voxels->sectors->width / module->voxels->blocks_per_line);
blocks = lialg_range_clamp (blocks, 0, module->voxels->blocks_per_line * module->voxels->sectors->count - 1);
/* Loop through visible sectors. */
LIALG_RANGE_FOREACH (iter0, sectors)
{
/* Get voxel sector. */
sector = lialg_sectors_data_index (module->voxels->sectors, LIALG_SECTORS_CONTENT_VOXEL, iter0.index, 0);
if (sector == NULL)
continue;
/* Calculate visible block range. */
livox_sector_get_offset (sector, &sx, &sy, &sz);
sx *= module->voxels->blocks_per_line;
sy *= module->voxels->blocks_per_line;
sz *= module->voxels->blocks_per_line;
range.min = 0;
range.max = module->voxels->blocks_per_line;
range.minx = LIMAT_MAX (blocks.minx - sx, 0);
range.miny = LIMAT_MAX (blocks.miny - sy, 0);
range.minz = LIMAT_MAX (blocks.minz - sz, 0);
range.maxx = LIMAT_MIN (blocks.maxx - sx, module->voxels->blocks_per_line - 1);
range.maxy = LIMAT_MIN (blocks.maxy - sy, module->voxels->blocks_per_line - 1);
range.maxz = LIMAT_MIN (blocks.maxz - sz, module->voxels->blocks_per_line - 1);
/* Loop through visible blocks. */
LIALG_RANGE_FOREACH (iter1, range)
{
block = livox_sector_get_block (sector, iter1.x, iter1.y, iter1.z);
stamp = livox_block_get_stamp (block);
index = (sx + iter1.x) + (sy + iter1.y) * line + (sz + iter1.z) * line * line;
liscr_args_setf_float (args, index, stamp);
}
static void Lobby_download_server_list (LIScrArgs* args)
{
#ifdef HAVE_CURL
int ret;
int port = 0;
int players = 0;
char* url;
char* desc;
char* ip;
char* name;
const char* master;
char error_buffer[CURL_ERROR_SIZE];
LIArcReader* reader;
LIArcWriter* writer;
CURL* curl;
/* Get arguments. */
if (!liscr_args_gets_string (args, "master", &master))
return;
liscr_args_set_output (args, LISCR_ARGS_OUTPUT_TABLE_FORCE);
/* Format the script URL. */
url = lisys_string_concat (master, "/lossrvapi.php");
if (url == NULL)
return;
/* GET from the master server. */
curl = curl_easy_init();
if (curl != NULL)
{
writer = liarc_writer_new ();
curl_easy_setopt (curl, CURLOPT_URL, url);
curl_easy_setopt (curl, CURLOPT_WRITEDATA, writer);
curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, private_write);
curl_easy_setopt (curl, CURLOPT_ERRORBUFFER, error_buffer);
if (curl_easy_perform (curl))
{
lisys_error_set (EINVAL, "lobby: %s", error_buffer);
lisys_error_report ();
curl_easy_cleanup (curl);
liarc_writer_free (writer);
lisys_free (url);
return;
}
curl_easy_cleanup (curl);
liarc_writer_append_nul (writer);
reader = liarc_reader_new (
liarc_writer_get_buffer (writer),
liarc_writer_get_length (writer));
while (!liarc_reader_check_end (reader))
{
ip = NULL;
name = NULL;
desc = NULL;
ret = liarc_reader_get_text (reader, "\t", &ip) &&
liarc_reader_get_text_int (reader, &port) &&
liarc_reader_skip_bytes (reader, 1) &&
liarc_reader_get_text_int (reader, &players) &&
liarc_reader_skip_bytes (reader, 1) &&
liarc_reader_get_text (reader, "\t", &name) &&
liarc_reader_get_text (reader, "\n", &desc);
if (ret)
{
lua_newtable (args->lua);
lua_pushstring (args->lua, ip);
lua_setfield (args->lua, -2, "ip");
lua_pushnumber (args->lua, port);
lua_setfield (args->lua, -2, "port");
lua_pushnumber (args->lua, players);
lua_setfield (args->lua, -2, "players");
lua_pushstring (args->lua, name);
lua_setfield (args->lua, -2, "name");
lua_pushstring (args->lua, desc);
lua_setfield (args->lua, -2, "desc");
liscr_args_seti_stack (args);
}
lisys_free (ip);
lisys_free (name);
lisys_free (desc);
if (!ret)
break;
}
liarc_reader_free (reader);
liarc_writer_free (writer);
}
lisys_free (url);
#endif
}
static void Database_query (LIScrArgs* args)
{
int i;
int col;
int row;
int ret;
int size;
const char* query;
const char* str;
sqlite3* self;
LIArcPacket* packet;
LIScrData* data;
sqlite3_stmt* statement;
self = args->self;
if (!liscr_args_geti_string (args, 0, &query) &&
!liscr_args_gets_string (args, "query", &query))
return;
/* Create a statement. */
if (sqlite3_prepare_v2 (self, query, -1, &statement, NULL) != SQLITE_OK)
{
lisys_error_set (EINVAL, "SQL prepare: %s", sqlite3_errmsg (self));
lisys_error_report ();
return;
}
/* Bind variables. */
if (liscr_args_geti_table (args, 1) || liscr_args_gets_table (args, "bind"))
{
for (i = 1 ; i < sqlite3_bind_parameter_count (statement) + 1 ; i++)
{
/* We got a table that has the bound variables in fields matching
the indices of the bound variables. We can simply loop through
the table and use the binding index as the key. */
lua_pushnumber (args->lua, i);
lua_gettable (args->lua, -2);
switch (lua_type (args->lua, -1))
{
/* Bind numbers as doubles. */
case LUA_TNUMBER:
if (sqlite3_bind_double (statement, i, lua_tonumber (args->lua, -1)) != SQLITE_OK)
{
lisys_error_set (EINVAL, "SQL bind: %s", sqlite3_errmsg (self));
lisys_error_report ();
sqlite3_finalize (statement);
return;
}
break;
/* Bind strings as text. */
case LUA_TSTRING:
if (sqlite3_bind_text (statement, i, lua_tostring (args->lua, -1), -1, SQLITE_TRANSIENT) != SQLITE_OK)
{
lisys_error_set (EINVAL, "SQL bind: %s", sqlite3_errmsg (self));
lisys_error_report ();
sqlite3_finalize (statement);
return;
}
break;
/* Bind packets as blobs. */
case LUA_TUSERDATA:
data = liscr_isdata (args->lua, -1, LISCR_SCRIPT_PACKET);
if (data == NULL)
break;
packet = liscr_data_get_data (data);
if (packet->writer != NULL)
{
if (sqlite3_bind_blob (statement, i, packet->writer->memory.buffer,
packet->writer->memory.length, SQLITE_TRANSIENT) != SQLITE_OK)
{
lisys_error_set (EINVAL, "SQL bind: %s", sqlite3_errmsg (self));
lisys_error_report ();
sqlite3_finalize (statement);
return;
}
}
else
{
if (sqlite3_bind_blob (statement, i, packet->reader->buffer,
packet->reader->length, SQLITE_TRANSIENT) != SQLITE_OK)
{
lisys_error_set (EINVAL, "SQL bind: %s", sqlite3_errmsg (self));
lisys_error_report ();
sqlite3_finalize (statement);
return;
}
}
break;
/* Bind any other values as NULL. */
default:
if (sqlite3_bind_null (statement, i) != SQLITE_OK)
{
lisys_error_set (EINVAL, "SQL bind: %s", sqlite3_errmsg (self));
lisys_error_report ();
sqlite3_finalize (statement);
return;
}
break;
}
lua_pop (args->lua, 1);
}
lua_pop (args->lua, 1);
}
/* Execute the statement and process results. */
for (row = 0, ret = sqlite3_step (statement) ; ret != SQLITE_DONE ; ret = sqlite3_step (statement), row++)
{
/* Check for errors. */
if (ret != SQLITE_ROW)
{
lisys_error_set (EINVAL, "SQL step: %s", sqlite3_errmsg (self));
lisys_error_report ();
sqlite3_finalize (statement);
return;
}
if (!row)
liscr_args_set_output (args, LISCR_ARGS_OUTPUT_TABLE_FORCE);
/* Create a row table. */
lua_newtable (args->lua);
/* Push the columns to the table. */
for (col = 0 ; col < sqlite3_column_count (statement) ; col++)
{
switch (sqlite3_column_type (statement, col))
{
case SQLITE_INTEGER:
lua_pushnumber (args->lua, col + 1);
lua_pushnumber (args->lua, sqlite3_column_int (statement, col));
lua_settable (args->lua, -3);
break;
case SQLITE_FLOAT:
lua_pushnumber (args->lua, col + 1);
lua_pushnumber (args->lua, sqlite3_column_double (statement, col));
lua_settable (args->lua, -3);
break;
case SQLITE_TEXT:
str = (const char*) sqlite3_column_text (statement, col);
size = sqlite3_column_bytes (statement, col);
lua_pushnumber (args->lua, col + 1);
if (size > 0 && str != NULL)
lua_pushstring (args->lua, str);
else
lua_pushstring (args->lua, str);
lua_settable (args->lua, -3);
break;
case SQLITE_BLOB:
str = sqlite3_column_blob (statement, col);
size = sqlite3_column_bytes (statement, col);
packet = liarc_packet_new_readable (str, size);
if (packet != NULL)
{
lua_pushnumber (args->lua, col + 1);
data = liscr_data_new (args->script, args->lua, packet, LISCR_SCRIPT_PACKET, liarc_packet_free);
if (data != NULL)
lua_settable (args->lua, -3);
else
{
lua_pop (args->lua, 1);
liarc_packet_free (packet);
}
}
break;
case SQLITE_NULL:
break;
default:
lisys_assert (0 && "invalid column type");
break;
}
}
/* Add the row to the return values. */
liscr_args_seti_stack (args);
}
if (!row)
liscr_args_set_output (args, LISCR_ARGS_OUTPUT_TABLE_FORCE);
sqlite3_finalize (statement);
}
