api_obj_desc.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_obj_desc_base.h"
#include "api_simple.h"
#include "export_desc.h"
#include "get_next.h"
#include "../api_class.h"
#include "../api_function.h"
#include "../../descriptor/bridge_desc.h"
#include "../../descriptor/building_desc.h"
#include "../../descriptor/vehicle_desc.h"
#include "../../descriptor/goods_desc.h"
#include "../../descriptor/roadsign_desc.h"
#include "../../descriptor/way_obj_desc.h"
#include "../../descriptor/factory_desc.h"
#include "../../builder/brueckenbauer.h"
#include "../../builder/hausbauer.h"
#include "../../builder/fabrikbauer.h"
#include "../../builder/tunnelbauer.h"
#include "../../builder/vehikelbauer.h"
#include "../../builder/goods_manager.h"
#include "../../builder/wegbauer.h"
#include "../../obj/roadsign.h"
#include "../../obj/wayobj.h"
#include "../../simhalt.h"
#include "../../simware.h"
#include "../../tool/simtool.h"
#include "../../world/simworld.h"

#define begin_enum(name)
#define end_enum()
#define enum_slot create_slot


using namespace script_api;


SQInteger get_next_ware_desc(HSQUIRRELVM vm)
{
    return generic_get_next(vm, goods_manager_t::get_count());
}


SQInteger get_goods_desc_index(HSQUIRRELVM vm)
{
    uint32 index = param<uint32>::get(vm, -1);

    const char* name = "None"; // fall-back
    if (index < goods_manager_t::get_count()) {
        name = goods_manager_t::get_info(index)->get_name();
    }
    return push_instance(vm, "good_desc_x",  name);
}


bool are_equal(const obj_named_desc_t* a, const obj_named_desc_t* b)
{
    return (a==b);
}


sint64 get_scaled_maintenance(const obj_desc_transport_related_t* desc)
{
    return desc ? welt->scale_with_month_length(desc->get_maintenance()) : 0;
}

sint64 get_scaled_maintenance_vehicle(const vehicle_desc_t* desc)
{
    return desc ? welt->scale_with_month_length(desc->vehicle_desc_t::get_maintenance()) : 0;
}

sint64 get_scaled_maintenance_building(const building_desc_t* desc)
{
    return desc ? welt->scale_with_month_length(desc->get_maintenance(welt)) : 0;
}


bool building_enables(const building_desc_t* desc, uint8 which)
{
    return desc ? desc->get_enabled() & which : 0;
}

SQInteger building_get_size(HSQUIRRELVM vm)
{
    const building_desc_t* desc = param<const building_desc_t*>::get(vm, 1);
    uint8 rotation = param<uint8>::get(vm, 2);
    if (desc) {
        koord size = desc->get_size(rotation);
        // no automatic coordinate transform please
        return push_instance(vm, "coord", size.x, size.y);
    }
    return -1;
}

mytime_t get_intro_retire(const obj_desc_timelined_t* desc, bool intro)
{
    return (uint32)(desc ? ( intro ? desc->get_intro_year_month() : desc->get_retire_year_month() ) : 1);
}


bool is_obsolete_future(const obj_desc_timelined_t* desc, mytime_t time, uint8 what)
{
    if (desc) {
        switch(what) {
            case 0: return desc->is_future(time.raw);
            case 1: return desc->is_retired(time.raw);
            case 2: return desc->is_available(time.raw);
            default: ;
        }
    }
    return false;
}


const vector_tpl<const building_desc_t*>& get_building_list(building_desc_t::btype type)
{
    const vector_tpl<const building_desc_t*>* p = hausbauer_t::get_list(type);

    static const vector_tpl<const building_desc_t*> dummy;

    return p ? *p : dummy;
}


