api_tiles.cc

Go to the documentation of this file.

/*
 * This file is part of the Simutrans project under the Artistic License.
 * (see LICENSE.txt)
 */

#include "api.h"

#include "api_simple.h"
#include "get_next.h"
#include "../api_class.h"
#include "../api_function.h"
#include "../../tool/simmenu.h"
#include "../../world/simworld.h"
#include "../../ground/wasser.h"
#include "../../obj/crossing.h"

#include "../../simconvoi.h"
#include "../../vehicle/vehicle.h"

namespace script_api {
    declare_enum_param(grund_t::flag_values, uint8, "flags");
    declare_specialized_param(depot_t*, "t|x|y", "depot_x");
};

using namespace script_api;


SQInteger get_next_object(HSQUIRRELVM vm)
{
    grund_t *gr = param<grund_t*>::get(vm, 1);
    return generic_get_next(vm, gr ? gr->obj_count() : 0);
}


SQInteger get_object_index(HSQUIRRELVM vm)
{
    grund_t *gr = param<grund_t*>::get(vm, 1);
    uint8 index = param<uint8>::get(vm, 2);

    obj_t *obj = NULL;
    if (gr  &&  index < gr->obj_count()) {
        obj = gr->obj_bei(index);
    }
    return param<obj_t*>::push(vm, obj);
}

SQInteger get_object_count(HSQUIRRELVM vm)
{
    grund_t *gr = param<grund_t*>::get(vm, 1);
    return param<uint8>::push(vm, gr ? gr->obj_count() : 0);
}

call_tool_work tile_remove_object(grund_t* gr, player_t* player, obj_t::typ type)
{
    cbuffer_t buf;
    buf.printf("%d", (int)type);
    return call_tool_work(TOOL_REMOVER | GENERAL_TOOL, (const char*)buf, 0, player, gr->get_pos());
}

// return way ribis, have to implement a wrapper, to correctly rotate ribi
static SQInteger get_way_ribi(HSQUIRRELVM vm)
{
    grund_t *gr = param<grund_t*>::get(vm, 1);
    waytype_t wt = param<waytype_t>::get(vm, 2);
    bool masked = param<bool>::get(vm, 3);

    ribi_t::ribi ribi = gr ? (masked ? gr->get_weg_ribi(wt) : gr->get_weg_ribi_unmasked(wt) ) : 0;

    return param<my_ribi_t>::push(vm, ribi);
}

static SQInteger get_canal_ribi(HSQUIRRELVM vm)
{
    grund_t *gr = param<grund_t*>::get(vm, 1);
    ribi_t::ribi ribi = gr  &&  gr->is_water() ?  ((wasser_t*)gr)->get_canal_ribi() : (ribi_t::ribi)0;

    return param<my_ribi_t>::push(vm, ribi);
}


// we have to implement a wrapper, to correctly rotate ribi
grund_t* get_neighbour(grund_t *gr, waytype_t wt, my_ribi_t ribi)
{
    grund_t *to = NULL;
    if (gr  &&  ribi_t::is_single(ribi)) {
        gr->get_neighbour(to, wt, ribi);
    }
    return to;
}

my_slope_t get_slope(grund_t *gr)
{
    return gr->get_grund_hang();
}

bool is_crossing(grund_t *gr)
{
    return gr->find<crossing_t>();
}

halthandle_t get_first_halt_on_square(planquadrat_t* plan)
{
    return plan->get_halt(NULL);
}

vector_tpl<halthandle_t> const& square_get_halt_list(planquadrat_t *plan)
{
    static vector_tpl<halthandle_t> list;
    list.clear();
    if (plan) {
        const halthandle_t* haltlist = plan->get_haltlist();
        for(uint8 i=0, end = plan->get_haltlist_count(); i < end; i++) {
            list.append(haltlist[i]);
        }
    }
    return list;
}

