185 lines
6.3 KiB
C++
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
|