diff options
Diffstat (limited to 'source/game/scripting/StarLuaGameConverters.cpp')
| -rw-r--r-- | source/game/scripting/StarLuaGameConverters.cpp | 601 |
1 files changed, 601 insertions, 0 deletions
diff --git a/source/game/scripting/StarLuaGameConverters.cpp b/source/game/scripting/StarLuaGameConverters.cpp new file mode 100644 index 0000000..e2fd516 --- /dev/null +++ b/source/game/scripting/StarLuaGameConverters.cpp @@ -0,0 +1,601 @@ +#include "StarLuaGameConverters.hpp" + +namespace Star { + +LuaValue LuaConverter<CollisionKind>::from(LuaEngine& engine, CollisionKind k) { + return engine.createString(CollisionKindNames.getRight(k)); +} + +Maybe<CollisionKind> LuaConverter<CollisionKind>::to(LuaEngine&, LuaValue const& v) { + if (auto str = v.ptr<LuaString>()) + return CollisionKindNames.maybeLeft(str->ptr()); + return {}; +} + +LuaValue LuaConverter<CollisionSet>::from(LuaEngine& engine, CollisionSet const& s) { + auto collisionTable = engine.createTable(); + int i = 1; + for (auto const& v : CollisionKindNames) { + if (s.contains(v.first)) { + collisionTable.set(i++, v.second); + } + } + return collisionTable; +} + +Maybe<CollisionSet> LuaConverter<CollisionSet>::to(LuaEngine& engine, LuaValue const& v) { + auto table = v.ptr<LuaTable>(); + if (!table) + return {}; + + CollisionSet result; + bool failed = false; + table->iterate([&result, &failed, &engine](LuaValue, LuaValue value) { + if (auto k = engine.luaMaybeTo<CollisionKind>(move(value))) { + result.insert(*k); + return true; + } else { + failed = true; + return false; + } + }); + + if (failed) + return {}; + return result; +} + +LuaValue LuaConverter<PlatformerAStar::Path>::from(LuaEngine& engine, PlatformerAStar::Path const& path) { + auto convertNode = [&engine](PlatformerAStar::Node const& node) { + auto table = engine.createTable(); + table.set("position", node.position); + table.set("velocity", node.velocity); + return table; + }; + + LuaTable pathTable = engine.createTable(); + int pathTableIndex = 1; + for (auto const& edge : path) { + auto edgeTable = engine.createTable(); + edgeTable.set("cost", edge.cost); + edgeTable.set("action", PlatformerAStar::ActionNames.getRight(edge.action)); + edgeTable.set("jumpVelocity", edge.jumpVelocity); + edgeTable.set("source", convertNode(edge.source)); + edgeTable.set("target", convertNode(edge.target)); + pathTable.set(pathTableIndex++, move(edgeTable)); + } + return pathTable; +} + +LuaMethods<PlatformerAStar::PathFinder> LuaUserDataMethods<PlatformerAStar::PathFinder>::make() { + LuaMethods<PlatformerAStar::PathFinder> methods; + methods.registerMethodWithSignature<Maybe<bool>, PlatformerAStar::PathFinder&, Maybe<unsigned>>( + "explore", mem_fn(&PlatformerAStar::PathFinder::explore)); + methods.registerMethodWithSignature<Maybe<PlatformerAStar::Path>, PlatformerAStar::PathFinder&>( + "result", mem_fn(&PlatformerAStar::PathFinder::result)); + return methods; +} + +Maybe<PlatformerAStar::Parameters> LuaConverter<PlatformerAStar::Parameters>::to(LuaEngine&, LuaValue const& v) { + PlatformerAStar::Parameters p; + p.returnBest = false; + p.mustEndOnGround = false; + p.enableWalkSpeedJumps = false; + p.enableVerticalJumpAirControl = false; + if (v == LuaNil) + return p; + + auto table = v.ptr<LuaTable>(); + if (!table) + return {}; + + try { + p.maxDistance = table->get<Maybe<float>>("maxDistance"); + p.returnBest = table->get<Maybe<bool>>("returnBest").value(false); + p.mustEndOnGround = table->get<Maybe<bool>>("mustEndOnGround").value(false); + p.enableWalkSpeedJumps = table->get<Maybe<bool>>("enableWalkSpeedJumps").value(false); + p.enableVerticalJumpAirControl = table->get<Maybe<bool>>("enableVerticalJumpAirControl").value(false); + p.swimCost = table->get<Maybe<float>>("swimCost"); + p.jumpCost = table->get<Maybe<float>>("jumpCost"); + p.liquidJumpCost = table->get<Maybe<float>>("liquidJumpCost"); + p.dropCost = table->get<Maybe<float>>("dropCost"); + p.boundBox = table->get<RectF>("boundBox"); + p.standingBoundBox = table->get<RectF>("standingBoundBox"); + p.droppingBoundBox = table->get<RectF>("droppingBoundBox"); + p.smallJumpMultiplier = table->get<Maybe<float>>("smallJumpMultiplier"); + p.jumpDropXMultiplier = table->get<Maybe<float>>("jumpDropXMultiplier"); + p.maxFScore = table->get<double>("maxFScore"); + p.maxNodesToSearch = table->get<unsigned>("maxNodesToSearch"); + p.maxLandingVelocity = table->get<Maybe<float>>("maxLandingVelocity"); + } catch (LuaConversionException const&) { + return {}; + } + + return p; +} + +LuaValue LuaConverter<ActorJumpProfile>::from(LuaEngine& engine, ActorJumpProfile const& v) { + auto table = engine.createTable(); + table.set("jumpSpeed", v.jumpSpeed); + table.set("jumpControlForce", v.jumpControlForce); + table.set("jumpInitialPercentage", v.jumpInitialPercentage); + table.set("jumpHoldTime", v.jumpHoldTime); + table.set("jumpTotalHoldTime", v.jumpTotalHoldTime); + table.set("multiJump", v.multiJump); + table.set("reJumpDelay", v.reJumpDelay); + table.set("autoJump", v.autoJump); + table.set("collisionCancelled", v.collisionCancelled); + return table; +} + +Maybe<ActorJumpProfile> LuaConverter<ActorJumpProfile>::to(LuaEngine&, LuaValue const& v) { + if (v == LuaNil) + return ActorJumpProfile(); + + auto table = v.ptr<LuaTable>(); + if (!table) + return {}; + + try { + ActorJumpProfile ajp; + ajp.jumpSpeed = table->get<Maybe<float>>("jumpSpeed"); + ajp.jumpControlForce = table->get<Maybe<float>>("jumpControlForce"); + ajp.jumpInitialPercentage = table->get<Maybe<float>>("jumpInitialPercentage"); + ajp.jumpHoldTime = table->get<Maybe<float>>("jumpHoldTime"); + ajp.jumpTotalHoldTime = table->get<Maybe<float>>("jumpTotalHoldTime"); + ajp.multiJump = table->get<Maybe<bool>>("multiJump"); + ajp.reJumpDelay = table->get<Maybe<float>>("reJumpDelay"); + ajp.autoJump = table->get<Maybe<bool>>("autoJump"); + ajp.collisionCancelled = table->get<Maybe<bool>>("collisionCancelled"); + return ajp; + } catch (LuaConversionException const&) { + return {}; + } +} + +LuaValue LuaConverter<ActorMovementParameters>::from(LuaEngine& engine, ActorMovementParameters const& v) { + auto table = engine.createTable(); + table.set("mass", v.mass); + table.set("gravityMultiplier", v.gravityMultiplier); + table.set("liquidBuoyancy", v.liquidBuoyancy); + table.set("airBuoyancy", v.airBuoyancy); + table.set("bounceFactor", v.bounceFactor); + table.set("slopeSlidingFactor", v.slopeSlidingFactor); + table.set("maxMovementPerStep", v.maxMovementPerStep); + table.set("maximumCorrection", v.maximumCorrection); + table.set("speedLimit", v.speedLimit); + table.set("standingPoly", v.standingPoly); + table.set("crouchingPoly", v.crouchingPoly); + table.set("stickyCollision", v.stickyCollision); + table.set("stickyForce", v.stickyForce); + table.set("walkSpeed", v.walkSpeed); + table.set("runSpeed", v.runSpeed); + table.set("flySpeed", v.flySpeed); + table.set("airFriction", v.airFriction); + table.set("liquidFriction", v.liquidFriction); + table.set("minimumLiquidPercentage", v.minimumLiquidPercentage); + table.set("liquidImpedance", v.liquidImpedance); + table.set("normalGroundFriction", v.normalGroundFriction); + table.set("ambulatingGroundFriction", v.ambulatingGroundFriction); + table.set("groundForce", v.groundForce); + table.set("airForce", v.airForce); + table.set("liquidForce", v.liquidForce); + table.set("airJumpProfile", v.airJumpProfile); + table.set("liquidJumpProfile", v.liquidJumpProfile); + table.set("fallStatusSpeedMin", v.fallStatusSpeedMin); + table.set("fallThroughSustainFrames", v.fallThroughSustainFrames); + table.set("maximumPlatformCorrection", v.maximumPlatformCorrection); + table.set("maximumPlatformCorrectionVelocityFactor", v.maximumPlatformCorrectionVelocityFactor); + table.set("physicsEffectCategories", v.physicsEffectCategories); + table.set("groundMovementMinimumSustain", v.groundMovementMinimumSustain); + table.set("groundMovementMaximumSustain", v.groundMovementMaximumSustain); + table.set("groundMovementCheckDistance", v.groundMovementCheckDistance); + table.set("collisionEnabled", v.collisionEnabled); + table.set("frictionEnabled", v.frictionEnabled); + table.set("gravityEnabled", v.gravityEnabled); + return table; +} + +Maybe<ActorMovementParameters> LuaConverter<ActorMovementParameters>::to(LuaEngine&, LuaValue const& v) { + if (v == LuaNil) + return ActorMovementParameters(); + + auto table = v.ptr<LuaTable>(); + if (!table) + return {}; + + try { + ActorMovementParameters amp; + amp.mass = table->get<Maybe<float>>("mass"); + amp.gravityMultiplier = table->get<Maybe<float>>("gravityMultiplier"); + amp.liquidBuoyancy = table->get<Maybe<float>>("liquidBuoyancy"); + amp.airBuoyancy = table->get<Maybe<float>>("airBuoyancy"); + amp.bounceFactor = table->get<Maybe<float>>("bounceFactor"); + amp.slopeSlidingFactor = table->get<Maybe<float>>("slopeSlidingFactor"); + amp.maxMovementPerStep = table->get<Maybe<float>>("maxMovementPerStep"); + amp.maximumCorrection = table->get<Maybe<float>>("maximumCorrection"); + amp.speedLimit = table->get<Maybe<float>>("speedLimit"); + amp.standingPoly = table->get<Maybe<PolyF>>("standingPoly").orMaybe(table->get<Maybe<PolyF>>("collisionPoly")); + amp.crouchingPoly = table->get<Maybe<PolyF>>("crouchingPoly").orMaybe(table->get<Maybe<PolyF>>("collisionPoly")); + amp.stickyCollision = table->get<Maybe<bool>>("stickyCollision"); + amp.stickyForce = table->get<Maybe<float>>("stickyForce"); + amp.walkSpeed = table->get<Maybe<float>>("walkSpeed"); + amp.runSpeed = table->get<Maybe<float>>("runSpeed"); + amp.flySpeed = table->get<Maybe<float>>("flySpeed"); + amp.airFriction = table->get<Maybe<float>>("airFriction"); + amp.liquidFriction = table->get<Maybe<float>>("liquidFriction"); + amp.minimumLiquidPercentage = table->get<Maybe<float>>("minimumLiquidPercentage"); + amp.liquidImpedance = table->get<Maybe<float>>("liquidImpedance"); + amp.normalGroundFriction = table->get<Maybe<float>>("normalGroundFriction"); + amp.ambulatingGroundFriction = table->get<Maybe<float>>("ambulatingGroundFriction"); + amp.groundForce = table->get<Maybe<float>>("groundForce"); + amp.airForce = table->get<Maybe<float>>("airForce"); + amp.liquidForce = table->get<Maybe<float>>("liquidForce"); + amp.airJumpProfile = table->get<ActorJumpProfile>("airJumpProfile"); + amp.liquidJumpProfile = table->get<ActorJumpProfile>("liquidJumpProfile"); + amp.fallStatusSpeedMin = table->get<Maybe<float>>("fallStatusSpeedMin"); + amp.fallThroughSustainFrames = table->get<Maybe<int>>("fallThroughSustainFrames"); + amp.maximumPlatformCorrection = table->get<Maybe<float>>("maximumPlatformCorrection"); + amp.maximumPlatformCorrectionVelocityFactor = table->get<Maybe<float>>("maximumPlatformCorrectionVelocityFactor"); + amp.physicsEffectCategories = table->get<Maybe<StringSet>>("physicsEffectCategories"); + amp.groundMovementMinimumSustain = table->get<Maybe<float>>("groundMovementMinimumSustain"); + amp.groundMovementMaximumSustain = table->get<Maybe<float>>("groundMovementMaximumSustain"); + amp.groundMovementCheckDistance = table->get<Maybe<float>>("groundMovementCheckDistance"); + amp.collisionEnabled = table->get<Maybe<bool>>("collisionEnabled"); + amp.frictionEnabled = table->get<Maybe<bool>>("frictionEnabled"); + amp.gravityEnabled = table->get<Maybe<bool>>("gravityEnabled"); + return amp; + } catch (LuaConversionException const&) { + return {}; + } +} + +LuaValue LuaConverter<ActorMovementModifiers>::from(LuaEngine& engine, ActorMovementModifiers const& v) { + auto table = engine.createTable(); + table.set("groundMovementModifier", v.groundMovementModifier); + table.set("liquidMovementModifier", v.liquidMovementModifier); + table.set("speedModifier", v.speedModifier); + table.set("airJumpModifier", v.airJumpModifier); + table.set("liquidJumpModifier", v.liquidJumpModifier); + table.set("runningSuppressed", v.runningSuppressed); + table.set("jumpingSuppressed", v.jumpingSuppressed); + table.set("facingSuppressed", v.facingSuppressed); + table.set("movementSuppressed", v.movementSuppressed); + return table; +} + +Maybe<ActorMovementModifiers> LuaConverter<ActorMovementModifiers>::to(LuaEngine&, LuaValue const& v) { + if (v == LuaNil) + return ActorMovementModifiers(); + + auto table = v.ptr<LuaTable>(); + if (!table) + return {}; + + try { + ActorMovementModifiers amm; + amm.groundMovementModifier = table->get<Maybe<float>>("groundMovementModifier").value(1.0f); + amm.liquidMovementModifier = table->get<Maybe<float>>("liquidMovementModifier").value(1.0f); + amm.speedModifier = table->get<Maybe<float>>("speedModifier").value(1.0f); + amm.airJumpModifier = table->get<Maybe<float>>("airJumpModifier").value(1.0f); + amm.liquidJumpModifier = table->get<Maybe<float>>("liquidJumpModifier").value(1.0f); + amm.runningSuppressed = table->get<Maybe<bool>>("runningSuppressed").value(false); + amm.jumpingSuppressed = table->get<Maybe<bool>>("jumpingSuppressed").value(false); + amm.facingSuppressed = table->get<Maybe<bool>>("facingSuppressed").value(false); + amm.movementSuppressed = table->get<Maybe<bool>>("movementSuppressed").value(false); + return amm; + } catch (LuaConversionException const&) { + return {}; + } +} + +LuaValue LuaConverter<StatModifier>::from(LuaEngine& engine, StatModifier const& v) { + return engine.luaFrom(jsonFromStatModifier(v)); +} + +Maybe<StatModifier> LuaConverter<StatModifier>::to(LuaEngine& engine, LuaValue v) { + auto json = engine.luaMaybeTo<Json>(move(v)); + if (!json) + return {}; + + try { + return jsonToStatModifier(json.take()); + } catch (JsonException const&) { + return {}; + } +} + +LuaValue LuaConverter<EphemeralStatusEffect>::from(LuaEngine& engine, EphemeralStatusEffect const& v) { + auto table = engine.createTable(); + table.set("effect", v.uniqueEffect); + table.set("duration", v.duration); + return table; +} + +Maybe<EphemeralStatusEffect> LuaConverter<EphemeralStatusEffect>::to(LuaEngine& engine, LuaValue const& v) { + if (auto s = v.ptr<LuaString>()) { + return EphemeralStatusEffect{UniqueStatusEffect(s->ptr()), {}}; + } else if (auto table = v.ptr<LuaTable>()) { + auto effect = engine.luaMaybeTo<String>(table->get("effect")); + auto duration = engine.luaMaybeTo<Maybe<float>>(table->get("duratino")); + if (effect && duration) + return EphemeralStatusEffect{effect.take(), duration.take()}; + } + + return {}; +} + +LuaValue LuaConverter<DamageRequest>::from(LuaEngine& engine, DamageRequest const& v) { + auto table = engine.createTable(); + table.set("hitType", HitTypeNames.getRight(v.hitType)); + table.set("damageType", DamageTypeNames.getRight(v.damageType)); + table.set("damage", v.damage); + table.set("knockbackMomentum", v.knockbackMomentum); + table.set("sourceEntityId", v.sourceEntityId); + table.set("damageSourceKind", v.damageSourceKind); + table.set("statusEffects", v.statusEffects); + return table; +} + +Maybe<DamageRequest> LuaConverter<DamageRequest>::to(LuaEngine&, LuaValue const& v) { + auto table = v.ptr<LuaTable>(); + if (!table) + return {}; + + try { + DamageRequest dr; + if (auto hitType = table->get<Maybe<String>>("hitType")) + dr.hitType = HitTypeNames.getLeft(*hitType); + if (auto damageType = table->get<Maybe<String>>("damageType")) + dr.damageType = DamageTypeNames.getLeft(*damageType); + dr.damage = table->get<float>("damage"); + if (auto knockbackMomentum = table->get<Maybe<Vec2F>>("knockbackMomentum")) + dr.knockbackMomentum = *knockbackMomentum; + if (auto sourceEntityId = table->get<Maybe<EntityId>>("sourceEntityId")) + dr.sourceEntityId = *sourceEntityId; + if (auto damageSourceKind = table->get<Maybe<String>>("damageSourceKind")) + dr.damageSourceKind = damageSourceKind.take(); + if (auto statusEffects = table->get<Maybe<List<EphemeralStatusEffect>>>("statusEffects")) + dr.statusEffects = statusEffects.take(); + return dr; + } catch (LuaConversionException const&) { + return {}; + } catch (MapException const&) { + return {}; + } +} + +LuaValue LuaConverter<DamageNotification>::from(LuaEngine& engine, DamageNotification const& v) { + auto table = engine.createTable(); + table.set("sourceEntityId", v.sourceEntityId); + table.set("targetEntityId", v.targetEntityId); + table.set("position", v.position); + table.set("damageDealt", v.damageDealt); + table.set("healthLost", v.healthLost); + table.set("hitType", HitTypeNames.getRight(v.hitType)); + table.set("damageSourceKind", v.damageSourceKind); + table.set("targetMaterialKind", v.targetMaterialKind); + return table; +} + +Maybe<DamageNotification> LuaConverter<DamageNotification>::to(LuaEngine&, LuaValue const& v) { + auto table = v.ptr<LuaTable>(); + if (!table) + return {}; + try { + DamageNotification dn; + dn.sourceEntityId = table->get<EntityId>("sourceEntityId"); + dn.targetEntityId = table->get<EntityId>("targetEntityId"); + dn.position = table->get<Vec2F>("position"); + dn.damageDealt = table->get<float>("damageDealt"); + dn.healthLost = table->get<float>("healthLost"); + dn.hitType = HitTypeNames.getLeft(table->get<String>("hitType")); + dn.damageSourceKind = table->get<String>("damageSourceKind"); + dn.targetMaterialKind = table->get<String>("targetMaterialKind"); + return dn; + } catch (LuaConversionException const&) { + return {}; + } catch (MapException const&) { + return {}; + } +} + +LuaValue LuaConverter<LiquidLevel>::from(LuaEngine& engine, LiquidLevel const& v) { + auto table = engine.createTable(); + table.set(1, v.liquid); + table.set(2, v.level); + return table; +} + +Maybe<LiquidLevel> LuaConverter<LiquidLevel>::to(LuaEngine& engine, LuaValue const& v) { + if (auto table = v.ptr<LuaTable>()) { + auto liquid = engine.luaMaybeTo<LiquidId>(table->get(1)); + auto level = engine.luaMaybeTo<uint8_t>(table->get(2)); + if (liquid && level) + return LiquidLevel(liquid.take(), level.take()); + } + return {}; +} + +LuaValue LuaConverter<Collection>::from(LuaEngine& engine, Collection const& c) { + auto table = engine.createTable(); + table.set("name", c.name); + table.set("type", CollectionTypeNames.getRight(c.type)); + table.set("title", c.title); + return table; +} + +Maybe<Collection> LuaConverter<Collection>::to(LuaEngine& engine, LuaValue const& v) { + if (auto table = v.ptr<LuaTable>()) { + auto name = engine.luaMaybeTo<String>(table->get("name")); + auto type = engine.luaMaybeTo<String>(table->get("type")); + auto title = engine.luaMaybeTo<String>(table->get("title")); + if (name && type && CollectionTypeNames.hasRightValue(*type) && title) + return Collection(*name, CollectionTypeNames.getLeft(*type), *title); + } + + return {}; +} + +LuaValue LuaConverter<Collectable>::from(LuaEngine& engine, Collectable const& c) { + auto table = engine.createTable(); + table.set("name", c.name); + table.set("order", c.order); + table.set("title", c.title); + table.set("description", c.description); + table.set("icon", c.icon); + return table; +} + +Maybe<Collectable> LuaConverter<Collectable>::to(LuaEngine& engine, LuaValue const& v) { + if (auto table = v.ptr<LuaTable>()) { + auto name = engine.luaMaybeTo<String>(table->get("name")); + if (name) { + return Collectable(*name, + engine.luaMaybeTo<int>(table->get("order")).value(0), + engine.luaMaybeTo<String>(table->get("title")).value(""), + engine.luaMaybeTo<String>(table->get("description")).value(""), + engine.luaMaybeTo<String>(table->get("icon")).value("")); + } + } + + return {}; +} + +LuaMethods<BehaviorStateWeakPtr> LuaUserDataMethods<BehaviorStateWeakPtr>::make() { + LuaMethods<BehaviorStateWeakPtr> methods; + methods.registerMethodWithSignature<NodeStatus, BehaviorStateWeakPtr, float>( + "run", [](BehaviorStateWeakPtr const& behavior, float dt) -> NodeStatus { + if (behavior.expired()) + throw StarException("Use of expired blackboard"); + + return behavior.lock()->run(dt); + }); + methods.registerMethodWithSignature<void, BehaviorStateWeakPtr>( + "clear", [](BehaviorStateWeakPtr const& behavior) { + if (behavior.expired()) + throw StarException("Use of expired blackboard"); + + behavior.lock()->clear(); + }); + methods.registerMethodWithSignature<BlackboardWeakPtr, BehaviorStateWeakPtr>( + "blackboard", [](BehaviorStateWeakPtr const& behavior) -> BlackboardWeakPtr { + if (behavior.expired()) + throw StarException("Use of expired blackboard"); + + return behavior.lock()->blackboardPtr(); + }); + return methods; +} + +LuaValue LuaConverter<NodeStatus>::from(LuaEngine&, NodeStatus const& status) { + if (status == NodeStatus::Success) + return true; + else if (status == NodeStatus::Failure) + return false; + else + return {}; +} + +NodeStatus LuaConverter<NodeStatus>::to(LuaEngine&, LuaValue const& v) { + if (v.is<LuaBoolean>()) + return v.get<LuaBoolean>() == true ? NodeStatus::Success : NodeStatus::Failure; + else + return NodeStatus::Running; +} + +LuaMethods<BlackboardWeakPtr> LuaUserDataMethods<BlackboardWeakPtr>::make() { + LuaMethods<BlackboardWeakPtr> methods; + + auto get =[](BlackboardWeakPtr const& board, NodeParameterType const& type, String const& key) -> LuaValue { + if (board.expired()) + throw StarException("Use of expired blackboard"); + + return board.lock()->get(type, key); + }; + auto set = [](BlackboardWeakPtr const& board, NodeParameterType const& type, String const& key, LuaValue const& value) { + if (board.expired()) + throw StarException("Use of expired blackboard"); + + board.lock()->set(type, key, value); + }; + + methods.registerMethodWithSignature<LuaValue, BlackboardWeakPtr, String, String>("get", + [&](BlackboardWeakPtr const& board, String const& type, String const& key) -> LuaValue { + return get(board, NodeParameterTypeNames.getLeft(type), key); + }); + methods.registerMethodWithSignature<void, BlackboardWeakPtr, String, String, LuaValue>("set", + [&](BlackboardWeakPtr const& board, String const& type, String const& key, LuaValue const& value) { + set(board, NodeParameterTypeNames.getLeft(type), key, value); + }); + + methods.registerMethodWithSignature<LuaValue, BlackboardWeakPtr, String>( + "getEntity", [&](BlackboardWeakPtr const& board, String const& key) -> LuaValue { + return get(board, NodeParameterType::Entity, key); + }); + methods.registerMethodWithSignature<LuaValue, BlackboardWeakPtr, String>( + "getPosition", [&](BlackboardWeakPtr const& board, String const& key) -> LuaValue { + return get(board, NodeParameterType::Position, key); + }); + methods.registerMethodWithSignature<LuaValue, BlackboardWeakPtr, String>( + "getVec2", [&](BlackboardWeakPtr const& board, String const& key) -> LuaValue { + return get(board, NodeParameterType::Vec2, key); + }); + methods.registerMethodWithSignature<LuaValue, BlackboardWeakPtr, String>( + "getNumber", [&](BlackboardWeakPtr const& board, String const& key) -> LuaValue { + return get(board, NodeParameterType::Number, key); + }); + methods.registerMethodWithSignature<LuaValue, BlackboardWeakPtr, String>( + "getBool", [&](BlackboardWeakPtr const& board, String const& key) -> LuaValue { + return get(board, NodeParameterType::Bool, key); + }); + methods.registerMethodWithSignature<LuaValue, BlackboardWeakPtr, String>( + "getList", [&](BlackboardWeakPtr const& board, String const& key) -> LuaValue { + return get(board, NodeParameterType::List, key); + }); + methods.registerMethodWithSignature<LuaValue, BlackboardWeakPtr, String>( + "getTable", [&](BlackboardWeakPtr const& board, String const& key) -> LuaValue { + return get(board, NodeParameterType::Table, key); + }); + methods.registerMethodWithSignature<LuaValue, BlackboardWeakPtr, String>( + "getString", [&](BlackboardWeakPtr const& board, String const& key) -> LuaValue { + return get(board, NodeParameterType::String, key); + }); + + + methods.registerMethodWithSignature<void, BlackboardWeakPtr, String, LuaValue>( + "setEntity", [&](BlackboardWeakPtr const& board, String const& key, LuaValue const& value) { + set(board, NodeParameterType::Entity, key, value); + }); + methods.registerMethodWithSignature<void, BlackboardWeakPtr, String, LuaValue>( + "setPosition", [&](BlackboardWeakPtr const& board, String const& key, LuaValue const& value) { + set(board, NodeParameterType::Position, key, value); + }); + methods.registerMethodWithSignature<void, BlackboardWeakPtr, String, LuaValue>( + "setVec2", [&](BlackboardWeakPtr const& board, String const& key, LuaValue const& value) { + set(board, NodeParameterType::Vec2, key, value); + }); + methods.registerMethodWithSignature<void, BlackboardWeakPtr, String, LuaValue>( + "setNumber", [&](BlackboardWeakPtr const& board, String const& key, LuaValue const& value) { + set(board, NodeParameterType::Number, key, value); + }); + methods.registerMethodWithSignature<void, BlackboardWeakPtr, String, LuaValue>( + "setBool", [&](BlackboardWeakPtr const& board, String const& key, LuaValue const& value) { + set(board, NodeParameterType::Bool, key, value); + }); + methods.registerMethodWithSignature<void, BlackboardWeakPtr, String, LuaValue>( + "setList", [&](BlackboardWeakPtr const& board, String const& key, LuaValue const& value) { + set(board, NodeParameterType::List, key, value); + }); + methods.registerMethodWithSignature<void, BlackboardWeakPtr, String, LuaValue>( + "setTable", [&](BlackboardWeakPtr const& board, String const& key, LuaValue const& value) { + set(board, NodeParameterType::Table, key, value); + }); + methods.registerMethodWithSignature<void, BlackboardWeakPtr, String, LuaValue>( + "setString", [&](BlackboardWeakPtr const& board, String const& key, LuaValue const& value) { + set(board, NodeParameterType::String, key, value); + }); + return methods; +} + +} |