vector_tpl<convoihandle_t> const get_convoy_list(grund_t* gr)
{
    static vector_tpl<convoihandle_t> list;
    list.clear();

    for( uint8 n = 0; n<gr->obj_count(); n++) {
        obj_t* obj = gr->obj_bei( n );
        if( vehicle_t* veh = dynamic_cast<vehicle_t*>(obj) ) {
            convoihandle_t cnv;
            if( veh->get_convoi() ) {
                list.append_unique( veh->get_convoi()->self );
            }
        }
    }
    return list;
}

void export_tiles(HSQUIRRELVM vm)
{
    begin_class(vm, "tile_x", "coord3d,extend_get,ingame_object");

    // actually defined in simutrans/script/script_base.nut
    // register_function(..., "constructor", ...);

    export_is_valid<grund_t*>(vm); //register_function("is_valid")
    register_method(vm, &grund_t::suche_obj, "find_object");
    register_method(vm, &tile_remove_object, "remove_object", true);
    register_method(vm, &grund_t::get_halt, "get_halt");

    register_method(vm, &grund_t::is_water, "is_water");

    register_method(vm, &grund_t::ist_bruecke, "is_bridge");

    register_method(vm, &grund_t::ist_tunnel, "is_tunnel");

    register_method(vm, &grund_t::ist_natur, "is_empty");

    register_method(vm, &grund_t::ist_karten_boden, "is_ground");

    register_method(vm, &is_crossing, "is_crossing", true);

    register_method(vm, &get_slope, "get_slope", true);

    register_method(vm, &grund_t::get_text, "get_text");

    register_method(vm, &grund_t::hat_weg, "has_way");

    register_method(vm, &grund_t::hat_wege, "has_ways");

    register_method<bool (grund_t::*)() const>(vm, &grund_t::has_two_ways, "has_two_ways");
    register_method(vm, &grund_t::get_weg, "get_way");
    register_function_fv(vm, &get_way_ribi, "get_way_dirs", 2, "xi", freevariable<bool>(false) );
    register_function_fv(vm, &get_way_ribi, "get_way_dirs_masked", 2, "xi", freevariable<bool>(true) );
    register_function(vm, &get_canal_ribi, "get_canal_ribi", 1, "x");
    register_method(vm, &get_neighbour, "get_neighbour", true);
    register_method(vm, &grund_t::get_depot, "get_depot");
    register_method(vm, &grund_t::kann_alle_obj_entfernen, "can_remove_all_objects");

    register_method_fv(vm, &grund_t::get_flag, "is_marked", freevariable<uint8>(grund_t::marked));
    register_method_fv(vm, &grund_t::clear_flag, "unmark", freevariable<uint8>(grund_t::marked));
    register_method_fv(vm, &grund_t::set_flag, "mark", freevariable<uint8>(grund_t::marked));

    register_method(vm, &get_convoy_list, "get_convoys", true);

#ifdef SQAPI_DOC // document members

    tile_object_list_x get_objects();
#endif

    end_class(vm);

    begin_class(vm, "tile_object_list_x", "coord3d");
    register_function(vm, get_next_object,  "_nexti",  2, "x o|i");
    register_function(vm, get_object_index, "_get",    2, "x i|s");
    register_function(vm, get_object_count, "get_count",  1, "x");

    end_class(vm);

    begin_class(vm, "square_x", "coord,extend_get,ingame_object");

    // actually defined in simutrans/script/script_base.nut
    // register_function(..., "constructor", ...);

    export_is_valid<planquadrat_t*>(vm); //register_function("is_valid")
    register_method(vm, &get_first_halt_on_square, "get_halt", true);

    register_method(vm, &planquadrat_t::get_halt, "get_player_halt");

    register_method(vm, &planquadrat_t::get_boden_in_hoehe, "get_tile_at_height");

    register_method(vm, &planquadrat_t::get_kartenboden, "get_ground_tile");

    register_method(vm, &square_get_halt_list, "get_halt_list", true);

    register_method(vm, &planquadrat_t::get_climate, "get_climate");

    end_class(vm);
}