const vector_tpl<const building_desc_t*>& get_available_stations(building_desc_t::btype type, waytype_t wt, const goods_desc_t *freight)
{
    static vector_tpl<const building_desc_t*> dummy;
    dummy.clear();

    switch(type) {
        case building_desc_t::depot:
        case building_desc_t::generic_stop:
        case building_desc_t::generic_extension:
        case building_desc_t::dock:
        case building_desc_t::flat_dock:
            break;
        default:
            return dummy;
    }

    const vector_tpl<const building_desc_t*>* p = hausbauer_t::get_list(type);

    // translate freight to enables-flags
    uint8 enables = 0;
    if (freight  &&  type != building_desc_t::depot) {
        switch(freight->get_catg_index()) {
            case goods_manager_t::INDEX_PAS:  enables = haltestelle_t::PAX;  break;
            case goods_manager_t::INDEX_MAIL: enables = haltestelle_t::POST; break;
            default:                          enables = haltestelle_t::WARE;
        }
    }

    // use wt_all (which is equal to invalid_wt, see api_const.cc) to get buildings for all waytypes
    bool accept_all_wt = wt == invalid_wt  ||  wt == ignore_wt;

    uint16 time = welt->get_timeline_year_month();
    for(building_desc_t const* const desc : *p) {
        if(  desc->get_type()==type
            &&  (accept_all_wt  ||  desc->get_extra()==(uint32)wt)
            &&  (enables==0  ||  (desc->get_enabled()&enables)!=0)
            &&  desc->get_builder()
            &&  desc->is_available(time))
        {

            dummy.append(desc);
        }
    }
    return dummy;
}

sint64 building_get_cost(const building_desc_t* desc)
{
    return desc->get_price(welt) * desc->get_x() * desc->get_y();
}

bool building_is_terminus(const building_desc_t *desc)
{
    return desc  &&  desc->get_type() == building_desc_t::generic_stop  &&  desc->get_all_layouts() == 4;
}

bool can_be_first(const vehicle_desc_t *desc)
{
    return desc->can_follow(NULL);
}

bool can_be_last(const vehicle_desc_t *desc)
{
    return desc->can_lead(NULL);
}

bool is_coupling_allowed(const vehicle_desc_t *desc1, const vehicle_desc_t *desc2)
{
    return desc1  &&  desc2  &&  desc1->can_lead(desc2)  &&  desc2->can_follow(desc1);
}

const vector_tpl<const vehicle_desc_t*>& get_predecessors(const vehicle_desc_t *desc)
{
    static vector_tpl<const vehicle_desc_t*> dummy;
    dummy.clear();
    for(int i=0; i<desc->get_leader_count(); i++) {
        if (desc->get_leader(i)) {
            dummy.append(desc->get_leader(i));
        }
    }
    return dummy;
}

const vector_tpl<const vehicle_desc_t*>& get_successors(const vehicle_desc_t *desc)
{
    static vector_tpl<const vehicle_desc_t*> dummy;
    dummy.clear();
    for(int i=0; i<desc->get_trailer_count(); i++) {
        if (desc->get_trailer(i)) {
            dummy.append(desc->get_trailer(i));
        }
    }
    return dummy;
}

const vector_tpl<const vehicle_desc_t*>& get_available_vehicles(waytype_t wt)
{
    static vector_tpl<const vehicle_desc_t*> dummy;

    bool use_obsolete = welt->get_settings().get_allow_buying_obsolete_vehicles();
    uint16 time = welt->get_timeline_year_month();

    dummy.clear();
    slist_tpl<vehicle_desc_t const*> const& list = vehicle_builder_t::get_info(wt);

    for(vehicle_desc_t const* const i : list) {
        if (!i->is_retired(time)  ||  use_obsolete) {
            if (!i->is_future(time)) {
                dummy.append(i);
            }
        }
    }
    return dummy;
}

uint32 get_power(const vehicle_desc_t *desc)
{
    return desc->get_power() * desc->get_gear();
}

bool vehicle_needs_electrification(const vehicle_desc_t *desc)
{
    return desc->get_power()  &&  (desc->get_engine_type()==vehicle_desc_t::electric);
}

// export of building_desc_t::btype only here
namespace script_api {
    declare_enum_param(building_desc_t::btype, uint16, "building_desc_x::building_type");
};

bool is_traffic_light(const roadsign_desc_t *d)
{
    return !d->is_signal_type()  &&  d->is_traffic_light();
}


sint64 tree_get_price()
{
    return -welt->get_settings().cst_remove_tree;
}


