source: trunk/src/lua/lua_aux.cc @ 551

// Copyright (C) 2012-2015 ChaosForge Ltd
// http://chaosforge.org/
//
// This file is part of Nova libraries. 
// For conditions of distribution and use, see copying.txt file in root folder.

#include "nv/lua/lua_aux.hh"

#include "nv/lua/lua_raw.hh"
#include "nv/core/random.hh"

static nv::random lua_rng;

static int nluaaux_table_copy( lua_State* L )
{
        luaL_checktype( L, 1, LUA_TTABLE );
        lua_settop( L, 1 );
        nlua_shallowcopy( L, 1 );
        return 1;
}

static int nluaaux_table_deepcopy( lua_State* L )
{
        luaL_checktype( L, 1, LUA_TTABLE );
        lua_settop( L, 1 );
        nlua_deepcopy( L, 1 );
        return 0;
}

static int nluaaux_table_icopy( lua_State* L )
{
        luaL_checktype( L, 1, LUA_TTABLE );
        lua_settop( L, 1 );
        nlua_shallowicopy( L, 1 );
        return 1;
}

static int nluaaux_table_merge( lua_State* L )
{
        luaL_checktype( L, 1, LUA_TTABLE );
        luaL_checktype( L, 2, LUA_TTABLE );
        lua_settop( L, 2 );
        nlua_shallowmerge( L, 1 );
        return 0;
}

static int nluaaux_table_reversed( lua_State* L )
{
        luaL_checktype( L, 1, LUA_TTABLE );
        lua_settop( L, 1 );
        nlua_pushreversed( L, 1 );
        return 1;
}

static int nluaaux_table_toset( lua_State* L )
{
        luaL_checktype( L, 1, LUA_TTABLE );
        lua_settop( L, 1 );
        nlua_toset( L, 1 );
        return 1;
}

static int nluaaux_table_tokeyset( lua_State* L )
{
        luaL_checktype( L, 1, LUA_TTABLE );
        lua_settop( L, 1 );
        nlua_tokeyset( L, 1 );
        return 1;
}

static const struct luaL_Reg nluaaux_table_aux_f [] = {
        { "copy",      nluaaux_table_copy },
        { "deepcopy",  nluaaux_table_deepcopy },
        { "icopy",     nluaaux_table_icopy },
        { "merge",     nluaaux_table_merge },
        { "reversed",  nluaaux_table_reversed },
        { "toset",     nluaaux_table_toset },
        { "tokeyset",  nluaaux_table_tokeyset },
        { NULL, NULL }
};

static int nluaaux_math_clamp( lua_State* L )
{
        double v   = luaL_checknumber( L,  1 );
        double min = luaL_optnumber( L, 2, 0 );
        double max = luaL_optnumber( L, 3, 1 );  
        if ( min > max ) luaL_argerror( L, 2, "min is larger than max!" );
        lua_pushnumber( L, v < min ? 2 : ( v > max ? 3 : 1 ) );
        return 1;
}

static int nluaaux_math_dieroll( lua_State* L )
{
        lua_Integer dice  = luaL_checkinteger( L,  1 );
        lua_Integer sides = luaL_checkinteger( L,  2 );
        if ( dice < 1 )  luaL_argerror( L, 1, "die count lower than 1!" );
        if ( sides < 1 ) luaL_argerror( L, 2, "side count lower than 1!" );
        lua_pushnumber( L, lua_rng.dice( static_cast< nv::uint32 >( dice ), static_cast< nv::uint32 >( sides ) ) );
        return 1;
}

static int nluaaux_math_random( lua_State* L )
{
        if ( lua_gettop( L ) == 0 )
        {
                lua_pushnumber( L, lua_rng.frand(1.0f) );
        }
        else
        {
                if ( lua_gettop( L ) == 1 )
                {
                        lua_Integer arg1 = luaL_checkinteger( L, 1 );
                        if ( arg1 < 1 ) arg1 = 1;
                        nlua_pushunsigned( L, lua_rng.urange( 1, static_cast<nv::uint32>( arg1 ) ) );
                }
                else
                {
                        int arg1 = static_cast< int >( luaL_checkinteger( L, 1 ) );
                        int arg2 = static_cast< int >( luaL_checkinteger( L, 2 ) );
                        int result = ( arg2 >= arg1 ? lua_rng.srange( arg1, arg2 ) : lua_rng.srange( arg2, arg1 ) );
                        lua_pushinteger( L, result );
                }
        }
        return 1;
}

static int nluaaux_math_randomseed( lua_State* L )
{
        lua_rng.set_seed( nlua_tounsigned( L, 1 ) );
        return 0;
}

static const struct luaL_Reg nluaaux_math_aux_f [] = {
        { "clamp",     nluaaux_math_clamp },
        { "random",    nluaaux_math_random },
        { "randomseed",nluaaux_math_randomseed },
        { "dieroll",   nluaaux_math_dieroll },
        { NULL, NULL }
};

nv::random & nv::lua::rng()
{
        return lua_rng;
}

void nv::lua::register_aux( lua::state* state )
{
        nlua_register( state->get_raw(), "table", nluaaux_table_aux_f );
        nlua_register( state->get_raw(), "math", nluaaux_math_aux_f );
}