osb/source/game/scripting/StarLuaGameConverters.hpp

185 lines
6.3 KiB
C++

#ifndef STAR_LUA_GAME_CONVERTERS_HPP
#define STAR_LUA_GAME_CONVERTERS_HPP
#include "StarLuaConverters.hpp"
#include "StarInventoryTypes.hpp"
#include "StarCollisionBlock.hpp"
#include "StarPlatformerAStar.hpp"
#include "StarActorMovementController.hpp"
#include "StarDamage.hpp"
#include "StarCollectionDatabase.hpp"
#include "StarBehaviorState.hpp"
#include "StarSystemWorld.hpp"
#include "StarDrawable.hpp"
#include "StarRpcThreadPromise.hpp"
namespace Star {
template <>
struct LuaConverter<InventorySlot> {
static LuaValue from(LuaEngine& engine, InventorySlot k);
static Maybe<InventorySlot> to(LuaEngine& engine, LuaValue const& v);
};
template <>
struct LuaConverter<CollisionKind> {
static LuaValue from(LuaEngine& engine, CollisionKind k);
static Maybe<CollisionKind> to(LuaEngine& engine, LuaValue const& v);
};
template <>
struct LuaConverter<CollisionSet> {
static LuaValue from(LuaEngine& engine, CollisionSet const& s);
static Maybe<CollisionSet> to(LuaEngine& engine, LuaValue const& v);
};
template <typename T>
struct LuaConverter<RpcPromise<T>> : LuaUserDataConverter<RpcPromise<T>> {};
template <typename T>
struct LuaUserDataMethods<RpcPromise<T>> {
static LuaMethods<RpcPromise<T>> make();
};
template <typename T>
struct LuaConverter<RpcThreadPromise<T>> : LuaUserDataConverter<RpcThreadPromise<T>> {};
template <typename T>
struct LuaUserDataMethods<RpcThreadPromise<T>> {
static LuaMethods<RpcThreadPromise<T>> make();
};
template <>
struct LuaConverter<PlatformerAStar::Path> {
static LuaValue from(LuaEngine& engine, PlatformerAStar::Path const& path);
};
template <>
struct LuaConverter<PlatformerAStar::PathFinder> : LuaUserDataConverter<PlatformerAStar::PathFinder> {};
template <>
struct LuaUserDataMethods<PlatformerAStar::PathFinder> {
static LuaMethods<PlatformerAStar::PathFinder> make();
};
template <>
struct LuaConverter<PlatformerAStar::Parameters> {
static Maybe<PlatformerAStar::Parameters> to(LuaEngine& engine, LuaValue const& v);
};
template <>
struct LuaConverter<ActorJumpProfile> {
static LuaValue from(LuaEngine& engine, ActorJumpProfile const& v);
static Maybe<ActorJumpProfile> to(LuaEngine& engine, LuaValue const& v);
};
template <>
struct LuaConverter<ActorMovementParameters> {
static LuaValue from(LuaEngine& engine, ActorMovementParameters const& v);
static Maybe<ActorMovementParameters> to(LuaEngine& engine, LuaValue const& v);
};
template <>
struct LuaConverter<ActorMovementModifiers> {
static LuaValue from(LuaEngine& engine, ActorMovementModifiers const& v);
static Maybe<ActorMovementModifiers> to(LuaEngine& engine, LuaValue const& v);
};
template <>
struct LuaConverter<StatModifier> {
static LuaValue from(LuaEngine& engine, StatModifier const& v);
static Maybe<StatModifier> to(LuaEngine& engine, LuaValue v);
};
template <>
struct LuaConverter<EphemeralStatusEffect> {
static LuaValue from(LuaEngine& engine, EphemeralStatusEffect const& v);
static Maybe<EphemeralStatusEffect> to(LuaEngine& engine, LuaValue const& v);
};
template <>
struct LuaConverter<DamageRequest> {
static LuaValue from(LuaEngine& engine, DamageRequest const& v);
static Maybe<DamageRequest> to(LuaEngine& engine, LuaValue const& v);
};
template <>
struct LuaConverter<DamageNotification> {
static LuaValue from(LuaEngine& engine, DamageNotification const& v);
static Maybe<DamageNotification> to(LuaEngine& engine, LuaValue const& v);
};
template <>
struct LuaConverter<LiquidLevel> {
static LuaValue from(LuaEngine& engine, LiquidLevel const& v);
static Maybe<LiquidLevel> to(LuaEngine& engine, LuaValue const& v);
};
template <>
struct LuaConverter<Drawable> {
static LuaValue from(LuaEngine& engine, Drawable const& v);
static Maybe<Drawable> to(LuaEngine& engine, LuaValue const& v);
};
template <typename T>
LuaMethods<RpcPromise<T>> LuaUserDataMethods<RpcPromise<T>>::make() {
LuaMethods<RpcPromise<T>> methods;
methods.template registerMethodWithSignature<bool, RpcPromise<T>&>("finished", mem_fn(&RpcPromise<T>::finished));
methods.template registerMethodWithSignature<bool, RpcPromise<T>&>("succeeded", mem_fn(&RpcPromise<T>::succeeded));
methods.template registerMethodWithSignature<Maybe<T>, RpcPromise<T>&>("result", mem_fn(&RpcPromise<T>::result));
methods.template registerMethodWithSignature<Maybe<String>, RpcPromise<T>&>("error", mem_fn(&RpcPromise<T>::error));
return methods;
}
template <typename T>
LuaMethods<RpcThreadPromise<T>> LuaUserDataMethods<RpcThreadPromise<T>>::make() {
LuaMethods<RpcThreadPromise<T>> methods;
methods.template registerMethodWithSignature<bool, RpcThreadPromise<T>&>("finished", mem_fn(&RpcThreadPromise<T>::finished));
methods.template registerMethodWithSignature<bool, RpcThreadPromise<T>&>("succeeded", mem_fn(&RpcThreadPromise<T>::succeeded));
methods.template registerMethodWithSignature<Maybe<T>, RpcThreadPromise<T>&>("result", mem_fn(&RpcThreadPromise<T>::result));
methods.template registerMethodWithSignature<Maybe<String>, RpcThreadPromise<T>&>("error", mem_fn(&RpcThreadPromise<T>::error));
return methods;
}
template <>
struct LuaConverter<Collection> {
static LuaValue from(LuaEngine& engine, Collection const& c);
static Maybe<Collection> to(LuaEngine& engine, LuaValue const& v);
};
template <>
struct LuaConverter<Collectable> {
static LuaValue from(LuaEngine& engine, Collectable const& c);
static Maybe<Collectable> to(LuaEngine& engine, LuaValue const& v);
};
// BehaviorState contains Lua references, putting it in a UserData violates
// the "don't put lua references in userdata, just don't" rule. We get around it by keeping
// a weak pointer to the behavior state, forcing it to be destroyed elsewhere.
template <>
struct LuaConverter<BehaviorStateWeakPtr> : LuaUserDataConverter<BehaviorStateWeakPtr> {};
template <>
struct LuaUserDataMethods<BehaviorStateWeakPtr> {
static LuaMethods<BehaviorStateWeakPtr> make();
};
template <>
struct LuaConverter<NodeStatus> {
static LuaValue from(LuaEngine& engine, NodeStatus const& status);
static NodeStatus to(LuaEngine& engine, LuaValue const& v);
};
// Weak pointer for the same reasons as BehaviorState.
template <>
struct LuaConverter<BlackboardWeakPtr> : LuaUserDataConverter<BlackboardWeakPtr> {};
template <>
struct LuaUserDataMethods<BlackboardWeakPtr> {
static LuaMethods<BlackboardWeakPtr> make();
};
}
#endif