const vector_tpl<const way_obj_desc_t*>& get_available_wayobjs(waytype_t wt)
{
    static vector_tpl<const way_obj_desc_t*> dummy;

    uint16 time = welt->get_timeline_year_month();

    dummy.clear();
    for(auto i : wayobj_t::get_list()) {
        const way_obj_desc_t* desc = i.value;
        if (desc->get_waytype()==wt  &&  desc->is_available(time)  &&  desc->get_builder()) {
            dummy.append(desc);
        }
    }
    return dummy;
}


#ifdef DOXYGEN

struct factory_slot_information_x { // begin_class("factory_slot_information_x")
    good_desc_x good; 
    integer capacity; 
    integer factor;   
}; // end_class
#endif

SQInteger get_factory_outputs(HSQUIRRELVM vm)
{
    const factory_desc_t *desc = param<const factory_desc_t *>::get(vm, -1);
    sq_newarray(vm, 0);
    if (desc) {
        for(uint16 i=0; i<desc->get_product_count(); i++) {
            const factory_product_desc_t *fp = desc->get_product(i);
            sq_newtable(vm);
            create_slot(vm, "good", fp->get_output_type());
            create_slot(vm, "capacity", fp->get_capacity());
            create_slot(vm, "factor", fp->get_factor());
            sq_arrayappend(vm, -2);
        }
    }
    return 1;
}

SQInteger get_factory_inputs(HSQUIRRELVM vm)
{
    const factory_desc_t *desc = param<const factory_desc_t *>::get(vm, -1);
    sq_newarray(vm, 0);
    if (desc) {
        for(uint16 i=0; i<desc->get_supplier_count(); i++) {
            const factory_supplier_desc_t *fp = desc->get_supplier(i);
            sq_newtable(vm);
            create_slot(vm, "good", fp->get_input_type());
            create_slot(vm, "capacity", fp->get_capacity());
            create_slot(vm, "factor", fp->get_consumption());
            sq_arrayappend(vm, -2);
        }
    }
    return 1;
}


