evert/osb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
330fc938f3
osb/source/game/items/StarActiveItem.cpp
Kai Blaschke 431a9c00a5
Fixed a huge amount of Clang warnings 
On Linux and macOS, using Clang to compile OpenStarbound produces about 400 MB worth of warnings during the build, making the compiler output unreadable and slowing the build down considerably.

99% of the warnings were unqualified uses of std::move and std::forward, which are now all properly qualified.

Fixed a few other minor warnings about non-virtual destructors and some uses of std::move preventing copy elision on temporary objects.

Most remaining warnings are now unused parameters.
2024-02-19 16:55:19 +01:00

527 lines
20 KiB
C++
Raw Blame History

#include "StarActiveItem.hpp"
#include "StarRoot.hpp"
#include "StarAssets.hpp"
#include "StarConfigLuaBindings.hpp"
#include "StarItemLuaBindings.hpp"
#include "StarStatusControllerLuaBindings.hpp"
#include "StarNetworkedAnimatorLuaBindings.hpp"
#include "StarScriptedAnimatorLuaBindings.hpp"
#include "StarPlayerLuaBindings.hpp"
#include "StarEntityLuaBindings.hpp"
#include "StarJsonExtra.hpp"
#include "StarDataStreamExtra.hpp"
#include "StarPlayer.hpp"
#include "StarEmoteEntity.hpp"
namespace Star {
ActiveItem::ActiveItem(Json const& config, String const& directory, Json const& parameters)
: Item(config, directory, parameters) {
auto assets = Root::singleton().assets();
auto animationConfig = assets->fetchJson(instanceValue("animation"), directory);
if (auto customConfig = instanceValue("animationCustom"))
animationConfig = jsonMerge(animationConfig, customConfig);
m_itemAnimator = NetworkedAnimator(animationConfig, directory);
for (auto const& pair : instanceValue("animationParts", JsonObject()).iterateObject())
m_itemAnimator.setPartTag(pair.first, "partImage", pair.second.toString());
m_scriptedAnimationParameters.reset(config.getObject("scriptedAnimationParameters", {}));
addNetElement(&m_itemAnimator);
addNetElement(&m_holdingItem);
addNetElement(&m_backArmFrame);
addNetElement(&m_frontArmFrame);
addNetElement(&m_twoHandedGrip);
addNetElement(&m_recoil);
addNetElement(&m_outsideOfHand);
addNetElement(&m_armAngle);
addNetElement(&m_facingDirection);
addNetElement(&m_damageSources);
addNetElement(&m_itemDamageSources);
addNetElement(&m_shieldPolys);
addNetElement(&m_itemShieldPolys);
addNetElement(&m_forceRegions);
addNetElement(&m_itemForceRegions);
// don't interpolate scripted animation parameters
addNetElement(&m_scriptedAnimationParameters, false);
m_holdingItem.set(true);
m_armAngle.setFixedPointBase(0.01f);
}
ActiveItem::ActiveItem(ActiveItem const& rhs) : ActiveItem(rhs.config(), rhs.directory(), rhs.parameters()) {}
ItemPtr ActiveItem::clone() const {
return make_shared<ActiveItem>(*this);
}
void ActiveItem::init(ToolUserEntity* owner, ToolHand hand) {
ToolUserItem::init(owner, hand);
if (entityMode() == EntityMode::Master) {
m_script.setScripts(jsonToStringList(instanceValue("scripts")).transformed(bind(&AssetPath::relativeTo, directory(), _1)));
m_script.setUpdateDelta(instanceValue("scriptDelta", 1).toUInt());
m_twoHandedGrip.set(twoHanded());
if (auto previousStorage = instanceValue("scriptStorage"))
m_script.setScriptStorage(previousStorage.toObject());
m_script.addCallbacks("activeItem", makeActiveItemCallbacks());
m_script.addCallbacks("item", LuaBindings::makeItemCallbacks(this));
m_script.addCallbacks("config", LuaBindings::makeConfigCallbacks(bind(&Item::instanceValue, as<Item>(this), _1, _2)));
m_script.addCallbacks("animator", LuaBindings::makeNetworkedAnimatorCallbacks(&m_itemAnimator));
m_script.addCallbacks("status", LuaBindings::makeStatusControllerCallbacks(owner->statusController()));
m_script.addActorMovementCallbacks(owner->movementController());
if (auto player = as<Player>(owner))
m_script.addCallbacks("player", LuaBindings::makePlayerCallbacks(player));
m_script.addCallbacks("entity", LuaBindings::makeEntityCallbacks(as<Entity>(owner)));
m_script.init(world());
m_currentFireMode = FireMode::None;
}
if (world()->isClient()) {
if (auto animationScripts = instanceValue("animationScripts")) {
m_scriptedAnimator.setScripts(jsonToStringList(animationScripts).transformed(bind(&AssetPath::relativeTo, directory(), _1)));
m_scriptedAnimator.setUpdateDelta(instanceValue("animationDelta", 1).toUInt());
m_scriptedAnimator.addCallbacks("animationConfig", LuaBindings::makeScriptedAnimatorCallbacks(&m_itemAnimator,
[this](String const& name, Json const& defaultValue) -> Json {
return m_scriptedAnimationParameters.value(name, defaultValue);
}));
m_scriptedAnimator.addCallbacks("activeItemAnimation", makeScriptedAnimationCallbacks());
m_scriptedAnimator.addCallbacks("config", LuaBindings::makeConfigCallbacks(bind(&Item::instanceValue, as<Item>(this), _1, _2)));
m_scriptedAnimator.init(world());
}
}
}
void ActiveItem::uninit() {
if (entityMode() == EntityMode::Master) {
m_script.uninit();
m_script.removeCallbacks("activeItem");
m_script.removeCallbacks("item");
m_script.removeCallbacks("config");
m_script.removeCallbacks("animator");
m_script.removeCallbacks("status");
m_script.removeActorMovementCallbacks();
m_script.removeCallbacks("player");
m_script.removeCallbacks("entity");
}
if (world()->isClient()) {
if (auto animationScripts = instanceValue("animationScripts")) {
m_scriptedAnimator.uninit();
m_scriptedAnimator.removeCallbacks("animationConfig");
m_scriptedAnimator.removeCallbacks("activeItemAnimation");
m_scriptedAnimator.removeCallbacks("config");
}
}
m_itemAnimatorDynamicTarget.stopAudio();
ToolUserItem::uninit();
m_activeAudio.clear();
}
void ActiveItem::update(float dt, FireMode fireMode, bool shifting, HashSet<MoveControlType> const& moves) {
StringMap<bool> moveMap;
for (auto m : moves)
moveMap[MoveControlTypeNames.getRight(m)] = true;
if (entityMode() == EntityMode::Master) {
if (fireMode != m_currentFireMode) {
m_currentFireMode = fireMode;
if (fireMode != FireMode::None)
m_script.invoke("activate", FireModeNames.getRight(fireMode), shifting, moveMap);
}
m_script.update(m_script.updateDt(dt), FireModeNames.getRight(fireMode), shifting, moveMap);
if (instanceValue("retainScriptStorageInItem", false).toBool()) {
setInstanceValue("scriptStorage", m_script.getScriptStorage());
}
}
bool isClient = world()->isClient();
if (isClient) {
m_itemAnimator.update(dt, &m_itemAnimatorDynamicTarget);
m_scriptedAnimator.update(m_scriptedAnimator.updateDt(dt));
} else {
m_itemAnimator.update(dt, nullptr);
}
eraseWhere(m_activeAudio, [this](pair<AudioInstancePtr const, Vec2F> const& a) {
a.first->setPosition(owner()->position() + handPosition(a.second));
return a.first->finished();
});
for (auto shieldPoly : shieldPolys()) {
shieldPoly.translate(owner()->position());
if (isClient)
SpatialLogger::logPoly("world", shieldPoly, {255, 255, 0, 255});
}
if (isClient) {
for (auto forceRegion : forceRegions()) {
if (auto dfr = forceRegion.ptr<DirectionalForceRegion>())
SpatialLogger::logPoly("world", dfr->region, { 155, 0, 255, 255 });
else if (auto rfr = forceRegion.ptr<RadialForceRegion>())
SpatialLogger::logPoint("world", rfr->center, { 155, 0, 255, 255 });
}
}
}
List<DamageSource> ActiveItem::damageSources() const {
List<DamageSource> damageSources = m_damageSources.get();
for (auto ds : m_itemDamageSources.get()) {
if (ds.damageArea.is<PolyF>()) {
auto& poly = ds.damageArea.get<PolyF>();
poly.rotate(m_armAngle.get());
if (owner()->facingDirection() == Direction::Left)
poly.flipHorizontal(0.0f);
poly.translate(handPosition(Vec2F()));
} else if (ds.damageArea.is<Line2F>()) {
auto& line = ds.damageArea.get<Line2F>();
line.rotate(m_armAngle.get());
if (owner()->facingDirection() == Direction::Left)
line.flipHorizontal(0.0f);
line.translate(handPosition(Vec2F()));
}
damageSources.append(std::move(ds));
}
return damageSources;
}
List<PolyF> ActiveItem::shieldPolys() const {
List<PolyF> shieldPolys = m_shieldPolys.get();
for (auto sp : m_itemShieldPolys.get()) {
sp.rotate(m_armAngle.get());
if (owner()->facingDirection() == Direction::Left)
sp.flipHorizontal(0.0f);
sp.translate(handPosition(Vec2F()));
shieldPolys.append(std::move(sp));
}
return shieldPolys;
}
List<PhysicsForceRegion> ActiveItem::forceRegions() const {
List<PhysicsForceRegion> forceRegions = m_forceRegions.get();
for (auto fr : m_itemForceRegions.get()) {
if (auto dfr = fr.ptr<DirectionalForceRegion>()) {
dfr->region.rotate(m_armAngle.get());
if (owner()->facingDirection() == Direction::Left)
dfr->region.flipHorizontal(0.0f);
dfr->region.translate(owner()->position() + handPosition(Vec2F()));
} else if (auto rfr = fr.ptr<RadialForceRegion>()) {
rfr->center = rfr->center.rotate(m_armAngle.get());
if (owner()->facingDirection() == Direction::Left)
rfr->center[0] *= -1;
rfr->center += owner()->position() + handPosition(Vec2F());
}
forceRegions.append(std::move(fr));
}
return forceRegions;
}
bool ActiveItem::holdingItem() const {
return m_holdingItem.get();
}
Maybe<String> ActiveItem::backArmFrame() const {
return m_backArmFrame.get();
}
Maybe<String> ActiveItem::frontArmFrame() const {
return m_frontArmFrame.get();
}
bool ActiveItem::twoHandedGrip() const {
return m_twoHandedGrip.get();
}
bool ActiveItem::recoil() const {
return m_recoil.get();
}
bool ActiveItem::outsideOfHand() const {
return m_outsideOfHand.get();
}
float ActiveItem::armAngle() const {
return m_armAngle.get();
}
Maybe<Direction> ActiveItem::facingDirection() const {
return m_facingDirection.get();
}
List<Drawable> ActiveItem::handDrawables() const {
if (m_itemAnimator.parts().empty()) {
auto drawables = Item::iconDrawables();
Drawable::scaleAll(drawables, 1.0f / TilePixels);
return drawables;
} else {
return m_itemAnimator.drawables();
}
}
List<pair<Drawable, Maybe<EntityRenderLayer>>> ActiveItem::entityDrawables() const {
return m_scriptedAnimator.drawables();
}
List<LightSource> ActiveItem::lights() const {
// Same as pullNewAudios, we translate and flip ourselves.
List<LightSource> result;
for (auto& light : m_itemAnimator.lightSources()) {
light.position = owner()->position() + handPosition(light.position);
light.beamAngle += m_armAngle.get();
if (owner()->facingDirection() == Direction::Left) {
if (light.beamAngle > 0)
light.beamAngle = Constants::pi / 2 + constrainAngle(Constants::pi / 2 - light.beamAngle);
else
light.beamAngle = -Constants::pi / 2 - constrainAngle(light.beamAngle + Constants::pi / 2);
}
result.append(std::move(light));
}
result.appendAll(m_scriptedAnimator.lightSources());
return result;
}
List<AudioInstancePtr> ActiveItem::pullNewAudios() {
// Because the item animator is in hand-space, and Humanoid does all the
// translation *and flipping*, we cannot use NetworkedAnimator's built-in
// functionality to rotate and flip, and instead must do it manually. We do
// not call animatorTarget.setPosition, and keep track of running audio
// ourselves. It would be easier if (0, 0) for the NetworkedAnimator was,
// say, the shoulder and un-rotated, but it gets a bit weird with Humanoid
// modifications.
List<AudioInstancePtr> result;
for (auto& audio : m_itemAnimatorDynamicTarget.pullNewAudios()) {
m_activeAudio[audio] = *audio->position();
audio->setPosition(owner()->position() + handPosition(*audio->position()));
result.append(std::move(audio));
}
result.appendAll(m_scriptedAnimator.pullNewAudios());
return result;
}
List<Particle> ActiveItem::pullNewParticles() {
// Same as pullNewAudios, we translate, rotate, and flip ourselves
List<Particle> result;
for (auto& particle : m_itemAnimatorDynamicTarget.pullNewParticles()) {
particle.position = owner()->position() + handPosition(particle.position);
particle.velocity = particle.velocity.rotate(m_armAngle.get());
if (owner()->facingDirection() == Direction::Left) {
particle.velocity[0] *= -1;
particle.flip = !particle.flip;
}
result.append(std::move(particle));
}
result.appendAll(m_scriptedAnimator.pullNewParticles());
return result;
}
Maybe<String> ActiveItem::cursor() const {
return m_cursor;
}
Maybe<Json> ActiveItem::receiveMessage(String const& message, bool localMessage, JsonArray const& args) {
return m_script.handleMessage(message, localMessage, args);
}
float ActiveItem::durabilityStatus() {
auto durability = instanceValue("durability").optFloat();
if (durability) {
auto durabilityHit = instanceValue("durabilityHit").optFloat().value(*durability);
return durabilityHit / *durability;
}
return 1.0;
}
Vec2F ActiveItem::armPosition(Vec2F const& offset) const {
return owner()->armPosition(hand(), owner()->facingDirection(), m_armAngle.get(), offset);
}
Vec2F ActiveItem::handPosition(Vec2F const& offset) const {
return armPosition(offset + owner()->handOffset(hand(), owner()->facingDirection()));
}
LuaCallbacks ActiveItem::makeActiveItemCallbacks() {
LuaCallbacks callbacks;
callbacks.registerCallback("ownerEntityId", [this]() {
return owner()->entityId();
});
callbacks.registerCallback("ownerTeam", [this]() {
return owner()->getTeam().toJson();
});
callbacks.registerCallback("ownerAimPosition", [this]() {
return owner()->aimPosition();
});
callbacks.registerCallback("ownerPowerMultiplier", [this]() {
return owner()->powerMultiplier();
});
callbacks.registerCallback("fireMode", [this]() {
return FireModeNames.getRight(m_currentFireMode);
});
callbacks.registerCallback("hand", [this]() {
return ToolHandNames.getRight(hand());
});
callbacks.registerCallback("handPosition", [this](Maybe<Vec2F> offset) {
return handPosition(offset.value());
});
// Gets the required aim angle to aim a "barrel" of the item that has the given
// vertical offset from the hand at the given target. The line that is aimed
// at the target is the horizontal line going through the aimVerticalOffset.
callbacks.registerCallback("aimAngleAndDirection", [this](float aimVerticalOffset, Vec2F targetPosition) {
// This was figured out using pencil and paper geometry from the hand
// rotation center, the target position, and the 90 deg vertical offset of
// the "barrel".
Vec2F handRotationCenter = owner()->armPosition(hand(), owner()->facingDirection(), 0.0f, Vec2F());
Vec2F ownerPosition = owner()->position();
// Vector in owner entity space from hand rotation center to target.
Vec2F toTarget = owner()->world()->geometry().diff(targetPosition, (ownerPosition + handRotationCenter));
float toTargetDist = toTarget.magnitude();
// If the aim position is inside the circle formed by the barrel line as it
// goes around (aimVerticalOffset <= toTargetDist) absolutely no angle will
// give you an intersect, so we just bail out and assume the target is at the
// edge of the circle to retain continuity.
float angleAdjust = -std::asin(clamp(aimVerticalOffset / toTargetDist, -1.0f, 1.0f));
auto angleSide = getAngleSide(toTarget.angle());
return luaTupleReturn(angleSide.first + angleAdjust, numericalDirection(angleSide.second));
});
// Similar to aimAngleAndDirection, but only provides the offset-adjusted aimAngle for the current facing direction
callbacks.registerCallback("aimAngle", [this](float aimVerticalOffset, Vec2F targetPosition) {
Vec2F handRotationCenter = owner()->armPosition(hand(), owner()->facingDirection(), 0.0f, Vec2F());
Vec2F ownerPosition = owner()->position();
Vec2F toTarget = owner()->world()->geometry().diff(targetPosition, (ownerPosition + handRotationCenter));
float toTargetDist = toTarget.magnitude();
float angleAdjust = -std::asin(clamp(aimVerticalOffset / toTargetDist, -1.0f, 1.0f));
return toTarget.angle() + angleAdjust;
});
callbacks.registerCallback("setHoldingItem", [this](bool holdingItem) {
m_holdingItem.set(holdingItem);
});
callbacks.registerCallback("setBackArmFrame", [this](Maybe<String> armFrame) {
m_backArmFrame.set(armFrame);
});
callbacks.registerCallback("setFrontArmFrame", [this](Maybe<String> armFrame) {
m_frontArmFrame.set(armFrame);
});
callbacks.registerCallback("setTwoHandedGrip", [this](bool twoHandedGrip) {
m_twoHandedGrip.set(twoHandedGrip);
});
callbacks.registerCallback("setRecoil", [this](bool recoil) {
m_recoil.set(recoil);
});
callbacks.registerCallback("setOutsideOfHand", [this](bool outsideOfHand) {
m_outsideOfHand.set(outsideOfHand);
});
callbacks.registerCallback("setArmAngle", [this](float armAngle) {
m_armAngle.set(armAngle);
});
callbacks.registerCallback("setFacingDirection", [this](float direction) {
m_facingDirection.set(directionOf(direction));
});
callbacks.registerCallback("setDamageSources", [this](Maybe<JsonArray> const& damageSources) {
m_damageSources.set(damageSources.value().transformed(construct<DamageSource>()));
});
callbacks.registerCallback("setItemDamageSources", [this](Maybe<JsonArray> const& damageSources) {
m_itemDamageSources.set(damageSources.value().transformed(construct<DamageSource>()));
});
callbacks.registerCallback("setShieldPolys", [this](Maybe<List<PolyF>> const& shieldPolys) {
m_shieldPolys.set(shieldPolys.value());
});
callbacks.registerCallback("setItemShieldPolys", [this](Maybe<List<PolyF>> const& shieldPolys) {
m_itemShieldPolys.set(shieldPolys.value());
});
callbacks.registerCallback("setForceRegions", [this](Maybe<JsonArray> const& forceRegions) {
if (forceRegions)
m_forceRegions.set(forceRegions->transformed(jsonToPhysicsForceRegion));
else
m_forceRegions.set({});
});
callbacks.registerCallback("setItemForceRegions", [this](Maybe<JsonArray> const& forceRegions) {
if (forceRegions)
m_itemForceRegions.set(forceRegions->transformed(jsonToPhysicsForceRegion));
else
m_itemForceRegions.set({});
});
callbacks.registerCallback("setCursor", [this](Maybe<String> cursor) {
m_cursor = std::move(cursor);
});
callbacks.registerCallback("setScriptedAnimationParameter", [this](String name, Json value) {
m_scriptedAnimationParameters.set(std::move(name), std::move(value));
});
callbacks.registerCallback("setInventoryIcon", [this](String image) {
setInstanceValue("inventoryIcon", image);
setIconDrawables({Drawable::makeImage(std::move(image), 1.0f, true, Vec2F())});
});
callbacks.registerCallback("setInstanceValue", [this](String name, Json val) {
setInstanceValue(std::move(name), std::move(val));
});
callbacks.registerCallback("callOtherHandScript", [this](String const& func, LuaVariadic<LuaValue> const& args) {
if (auto otherHandItem = owner()->handItem(hand() == ToolHand::Primary ? ToolHand::Alt : ToolHand::Primary)) {
if (auto otherActiveItem = as<ActiveItem>(otherHandItem))
return otherActiveItem->m_script.invoke(func, args).value();
}
return LuaValue();
});
callbacks.registerCallback("interact", [this](String const& type, Json const& configData, Maybe<EntityId> const& sourceEntityId) {
owner()->interact(InteractAction(type, sourceEntityId.value(NullEntityId), configData));
});
callbacks.registerCallback("emote", [this](String const& emoteName) {
auto emote = HumanoidEmoteNames.getLeft(emoteName);
if (auto entity = as<EmoteEntity>(owner()))
entity->playEmote(emote);
});
callbacks.registerCallback("setCameraFocusEntity", [this](Maybe<EntityId> const& cameraFocusEntity) {
owner()->setCameraFocusEntity(cameraFocusEntity);
});
return callbacks;
}
LuaCallbacks ActiveItem::makeScriptedAnimationCallbacks() {
LuaCallbacks callbacks;
callbacks.registerCallback("ownerPosition", [this]() {
return owner()->position();
});
callbacks.registerCallback("ownerAimPosition", [this]() {
return owner()->aimPosition();
});
callbacks.registerCallback("ownerArmAngle", [this]() {
return m_armAngle.get();
});
callbacks.registerCallback("ownerFacingDirection", [this]() {
return numericalDirection(owner()->facingDirection());
});
callbacks.registerCallback("handPosition", [this](Maybe<Vec2F> offset) {
return handPosition(offset.value());
});
return callbacks;
}
}
Reference in New Issue View Git Blame Copy Permalink