void export_goods_desc(HSQUIRRELVM vm)
{
    create_class<const obj_named_desc_t*>(vm, "obj_desc_x", "extend_get");

    register_method(vm, &obj_named_desc_t::get_name, "get_name");
    register_method(vm, &are_equal, "is_equal", true);
    export_is_valid<const obj_named_desc_t*>(vm); //register_function("is_valid")
    end_class(vm);

    create_class<const obj_desc_timelined_t*>(vm, "obj_desc_time_x", "obj_desc_x");

    register_method_fv(vm, &get_intro_retire, "get_intro_date", freevariable<bool>(true), true);
    register_method_fv(vm, &get_intro_retire, "get_retire_date", freevariable<bool>(false), true);
    register_method_fv(vm, &is_obsolete_future, "is_future", freevariable<uint8>(0), true);
    register_method_fv(vm, &is_obsolete_future, "is_retired", freevariable<uint8>(1), true);
    register_method_fv(vm, &is_obsolete_future, "is_available", freevariable<uint8>(2), true);
    end_class(vm);

    create_class<const obj_desc_transport_related_t*>(vm, "obj_desc_transport_x", "obj_desc_time_x");
    register_local_method(vm, &get_scaled_maintenance, "get_maintenance");
    register_method(vm, &obj_desc_transport_related_t::get_price, "get_cost");
    register_method(vm, &obj_desc_transport_related_t::get_waytype, "get_waytype");
    register_method(vm, &obj_desc_transport_related_t::get_topspeed, "get_topspeed");

    end_class(vm);

    begin_desc_class(vm, "vehicle_desc_x", "obj_desc_transport_x", (GETDESCFUNC)param<const vehicle_desc_t*>::getfunc());
    register_method(vm, &can_be_first, "can_be_first", true);
    register_method(vm, &can_be_last, "can_be_last", true);
    register_method(vm, &get_successors, "get_successors", true);
    register_method(vm, &get_predecessors, "get_predecessors", true);
    STATIC register_method(vm, &get_available_vehicles, "get_available_vehicles", false, true);
    register_method(vm, &get_power, "get_power", true);
    register_method(vm, &vehicle_needs_electrification, "needs_electrification", true);
    register_method(vm, &vehicle_desc_t::get_freight_type, "get_freight");
    register_method(vm, &vehicle_desc_t::get_capacity, "get_capacity");
    register_method(vm, &vehicle_desc_t::get_running_cost, "get_running_cost");
    register_method(vm, &get_scaled_maintenance_vehicle, "get_maintenance", true);
    register_method(vm, &vehicle_desc_t::get_weight, "get_weight"); // in kg
    register_method(vm, &vehicle_desc_t::get_length, "get_length"); // in CAR_UNITS_PER_TILE
    STATIC register_method(vm, is_coupling_allowed, "is_coupling_allowed", false, true);
    end_class(vm);

    begin_desc_class(vm, "tree_desc_x", "obj_desc_x", (GETDESCFUNC)param<const tree_desc_t*>::getfunc());

    STATIC register_method(vm, tree_get_price, "get_price", false, true);
    end_class(vm);

    begin_desc_class(vm, "building_desc_x", "obj_desc_time_x", (GETDESCFUNC)param<const building_desc_t*>::getfunc());

    register_method(vm, &building_desc_t::is_attraction, "is_attraction");
    register_function(vm, building_get_size, "get_size", 2,  "x i");
    register_method(vm, &get_scaled_maintenance_building, "get_maintenance", true);
    register_method(vm, &building_get_cost, "get_cost", true);
    register_method(vm, &building_desc_t::get_capacity, "get_capacity");
    register_method(vm, &building_desc_t::can_be_built_underground, "can_be_built_underground");
    register_method(vm, &building_desc_t::can_be_built_aboveground, "can_be_built_aboveground");
    register_method_fv(vm, &building_enables, "enables_pax", freevariable<uint8>(1), true);
    register_method_fv(vm, &building_enables, "enables_mail", freevariable<uint8>(2), true);
    register_method_fv(vm, &building_enables, "enables_freight", freevariable<uint8>(4), true);
    begin_enum("building_type")
    enum_slot(vm, "attraction_city", (uint8)building_desc_t::attraction_city, true);
    enum_slot(vm, "attraction_land", (uint8)building_desc_t::attraction_land, true);
    enum_slot(vm, "monument", (uint8)building_desc_t::monument, true);
    enum_slot(vm, "factory", (uint8)building_desc_t::factory, true);
    enum_slot(vm, "townhall", (uint8)building_desc_t::townhall, true);
    enum_slot(vm, "headquarter", (uint8)building_desc_t::headquarters, true);
    enum_slot(vm, "harbour", (uint8)building_desc_t::dock, true);
    enum_slot(vm, "flat_harbour", (uint8)building_desc_t::flat_dock, true);
    enum_slot(vm, "depot", (uint8)building_desc_t::depot, true);
    enum_slot(vm, "station", (uint8)building_desc_t::generic_stop, true);
    enum_slot(vm, "station_extension", (uint8)building_desc_t::generic_extension, true);
    enum_slot(vm, "city_res", (uint8)building_desc_t::city_res, true);
    enum_slot(vm, "city_com", (uint8)building_desc_t::city_com, true);
    enum_slot(vm, "city_ind", (uint8)building_desc_t::city_ind, true);
    end_enum();
    register_method(vm, &building_desc_t::get_type, "get_type");

    register_method(vm, &building_desc_t::get_finance_waytype, "get_waytype");

    register_method(vm, &building_desc_t::get_headquarters_level, "get_headquarter_level");

    STATIC register_method(vm, &get_building_list, "get_building_list", false, true);
    STATIC register_method(vm, &get_available_stations, "get_available_stations", false, true);

    register_method(vm, &building_is_terminus, "is_terminus", true);

    end_class(vm);

    begin_desc_class(vm, "factory_desc_x", "obj_desc_x", (GETDESCFUNC)param<const factory_desc_t*>::getfunc());
    register_method(vm, &factory_desc_t::get_name, "get_name");
    register_method(vm, &factory_desc_t::get_building, "get_building_desc");
    register_method(vm, &factory_desc_t::is_electricity_producer, "is_electricity_producer");
    register_method(vm, &factory_desc_t::get_productivity, "get_productivity_base");
    register_method(vm, &factory_desc_t::get_range, "get_productivity_range");
    register_function(vm, get_factory_inputs, "get_inputs", 1, "t|x|y");
    register_function(vm, get_factory_outputs, "get_outputs", 1, "t|x|y");
    register_method(vm, &factory_builder_t::get_factory_table, "get_list", 1);

    end_class(vm);

    begin_desc_class(vm, "way_desc_x", "obj_desc_transport_x", (GETDESCFUNC)param<const way_desc_t*>::getfunc());
    register_method(vm, &way_desc_t::has_double_slopes, "has_double_slopes");
    register_method(vm, &way_desc_t::get_styp, "get_system_type");

    STATIC register_method(vm, way_builder_t::get_way_list, "get_available_ways", false, true);

    STATIC register_method(vm, &tool_build_way_t::get_default_desc, "get_default_way_desc", false, true);

    end_class(vm);

    begin_desc_class(vm, "tunnel_desc_x", "obj_desc_transport_x", (GETDESCFUNC)param<const tunnel_desc_t*>::getfunc());
    STATIC register_method(vm, tunnel_builder_t::get_available_tunnels, "get_available_tunnels", false, true);
    end_class(vm);

    begin_desc_class(vm, "bridge_desc_x", "obj_desc_transport_x", (GETDESCFUNC)param<const bridge_desc_t*>::getfunc());
    register_method(vm, &bridge_desc_t::has_double_ramp, "has_double_ramp");
    register_method(vm, &bridge_desc_t::has_double_start, "has_double_start");
    register_method(vm, &bridge_desc_t::get_max_length, "get_max_length");
    register_method(vm, &bridge_desc_t::get_max_height, "get_max_height");
    STATIC register_method(vm, bridge_builder_t::get_desc, "get_desc", false, true);
    STATIC register_method(vm, bridge_builder_t::get_available_bridges, "get_available_bridges", false, true);

    end_class(vm);

    create_class(vm, "good_desc_list_x", 0);
    register_function(vm, get_next_ware_desc,  "_nexti",  2, "x o|i");
    register_function(vm, get_goods_desc_index, "_get",    2, "xi");

    end_class(vm);

    begin_desc_class(vm, "good_desc_x", "obj_desc_x", (GETDESCFUNC)param<const goods_desc_t*>::getfunc());

    // dummy entry to create documentation of constructor
    // register_function( .., "constructor", .. )

    create_slot(vm, "passenger", goods_manager_t::passengers, true);
    create_slot(vm, "mail",      goods_manager_t::mail,       true);
#ifdef DOXYGEN
    static good_desc_x passenger; 
    static good_desc_x mail;      
#endif

    register_method(vm, &goods_desc_t::get_catg_index, "get_catg_index");

    register_method(vm, &goods_desc_t::is_interchangeable, "is_interchangeable");
    register_method(vm, &goods_desc_t::get_weight_per_unit, "get_weight_per_unit"); // in kg

    register_method(vm, &goods_desc_t::get_mass, "get_metric");

    register_method(vm, &ware_t::calc_revenue, "calc_revenue", true);
    end_class(vm);

    begin_desc_class(vm, "sign_desc_x", "obj_desc_transport_x", (GETDESCFUNC)param<const roadsign_desc_t*>::getfunc());

    register_method(vm, &roadsign_desc_t::is_single_way, "is_one_way");
    register_method(vm, &roadsign_desc_t::is_private_way, "is_private_way");
    register_method(vm, &is_traffic_light, "is_traffic_light", true);
    register_method(vm, &roadsign_desc_t::is_choose_sign, "is_choose_sign");
    register_method(vm, &roadsign_desc_t::is_simple_signal, "is_signal");
    register_method(vm, &roadsign_desc_t::is_pre_signal, "is_pre_signal");
    register_method(vm, &roadsign_desc_t::is_priority_signal, "is_priority_signal");
    register_method(vm, &roadsign_desc_t::is_longblock_signal, "is_longblock_signal");
    register_method(vm, &roadsign_desc_t::is_end_choose_signal, "is_end_choose_signal");
    STATIC register_method(vm, roadsign_t::get_available_signs, "get_available_signs", false, true);

    end_class(vm);
    begin_desc_class(vm, "wayobj_desc_x", "obj_desc_transport_x", (GETDESCFUNC)param<const way_obj_desc_t*>::getfunc());
    register_method(vm, &way_obj_desc_t::is_overhead_line, "is_overhead_line");
    STATIC register_method(vm, get_available_wayobjs, "get_available_wayobjs", false, true);
    end_class(vm);
}