osb/source/game/StarWorldClient.cpp
2024-04-04 14:35:36 +11:00

2399 lines
88 KiB
C++

#include "StarWorldClient.hpp"
#include "StarIterator.hpp"
#include "StarLogging.hpp"
#include "StarBiome.hpp"
#include "StarMaterialRenderProfile.hpp"
#include "StarLiquidTypes.hpp"
#include "StarDamageDatabase.hpp"
#include "StarParticleDatabase.hpp"
#include "StarParticleManager.hpp"
#include "StarWorldImpl.hpp"
#include "StarPlayer.hpp"
#include "StarPlayerLog.hpp"
#include "StarAggressiveEntity.hpp"
#include "StarPhysicsEntity.hpp"
#include "StarItemDrop.hpp"
#include "StarItemDatabase.hpp"
#include "StarObjectDatabase.hpp"
#include "StarObject.hpp"
#include "StarEntityFactory.hpp"
#include "StarWorldTemplate.hpp"
#include "StarStoredFunctions.hpp"
#include "StarInspectableEntity.hpp"
#include "StarCurve25519.hpp"
namespace Star {
const std::string SECRET_BROADCAST_PUBLIC_KEY = "SecretBroadcastPublicKey";
const std::string SECRET_BROADCAST_PREFIX = "\0Broadcast\0"s;
const float WorldClient::DropDist = 6.0f;
WorldClient::WorldClient(PlayerPtr mainPlayer) {
auto& root = Root::singleton();
auto assets = root.assets();
m_clientConfig = assets->json("/client.config");
m_currentStep = 0;
m_currentTime = 0;
m_fullBright = false;
m_asyncLighting = false;
m_worldDimTimer = GameTimer(m_clientConfig.getFloat("worldDimTime"));
m_worldDimTimer.setDone();
m_worldDimLevel = 0.0f;
m_parallaxFadeTimer = GameTimer(m_clientConfig.getFloat("parallaxFadeTime"));
m_parallaxFadeTimer.setDone();
m_collisionDebug = false;
m_inWorld = false;
m_luaRoot = make_shared<LuaRoot>();
m_mainPlayer = mainPlayer;
centerClientWindowOnPlayer(Vec2U(100, 100));
m_collisionGenerator.init([this](int x, int y) {
if (!m_predictedTiles.empty()) {
if (auto p = m_predictedTiles.ptr({x, y})) {
if (p->collision)
return *p->collision;
}
}
return m_tileArray->tile({x, y}).collision;
});
m_modifiedTilePredictionTimeout = (int)round(m_clientConfig.getFloat("modifiedTilePredictionTimeout") / GlobalTimestep);
m_latency = 0.0;
m_blockDamageParticle = Particle(m_clientConfig.getObject("blockDamageParticle"));
m_blockDamageParticleVariance = Particle(m_clientConfig.getObject("blockDamageParticleVariance"));
m_blockDamageParticleProbability = m_clientConfig.getFloat("blockDamageParticleProbability");
m_blockDingParticle = Particle(m_clientConfig.getObject("blockDingParticle"));
m_blockDingParticleVariance = Particle(m_clientConfig.getObject("blockDingParticleVariance"));
m_blockDingParticleProbability = m_clientConfig.getFloat("blockDingParticleProbability");
m_damageNotificationBatchDuration = m_clientConfig.getFloat("damageNotificationBatchDuration");
m_ambientSounds.setTrackFadeInTime(assets->json("/interface.config:ambientTrackFadeInTime").toFloat());
m_ambientSounds.setTrackSwitchGrace(assets->json("/interface.config:ambientTrackSwitchGrace").toFloat());
m_musicTrack.setTrackSwitchGrace(assets->json("/interface.config:musicTrackSwitchGrace").toFloat());
m_musicTrack.setTrackFadeInTime(assets->json("/interface.config:musicTrackFadeInTime").toFloat());
m_altMusicTrack.setTrackFadeInTime(assets->json("/interface.config:musicTrackFadeInTime").toFloat());
m_altMusicTrack.setTrackSwitchGrace(assets->json("/interface.config:musicTrackFadeInTime").toFloat());
m_altMusicTrack.setVolume(0, 0, 0);
m_altMusicActive = false;
m_stopLightingThread = false;
clearWorld();
}
WorldClient::~WorldClient() {
if (m_lightingThread) {
m_stopLightingThread = true;
{
MutexLocker locker(m_lightingMutex);
m_lightingCond.broadcast();
}
m_lightingThread.finish();
}
clearWorld();
}
bool WorldClient::inWorld() const {
return m_inWorld;
}
bool WorldClient::inSpace() const {
if (!m_sky)
return false;
return m_sky->inSpace();
}
bool WorldClient::flying() const {
if (!m_sky)
return false;
return m_sky->flying();
}
bool WorldClient::mainPlayerDead() const {
if (inWorld())
return !m_entityMap->get<Player>(m_mainPlayer->entityId());
else
return false;
}
void WorldClient::reviveMainPlayer() {
if (inWorld() && mainPlayerDead()) {
m_mainPlayer->revive(m_playerStart);
m_mainPlayer->init(this, m_entityMap->reserveEntityId(), EntityMode::Master);
m_entityMap->addEntity(m_mainPlayer);
}
}
bool WorldClient::respawnInWorld() const {
return m_respawnInWorld;
}
void WorldClient::removeEntity(EntityId entityId, bool andDie) {
auto entity = m_entityMap->entity(entityId);
if (!entity)
return;
if (andDie) {
ClientRenderCallback renderCallback;
entity->destroy(&renderCallback);
const List<Directives>* directives = nullptr;
if (auto& worldTemplate = m_worldTemplate) {
if (const auto& parameters = worldTemplate->worldParameters())
if (auto& globalDirectives = m_worldTemplate->worldParameters()->globalDirectives)
directives = &globalDirectives.get();
}
if (directives) {
int directiveIndex = unsigned(entity->entityId()) % directives->size();
for (auto& p : renderCallback.particles)
p.directives.append(directives->get(directiveIndex));
}
m_particles->addParticles(std::move(renderCallback.particles));
m_samples.appendAll(std::move(renderCallback.audios));
}
if (auto version = m_masterEntitiesNetVersion.maybeTake(entity->entityId())) {
ByteArray finalNetState = entity->writeNetState(*version).first;
m_outgoingPackets.append(make_shared<EntityDestroyPacket>(entity->entityId(), std::move(finalNetState), andDie));
}
m_entityMap->removeEntity(entityId);
entity->uninit();
}
WorldTemplateConstPtr WorldClient::currentTemplate() const {
return m_worldTemplate;
}
SkyConstPtr WorldClient::currentSky() const {
return m_sky;
}
void WorldClient::timer(float delay, WorldAction worldAction) {
if (!inWorld())
return;
m_timers.append({delay, worldAction});
}
EntityPtr WorldClient::closestEntity(Vec2F const& center, float radius, EntityFilter selector) const {
if (!inWorld())
return {};
return m_entityMap->closestEntity(center, radius, selector);
}
void WorldClient::forAllEntities(EntityCallback callback) const {
m_entityMap->forAllEntities(callback);
}
void WorldClient::forEachEntity(RectF const& boundBox, EntityCallback callback) const {
if (!inWorld())
return;
m_entityMap->forEachEntity(boundBox, callback);
}
void WorldClient::forEachEntityLine(Vec2F const& begin, Vec2F const& end, EntityCallback callback) const {
if (!inWorld())
return;
m_entityMap->forEachEntityLine(begin, end, callback);
}
void WorldClient::forEachEntityAtTile(Vec2I const& pos, EntityCallbackOf<TileEntity> callback) const {
if (!inWorld())
return;
m_entityMap->forEachEntityAtTile(pos, callback);
}
EntityPtr WorldClient::findEntity(RectF const& boundBox, EntityFilter entityFilter) const {
if (!inWorld())
return {};
return m_entityMap->findEntity(boundBox, entityFilter);
}
EntityPtr WorldClient::findEntityLine(Vec2F const& begin, Vec2F const& end, EntityFilter entityFilter) const {
if (!inWorld())
return {};
return m_entityMap->findEntityLine(begin, end, entityFilter);
}
EntityPtr WorldClient::findEntityAtTile(Vec2I const& pos, EntityFilterOf<TileEntity> entityFilter) const {
if (!inWorld())
return {};
return m_entityMap->findEntityAtTile(pos, entityFilter);
}
bool WorldClient::tileIsOccupied(Vec2I const& pos, TileLayer layer, bool includeEphemeral, bool checkCollision) const {
if (!inWorld())
return false;
return WorldImpl::tileIsOccupied(m_tileArray, m_entityMap, pos, layer, includeEphemeral, checkCollision);
}
CollisionKind WorldClient::tileCollisionKind(Vec2I const& pos) const {
if (!inWorld())
return CollisionKind::Null;
return WorldImpl::tileCollisionKind(m_tileArray, m_entityMap, pos);
}
void WorldClient::forEachCollisionBlock(RectI const& region, function<void(CollisionBlock const&)> const& iterator) const {
if (!inWorld())
return;
const_cast<WorldClient*>(this)->freshenCollision(region);
m_tileArray->tileEach(region, [iterator](Vec2I const& pos, ClientTile const& tile) {
if (tile.getCollision() == CollisionKind::Null) {
iterator(CollisionBlock::nullBlock(pos));
} else {
starAssert(!tile.collisionCacheDirty);
for (auto const& block : tile.collisionCache)
iterator(block);
}
});
}
bool WorldClient::isTileConnectable(Vec2I const& pos, TileLayer layer, bool tilesOnly) const {
if (!inWorld())
return false;
return m_tileArray->tile(pos).isConnectable(layer, tilesOnly);
}
bool WorldClient::pointTileCollision(Vec2F const& point, CollisionSet const& collisionSet) const {
if (!inWorld())
return false;
return m_tileArray->tile(Vec2I(point.floor())).isColliding(collisionSet);
}
bool WorldClient::lineTileCollision(Vec2F const& begin, Vec2F const& end, CollisionSet const& collisionSet) const {
if (!inWorld())
return false;
return WorldImpl::lineTileCollision(m_geometry, m_tileArray, begin, end, collisionSet);
}
Maybe<pair<Vec2F, Vec2I>> WorldClient::lineTileCollisionPoint(Vec2F const& begin, Vec2F const& end, CollisionSet const& collisionSet) const {
if (!inWorld())
return {};
return WorldImpl::lineTileCollisionPoint(m_geometry, m_tileArray, begin, end, collisionSet);
}
List<Vec2I> WorldClient::collidingTilesAlongLine(
Vec2F const& begin, Vec2F const& end, CollisionSet const& collisionSet, int maxSize, bool includeEdges) const {
if (!inWorld())
return {};
return WorldImpl::collidingTilesAlongLine(m_geometry, m_tileArray, begin, end, collisionSet, maxSize, includeEdges);
}
bool WorldClient::rectTileCollision(RectI const& region, CollisionSet const& collisionSet) const {
if (!inWorld())
return false;
return WorldImpl::rectTileCollision(m_tileArray, region, collisionSet);
}
LiquidLevel WorldClient::liquidLevel(Vec2I const& pos) const {
if (!inWorld())
return {};
return m_tileArray->tile(pos).liquid;
}
LiquidLevel WorldClient::liquidLevel(RectF const& region) const {
if (!inWorld())
return {};
return WorldImpl::liquidLevel(m_tileArray, region);
}
TileModificationList WorldClient::validTileModifications(TileModificationList const& modificationList, bool allowEntityOverlap) const {
if (!inWorld())
return {};
return WorldImpl::splitTileModifications(m_entityMap, modificationList, allowEntityOverlap, m_tileGetterFunction, [this](Vec2I pos, TileModification) {
return !isTileProtected(pos);
}).first;
}
TileModificationList WorldClient::applyTileModifications(TileModificationList const& modificationList, bool allowEntityOverlap) {
if (!inWorld())
return {};
// thanks to new prediction: do each one by one so that previous modifications affect placeability
TileModificationList success, failures, temp;
TileModificationList const* list = &modificationList;
while (true) {
bool yay = false;
for (size_t i = 0; i != list->size(); ++i) {
auto& pair = list->at(i);
if (!isTileProtected(pair.first)) {
auto result = WorldImpl::validateTileModification(m_entityMap, pair.first, pair.second, allowEntityOverlap, m_tileGetterFunction);
if (result.first) {
informTilePrediction(pair.first, pair.second);
success.append(pair);
yay = true;
continue;
}
}
failures.append(pair);
}
if (yay) {
list = &(temp = std::move(failures));
failures = {};
continue;
}
else break;
}
if (!success.empty())
m_outgoingPackets.append(make_shared<ModifyTileListPacket>(std::move(success), true));
return failures;
}
float WorldClient::gravity(Vec2F const& pos) const {
if (!inWorld())
return 0.0f;
if (m_overrideGravity)
return *m_overrideGravity;
auto dungeonId = m_tileArray->tile(Vec2I::round(pos)).dungeonId;
return m_dungeonIdGravity.maybe(dungeonId).value(currentTemplate()->gravity());
}
float WorldClient::windLevel(Vec2F const& pos) const {
if (!inWorld())
return 0.0f;
return WorldImpl::windLevel(m_tileArray, pos, m_weather.wind());
}
void WorldClient::setClientWindow(RectI window) {
m_clientState.setWindow(window);
}
void WorldClient::centerClientWindowOnPlayer(Vec2U const& windowSize) {
setClientWindow(RectI::withCenter(Vec2I::floor(m_mainPlayer->position()), Vec2I(windowSize)));
}
void WorldClient::centerClientWindowOnPlayer() {
centerClientWindowOnPlayer(Vec2U(clientWindow().size()));
}
RectI WorldClient::clientWindow() const {
return m_clientState.window();
}
WorldClientState& WorldClient::clientState() {
return m_clientState;
}
void WorldClient::render(WorldRenderData& renderData, unsigned bufferTiles) {
if (!m_lightingThread && m_asyncLighting)
m_lightingThread = Thread::invoke("WorldClient::lightingMain", mem_fn(&WorldClient::lightingMain), this);
renderData.clear();
if (!inWorld())
return;
// If we're dimming the world, then that takes priority
m_worldDimTimer.tick();
float dimRatio = m_worldDimTimer.percent();
// Spends 80% of the time at pitch black with 10% ramp up and down
m_worldDimColor = {}; // always reset this to prevent persistent dimming from other sources
if (dimRatio) {
if (dimRatio <= 0.1f)
m_worldDimLevel = dimRatio / 0.1f;
else if (dimRatio >= 0.9f)
m_worldDimLevel = (1 - dimRatio) / (1 - 0.9f);
else
m_worldDimLevel = 1.0f;
}
List<LightSource> renderLightSources;
m_previewTiles.clear();
renderData.geometry = m_geometry;
ClientRenderCallback lightingRenderCallback;
m_entityMap->forAllEntities([&](EntityPtr const& entity) {
if (m_startupHiddenEntities.contains(entity->entityId()))
return;
entity->renderLightSources(&lightingRenderCallback);
});
renderLightSources = std::move(lightingRenderCallback.lightSources);
RectI window = m_clientState.window();
RectI tileRange = window.padded(bufferTiles);
renderData.tileMinPosition = tileRange.min();
if (!m_fullBright) {
{
MutexLocker m_prepLocker(m_lightMapPrepMutex);
m_pendingLights = std::move(renderLightSources);
m_pendingParticleLights = std::move(m_particles->lightSources());
m_pendingLightRange = window.padded(1);
} //Kae: Padded by one to fix light spread issues at the edges of the frame.
if (m_asyncLighting)
m_lightingCond.signal();
else
lightingCalc();
}
float pulseAmount = Root::singleton().assets()->json("/highlights.config:interactivePulseAmount").toFloat();
float pulseRate = Root::singleton().assets()->json("/highlights.config:interactivePulseRate").toFloat();
float pulseLevel = 1 - pulseAmount * 0.5 * (sin(2 * Constants::pi * pulseRate * Time::monotonicMilliseconds() / 1000.0) + 1);
bool inspecting = m_mainPlayer->inspecting();
float inspectionFlickerMultiplier = Random::randf(1 - Root::singleton().assets()->json("/highlights.config:inspectionFlickerAmount").toFloat(), 1);
EntityId playerAimInteractive = NullEntityId;
if (Root::singleton().configuration()->get("interactiveHighlight").toBool()) {
if (auto entity = m_mainPlayer->bestInteractionEntity(false))
playerAimInteractive = entity->entityId();
}
const List<Directives>* directives = nullptr;
if (auto& worldTemplate = m_worldTemplate) {
if (const auto& parameters = worldTemplate->worldParameters())
if (auto& globalDirectives = m_worldTemplate->worldParameters()->globalDirectives)
directives = &globalDirectives.get();
}
m_entityMap->forAllEntities([&](EntityPtr const& entity) {
if (m_startupHiddenEntities.contains(entity->entityId()))
return;
ClientRenderCallback renderCallback;
entity->render(&renderCallback);
EntityDrawables ed;
for (auto& p : renderCallback.drawables) {
if (directives) {
int directiveIndex = unsigned(entity->entityId()) % directives->size();
for (auto& d : p.second) {
if (d.isImage())
d.imagePart().addDirectives(directives->at(directiveIndex), true);
}
}
ed.layers[p.first] = std::move(p.second);
}
if (m_interactiveHighlightMode || (!inspecting && entity->entityId() == playerAimInteractive)) {
if (auto interactive = as<InteractiveEntity>(entity)) {
if (interactive->isInteractive()) {
ed.highlightEffect.type = EntityHighlightEffectType::Interactive;
ed.highlightEffect.level = pulseLevel;
}
}
} else if (inspecting) {
if (auto inspectable = as<InspectableEntity>(entity)) {
ed.highlightEffect = m_mainPlayer->inspectionHighlight(inspectable);
ed.highlightEffect.level *= inspectionFlickerMultiplier;
}
}
renderData.entityDrawables.append(std::move(ed));
if (directives) {
int directiveIndex = unsigned(entity->entityId()) % directives->size();
for (auto& p : renderCallback.particles)
p.directives.append(directives->get(directiveIndex));
}
m_particles->addParticles(std::move(renderCallback.particles));
m_samples.appendAll(std::move(renderCallback.audios));
m_previewTiles.appendAll(std::move(renderCallback.previewTiles));
renderData.overheadBars.appendAll(std::move(renderCallback.overheadBars));
}, [](EntityPtr const& a, EntityPtr const& b) {
return a->entityId() < b->entityId();
});
m_tileArray->tileEachTo(renderData.tiles, tileRange, [&](RenderTile& renderTile, Vec2I const& position, ClientTile const& clientTile) {
renderTile.foreground = clientTile.foreground;
renderTile.foregroundMod = clientTile.foregroundMod;
renderTile.background = clientTile.background;
renderTile.backgroundMod = clientTile.backgroundMod;
renderTile.foregroundHueShift = clientTile.foregroundHueShift;
renderTile.foregroundModHueShift = clientTile.foregroundModHueShift;
renderTile.foregroundColorVariant = clientTile.foregroundColorVariant;
renderTile.foregroundDamageType = clientTile.foregroundDamage.damageType();
renderTile.foregroundDamageLevel = floatToByte(clientTile.foregroundDamage.damageEffectPercentage());
renderTile.backgroundHueShift = clientTile.backgroundHueShift;
renderTile.backgroundModHueShift = clientTile.backgroundModHueShift;
renderTile.backgroundColorVariant = clientTile.backgroundColorVariant;
renderTile.backgroundDamageType = clientTile.backgroundDamage.damageType();
renderTile.backgroundDamageLevel = floatToByte(clientTile.backgroundDamage.damageEffectPercentage());
renderTile.liquidId = clientTile.liquid.liquid;
renderTile.liquidLevel = floatToByte(clientTile.liquid.level);
});
for (auto& pair : m_predictedTiles) {
Vec2I tileArrayPos = m_geometry.diff(pair.first, renderData.tileMinPosition);
if (tileArrayPos[0] >= 0 && tileArrayPos[0] < (int)renderData.tiles.size(0) && tileArrayPos[1] >= 0 && tileArrayPos[1] < (int)renderData.tiles.size(1)) {
RenderTile& renderTile = renderData.tiles(tileArrayPos[0], tileArrayPos[1]);
PredictedTile& p = pair.second;
if (p.liquid) {
auto& liquid = *p.liquid;
if (liquid.liquid == renderTile.liquidId) {
uint8_t added = floatToByte(liquid.level, true);
renderTile.liquidLevel = (renderTile.liquidLevel > 255 - added) ? 255 : renderTile.liquidLevel + added;
}
else {
renderTile.liquidId = liquid.liquid;
renderTile.liquidLevel = floatToByte(liquid.level, true);
}
}
pair.second.apply(renderTile);
}
}
for (auto const& previewTile : m_previewTiles) {
Vec2I tileArrayPos = m_geometry.diff(previewTile.position, renderData.tileMinPosition);
if (tileArrayPos[0] >= 0 && tileArrayPos[0] < (int)renderData.tiles.size(0) && tileArrayPos[1] >= 0 && tileArrayPos[1] < (int)renderData.tiles.size(1)) {
RenderTile& renderTile = renderData.tiles(tileArrayPos[0], tileArrayPos[1]);
auto material = previewTile.matId;
auto hueShift = previewTile.hueShift;
auto colorVariant = previewTile.colorVariant;
if (previewTile.updateMatId) {
if (previewTile.foreground) {
renderTile.foreground = material;
renderTile.foregroundHueShift = hueShift;
renderTile.foregroundColorVariant = colorVariant;
} else {
renderTile.background = material;
renderTile.backgroundHueShift = hueShift;
renderTile.backgroundColorVariant = colorVariant;
}
}
if (previewTile.liqId != EmptyLiquidId) {
renderTile.liquidId = previewTile.liqId;
renderTile.liquidLevel = 255;
}
}
}
renderData.particles = &m_particles->particles();
LogMap::set("client_render_particle_count", renderData.particles->size());
renderData.skyRenderData = m_sky->renderData();
auto environmentBiome = mainEnvironmentBiome();
m_parallaxFadeTimer.tick();
if (m_parallaxFadeTimer.ready() && m_nextParallax) {
m_currentParallax = m_nextParallax;
m_nextParallax.reset();
}
if (environmentBiome)
setParallax(environmentBiome->parallax);
if (m_currentParallax) {
if (m_parallaxFadeTimer.ready()) {
renderData.parallaxLayers.appendAll(m_currentParallax->layers());
} else {
for (auto layer : m_currentParallax->layers()) {
layer.alpha = min(1.0f, m_parallaxFadeTimer.percent() * 2);
renderData.parallaxLayers.append(layer);
}
}
}
if (m_nextParallax) {
for (auto layer : m_nextParallax->layers()) {
layer.alpha = min(1.0f, (1.0f - m_parallaxFadeTimer.percent()) * 2);
renderData.parallaxLayers.append(layer);
}
}
auto functionDatabase = Root::singleton().functionDatabase();
for (auto& layer : renderData.parallaxLayers) {
if (!layer.timeOfDayCorrelation.empty())
layer.alpha *= clamp((float)functionDatabase->function(layer.timeOfDayCorrelation)->evaluate(m_sky->timeOfDay() / m_sky->dayLength()), 0.0f, 1.0f);
}
stableSort(renderData.parallaxLayers, [](ParallaxLayer const& a, ParallaxLayer const& b) {
return tie(a.zLevel, a.verticalOrigin) > tie(b.zLevel, b.verticalOrigin);
});
auto overlayToDrawable = [](WorldStructure::Overlay const& overlay) -> Drawable {
Drawable drawable = Drawable::makeImage(overlay.image, 1.0f / TilePixels, false, overlay.min);
drawable.fullbright = overlay.fullbright;
return drawable;
};
renderData.backgroundOverlays = m_centralStructure.backgroundOverlays().transformed(overlayToDrawable);
renderData.foregroundOverlays = m_centralStructure.foregroundOverlays().transformed(overlayToDrawable);
renderData.isFullbright = m_fullBright;
renderData.dimLevel = m_worldDimLevel;
renderData.dimColor = m_worldDimColor;
}
List<AudioInstancePtr> WorldClient::pullPendingAudio() {
return take(m_samples);
}
List<AudioInstancePtr> WorldClient::pullPendingMusic() {
return take(m_music);
}
void WorldClient::dimWorld() {
m_worldDimTimer.reset();
}
bool WorldClient::interactiveHighlightMode() const {
return m_interactiveHighlightMode;
}
void WorldClient::setInteractiveHighlightMode(bool enabled) {
m_interactiveHighlightMode = enabled;
}
void WorldClient::setParallax(ParallaxPtr newParallax) {
if (newParallax) {
if (!m_currentParallax) {
m_currentParallax = newParallax;
} else if (m_parallaxFadeTimer.ready() && newParallax != m_currentParallax) {
m_nextParallax = newParallax;
m_parallaxFadeTimer.reset();
} else if (m_nextParallax && newParallax == m_currentParallax) {
m_currentParallax = m_nextParallax;
m_nextParallax = newParallax;
m_parallaxFadeTimer.invert();
}
}
}
void WorldClient::overrideGravity(float gravity) {
m_overrideGravity = gravity;
}
void WorldClient::resetGravity() {
m_overrideGravity = {};
}
bool WorldClient::fullBright() const {
return m_fullBright;
}
void WorldClient::setFullBright(bool fullBright) {
m_fullBright = fullBright;
}
bool WorldClient::asyncLighting() const {
return m_asyncLighting;
}
void WorldClient::setAsyncLighting(bool asyncLighting) {
m_asyncLighting = asyncLighting;
}
bool WorldClient::collisionDebug() const {
return m_collisionDebug;
}
void WorldClient::setCollisionDebug(bool collisionDebug) {
m_collisionDebug = collisionDebug;
}
void WorldClient::handleIncomingPackets(List<PacketPtr> const& packets) {
auto& root = Root::singleton();
auto materialDatabase = root.materialDatabase();
auto itemDatabase = root.itemDatabase();
auto entityFactory = root.entityFactory();
for (auto const& packet : packets) {
if (!inWorld() && !is<WorldStartPacket>(packet))
Logger::error("WorldClient received packet type {} while not in world", PacketTypeNames.getRight(packet->type()));
if (auto worldStartPacket = as<WorldStartPacket>(packet)) {
initWorld(*worldStartPacket);
} else if (auto worldStopPacket = as<WorldStopPacket>(packet)) {
Logger::info("Client received world stop packet, leaving: {}", worldStopPacket->reason);
clearWorld();
} else if (auto entityCreate = as<EntityCreatePacket>(packet)) {
if (m_entityMap->entity(entityCreate->entityId)) {
Logger::error("WorldClient received entity create packet with duplicate entity id {}, deleting old entity.", entityCreate->entityId);
removeEntity(entityCreate->entityId, false);
}
auto entity = entityFactory->netLoadEntity(entityCreate->entityType, entityCreate->storeData);
entity->readNetState(entityCreate->firstNetState);
entity->init(this, entityCreate->entityId, EntityMode::Slave);
m_entityMap->addEntity(entity);
if (m_interpolationTracker.interpolationEnabled()) {
entity->enableInterpolation(m_interpolationTracker.extrapolationHint());
// Delay appearance of new slaved entities to match with interplation
// state.
m_startupHiddenEntities.add(entityCreate->entityId);
timer(m_interpolationTracker.interpolationLeadTime(), [this, entityId = entityCreate->entityId](World*) {
m_startupHiddenEntities.remove(entityId);
});
}
} else if (auto entityUpdateSet = as<EntityUpdateSetPacket>(packet)) {
float interpolationLeadTime = m_interpolationTracker.interpolationLeadTime();
m_entityMap->forAllEntities([&](EntityPtr const& entity) {
EntityId entityId = entity->entityId();
if (connectionForEntity(entityId) == entityUpdateSet->forConnection) {
starAssert(entity->isSlave());
entity->readNetState(entityUpdateSet->deltas.value(entityId), interpolationLeadTime);
}
});
} else if (auto entityDestroy = as<EntityDestroyPacket>(packet)) {
if (auto entity = m_entityMap->entity(entityDestroy->entityId)) {
entity->readNetState(entityDestroy->finalNetState, m_interpolationTracker.interpolationLeadTime());
// Before destroying the entity, we should make sure that the entity is
// using the absolute latest data, so we disable interpolation.
if (m_interpolationTracker.interpolationEnabled() && entityDestroy->death) {
// Delay death packets by the interpolation step to give time for
// interpolation to catch up.
timer(m_interpolationTracker.interpolationLeadTime(), [this, entity, entityDestroy](World*) {
entity->disableInterpolation();
removeEntity(entityDestroy->entityId, entityDestroy->death);
});
} else {
entity->disableInterpolation();
removeEntity(entityDestroy->entityId, entityDestroy->death);
}
}
} else if (auto structurePacket = as<CentralStructureUpdatePacket>(packet)) {
m_centralStructure = WorldStructure(structurePacket->structureData);
} else if (auto tileArrayUpdate = as<TileArrayUpdatePacket>(packet)) {
RectI tileRegion = RectI::withSize(tileArrayUpdate->min, Vec2I(tileArrayUpdate->array.size()));
// NOTE: We're creating client side sectors on tileArrayUpdate here, and
// at no other time, and this is sort of a big assumption that
// tileArrayUpdate happens for all valid client side sectors first before
// any other tile updates.
for (auto const& sector : m_tileArray->validSectorsFor(tileRegion))
m_tileArray->loadDefaultSector(sector);
for (int x = tileRegion.xMin(); x < tileRegion.xMax(); ++x) {
for (int y = tileRegion.yMin(); y < tileRegion.yMax(); ++y)
readNetTile({x, y}, tileArrayUpdate->array(x - tileRegion.xMin(), y - tileRegion.yMin()), false);
}
dirtyCollision(tileRegion);
} else if (auto tileUpdate = as<TileUpdatePacket>(packet)) {
readNetTile(tileUpdate->position, tileUpdate->tile);
} else if (auto tileDamageUpdate = as<TileDamageUpdatePacket>(packet)) {
if (ClientTile* tile = m_tileArray->modifyTile(tileDamageUpdate->position)) {
if (tileDamageUpdate->layer == TileLayer::Foreground)
tile->foregroundDamage = tileDamageUpdate->tileDamage;
else
tile->backgroundDamage = tileDamageUpdate->tileDamage;
m_damagedBlocks.add(tileDamageUpdate->position);
}
} else if (auto tileModificationFailure = as<TileModificationFailurePacket>(packet)) {
// TODO: Right now we assume that every tile modification was caused by a
// player, but this may not be true in the future. In the future, there
// may be context hints with tile modifications to figure out what to do
// with failures.
for (auto& modification : tileModificationFailure->modifications) {
auto findPrediction = m_predictedTiles.find(modification.first);
if (findPrediction != m_predictedTiles.end()) {
auto& p = findPrediction->second;
if (auto placeMaterial = modification.second.ptr<PlaceMaterial>()) {
if (placeMaterial->layer == TileLayer::Foreground) {
p.foreground.reset();
p.foregroundHueShift.reset();
if (p.collision) {
p.collision.reset();
dirtyCollision(RectI::withSize(modification.first, { 1, 1 }));
}
}
else {
p.background.reset();
p.backgroundHueShift.reset();
}
} else if (auto placeMod = modification.second.ptr<PlaceMod>()) {
if (placeMod->layer == TileLayer::Foreground) {
p.foregroundMod.reset();
p.foregroundModHueShift.reset();
}
else {
p.backgroundMod.reset();
p.backgroundModHueShift.reset();
}
} else if (auto placeColor = modification.second.ptr<PlaceMaterialColor>()) {
if (placeColor->layer == TileLayer::Foreground)
p.foregroundColorVariant.reset();
else
p.backgroundColorVariant.reset();
} else if (auto placeLiquid = modification.second.ptr<PlaceLiquid>()) {
p.liquid.reset();
}
if (!p)
m_predictedTiles.erase(findPrediction);
}
if (auto placeMaterial = modification.second.ptr<PlaceMaterial>()) {
auto stack = materialDatabase->materialItemDrop(placeMaterial->material);
tryGiveMainPlayerItem(itemDatabase->item(stack), true);
} else if (auto placeMod = modification.second.ptr<PlaceMod>()) {
auto stack = materialDatabase->modItemDrop(placeMod->mod);
tryGiveMainPlayerItem(itemDatabase->item(stack), true);
}
}
} else if (auto liquidUpdate = as<TileLiquidUpdatePacket>(packet)) {
m_predictedTiles.remove(liquidUpdate->position);
if (ClientTile* tile = m_tileArray->modifyTile(liquidUpdate->position))
tile->liquid = liquidUpdate->liquidUpdate.liquidLevel();
} else if (auto giveItem = as<GiveItemPacket>(packet)) {
tryGiveMainPlayerItem(itemDatabase->item(giveItem->item));
} else if (auto stepUpdate = as<StepUpdatePacket>(packet)) {
m_interpolationTracker.receiveTimeUpdate(stepUpdate->remoteTime);
} else if (auto environmentUpdatePacket = as<EnvironmentUpdatePacket>(packet)) {
m_sky->readUpdate(environmentUpdatePacket->skyDelta);
m_weather.readUpdate(environmentUpdatePacket->weatherDelta);
} else if (auto hit = as<HitRequestPacket>(packet)) {
m_damageManager->pushRemoteHitRequest(hit->remoteHitRequest);
} else if (auto damage = as<DamageRequestPacket>(packet)) {
m_damageManager->pushRemoteDamageRequest(damage->remoteDamageRequest);
} else if (auto damage = as<DamageNotificationPacket>(packet)) {
std::string_view view = damage->remoteDamageNotification.damageNotification.targetMaterialKind.utf8();
static const size_t FULL_SIZE = SECRET_BROADCAST_PREFIX.size() + Curve25519::SignatureSize;
static const std::string LEGACY_VOICE_PREFIX = "data\0voice\0"s;
if (view.size() >= FULL_SIZE && view.rfind(SECRET_BROADCAST_PREFIX, 0) != NPos) {
// this is actually a secret broadcast!!
if (auto player = m_entityMap->get<Player>(damage->remoteDamageNotification.sourceEntityId)) {
if (auto publicKey = player->getSecretPropertyView(SECRET_BROADCAST_PUBLIC_KEY)) {
if (publicKey->utf8Size() == Curve25519::PublicKeySize) {
auto signature = view.substr(SECRET_BROADCAST_PREFIX.size(), Curve25519::SignatureSize);
auto rawBroadcast = view.substr(FULL_SIZE);
if (Curve25519::verify(
(uint8_t const*)signature.data(),
(uint8_t const*)publicKey->utf8Ptr(),
(void*)rawBroadcast.data(),
rawBroadcast.size()
)) {
handleSecretBroadcast(player, rawBroadcast);
}
}
}
}
}
else if (view.size() > 75 && view.rfind(LEGACY_VOICE_PREFIX, 0) != NPos) {
// this is a StarExtensions voice packet
// (remove this and stop transmitting like this once most SE features are ported over)
if (auto player = m_entityMap->get<Player>(damage->remoteDamageNotification.sourceEntityId)) {
if (auto publicKey = player->effectsAnimator()->globalTagPtr("\0SE_VOICE_SIGNING_KEY"s)) {
auto raw = view.substr(75);
if (m_broadcastCallback && Curve25519::verify(
(uint8_t const*)view.data() + LEGACY_VOICE_PREFIX.size(),
(uint8_t const*)publicKey->utf8Ptr(),
(void*)raw.data(),
raw.size()
)) {
auto broadcastData = "Voice\0"s;
broadcastData.append(raw.data(), raw.size());
m_broadcastCallback(player, broadcastData);
}
}
}
}
else {
m_damageManager->pushRemoteDamageNotification(damage->remoteDamageNotification);
}
} else if (auto entityMessagePacket = as<EntityMessagePacket>(packet)) {
EntityPtr entity;
if (entityMessagePacket->entityId.is<EntityId>())
entity = m_entityMap->entity(entityMessagePacket->entityId.get<EntityId>());
else
entity = m_entityMap->uniqueEntity(entityMessagePacket->entityId.get<String>());
if (!entity) {
m_outgoingPackets.append(make_shared<EntityMessageResponsePacket>(makeLeft("Unknown entity"), entityMessagePacket->uuid));
} else if (!entity->isMaster()) {
Logger::error("Server has sent a scripted entity response for a slave entity");
m_outgoingPackets.append(make_shared<EntityMessageResponsePacket>(makeLeft("Entity delivery error"), entityMessagePacket->uuid));
} else {
ConnectionId fromConnection = entityMessagePacket->fromConnection;
if (fromConnection == *m_clientId) // Kae: The server should not be able to forge entity messages that appear as if they're from us
fromConnection = ServerConnectionId;
auto response = entity->receiveMessage(entityMessagePacket->fromConnection, entityMessagePacket->message, entityMessagePacket->args);
if (response)
m_outgoingPackets.append(make_shared<EntityMessageResponsePacket>(makeRight(response.take()), entityMessagePacket->uuid));
else
m_outgoingPackets.append(make_shared<EntityMessageResponsePacket>(makeLeft("Message not handled by entity"), entityMessagePacket->uuid));
}
} else if (auto entityMessageResponsePacket = as<EntityMessageResponsePacket>(packet)) {
if (!m_entityMessageResponses.contains(entityMessageResponsePacket->uuid))
throw WorldClientException("EntityMessageResponse received for unknown context!");
auto response = m_entityMessageResponses.take(entityMessageResponsePacket->uuid);
if (entityMessageResponsePacket->response.isRight())
response.fulfill(entityMessageResponsePacket->response.right());
else
response.fail(entityMessageResponsePacket->response.left());
} else if (auto updateWorldProperties = as<UpdateWorldPropertiesPacket>(packet)) {
// Kae: Properties set to null (nil from Lua) should be erased instead of lingering around
for (auto& pair : updateWorldProperties->updatedProperties) {
if (pair.second.isNull())
m_worldProperties.erase(pair.first);
else
m_worldProperties[pair.first] = pair.second;
}
} else if (auto updateTileProtection = as<UpdateTileProtectionPacket>(packet)) {
setTileProtection(updateTileProtection->dungeonId, updateTileProtection->isProtected);
} else if (auto setDungeonGravity = as<SetDungeonGravityPacket>(packet)) {
if (setDungeonGravity->gravity)
m_dungeonIdGravity[setDungeonGravity->dungeonId] = *setDungeonGravity->gravity;
else
m_dungeonIdGravity.remove(setDungeonGravity->dungeonId);
} else if (auto setDungeonBreathable = as<SetDungeonBreathablePacket>(packet)) {
if (setDungeonBreathable->breathable.isValid())
m_dungeonIdBreathable[setDungeonBreathable->dungeonId] = *setDungeonBreathable->breathable;
else
m_dungeonIdBreathable.remove(setDungeonBreathable->dungeonId);
} else if (auto entityInteract = as<EntityInteractPacket>(packet)) {
auto interactResult = interact(entityInteract->interactRequest).result();
m_outgoingPackets.append(make_shared<EntityInteractResultPacket>(interactResult.take(), entityInteract->requestId, entityInteract->interactRequest.sourceId));
} else if (auto interactResult = as<EntityInteractResultPacket>(packet)) {
auto response = m_entityInteractionResponses.take(interactResult->requestId);
if (interactResult->action)
response.fulfill(interactResult->action);
else
response.fail("no interaction result");
} else if (auto setPlayerStart = as<SetPlayerStartPacket>(packet)) {
m_playerStart = setPlayerStart->playerStart;
m_respawnInWorld = setPlayerStart->respawnInWorld;
} else if (auto findUniqueEntityResponse = as<FindUniqueEntityResponsePacket>(packet)) {
for (auto& promise : take(m_findUniqueEntityResponses[findUniqueEntityResponse->uniqueEntityId])) {
if (findUniqueEntityResponse->entityPosition)
promise.fulfill(*findUniqueEntityResponse->entityPosition);
else
promise.fail("Unknown entity");
}
} else if (auto worldLayoutUpdate = as<WorldLayoutUpdatePacket>(packet)) {
m_worldTemplate->setWorldLayout(make_shared<WorldLayout>(worldLayoutUpdate->layoutData));
} else if (auto worldParametersUpdate = as<WorldParametersUpdatePacket>(packet)) {
m_worldTemplate->setWorldParameters(netLoadVisitableWorldParameters(worldParametersUpdate->parametersData));
} else if (auto pongPacket = as<PongPacket>(packet)) {
if (pongPacket->time)
m_latency = Time::monotonicMilliseconds() - pongPacket->time;
else if (m_pingTime)
m_latency = Time::monotonicMilliseconds() - m_pingTime.take();
} else {
Logger::error("Improper packet type {} received by client", (int)packet->type());
}
}
}
List<PacketPtr> WorldClient::getOutgoingPackets() {
return std::move(m_outgoingPackets);
}
void WorldClient::setLuaCallbacks(String const& groupName, LuaCallbacks const& callbacks) {
m_luaRoot->addCallbacks(groupName, callbacks);
}
void WorldClient::update(float dt) {
if (!inWorld())
return;
auto assets = Root::singleton().assets();
float expireTime = min(float(m_latency + 800), 2000.f);
auto now = Time::monotonicMilliseconds();
eraseWhere(m_predictedTiles, [&](auto& pair) {
float expiry = (float)(now - pair.second.time) / expireTime;
auto center = Vec2F(pair.first) + Vec2F::filled(0.5f);
auto size = Vec2F::filled(0.875f - expiry * 0.875f);
auto poly = PolyF(RectF::withCenter(center, size));
SpatialLogger::logPoly("world", poly, Color::Cyan.mix(Color::Red, expiry).toRgba());
if (expiry >= 1.0f) {
dirtyCollision(RectI::withSize(pair.first, { 1, 1 }));
return true;
} else {
return false;
}
});
// Secret broadcasts are transmitted through DamageNotifications for vanilla server compatibility.
// Because DamageNotification packets are spoofable, we have to sign the data so other clients can validate that it is legitimate.
auto& publicKey = Curve25519::publicKey();
String publicKeyString((const char*)publicKey.data(), publicKey.size());
m_mainPlayer->setSecretProperty(SECRET_BROADCAST_PUBLIC_KEY, publicKeyString);
// Temporary: Backwards compatibility with StarExtensions
m_mainPlayer->effectsAnimator()->setGlobalTag("\0SE_VOICE_SIGNING_KEY"s, publicKeyString);
++m_currentStep;
m_currentTime += dt;
m_interpolationTracker.update(m_currentTime);
List<WorldAction> triggeredActions;
eraseWhere(m_timers, [&triggeredActions, dt](pair<float, WorldAction>& timer) {
if ((timer.first -= dt) <= 0) {
triggeredActions.append(timer.second);
return true;
}
return false;
});
for (auto const& action : triggeredActions)
action(this);
List<EntityId> toRemove;
List<EntityId> clientPresenceEntities;
m_entityMap->updateAllEntities([&](EntityPtr const& entity) {
entity->update(dt, m_currentStep);
if (entity->shouldDestroy() && entity->entityMode() == EntityMode::Master)
toRemove.append(entity->entityId());
if (entity->isMaster() && entity->clientEntityMode() == ClientEntityMode::ClientPresenceMaster)
clientPresenceEntities.append(entity->entityId());
}, [](EntityPtr const& a, EntityPtr const& b) {
return a->entityType() < b->entityType();
});
m_clientState.setPlayer(m_mainPlayer->entityId());
m_clientState.setClientPresenceEntities(std::move(clientPresenceEntities));
m_damageManager->update(dt);
handleDamageNotifications();
m_sky->setAltitude(m_clientState.windowCenter()[1]);
m_sky->update(dt);
RectI particleRegion = m_clientState.window().padded(m_clientConfig.getInt("particleRegionPadding"));
m_weather.setVisibleRegion(particleRegion);
m_weather.update(dt);
if (!m_mainPlayer->isDead()) {
// Clear m_requestedDrops every so often in case of entity id reuse or
// desyncs etc
if (m_currentStep % m_clientConfig.getInt("itemRequestReset") == 0)
m_requestedDrops.clear();
Vec2F playerPos = m_mainPlayer->position();
auto dropList = m_entityMap->query<ItemDrop>(RectF(playerPos - Vec2F::filled(DropDist / 2), playerPos + Vec2F::filled(DropDist / 2)));
for (auto itemDrop : dropList) {
auto distSquared = m_geometry.diff(itemDrop->position(), playerPos).magnitudeSquared();
// If the drop is within DropDist and not owned, request it.
if (itemDrop->canTake() && !m_requestedDrops.contains(itemDrop->entityId()) && distSquared < square(DropDist)) {
m_requestedDrops.add(itemDrop->entityId());
if (m_mainPlayer->itemsCanHold(itemDrop->item()) != 0) {
m_startupHiddenEntities.erase(itemDrop->entityId());
itemDrop->takeBy(m_mainPlayer->entityId(), (float)m_latency / 1000);
m_outgoingPackets.append(make_shared<RequestDropPacket>(itemDrop->entityId()));
}
}
}
} else {
m_requestedDrops.clear();
}
sparkDamagedBlocks();
m_particles->addParticles(m_weather.pullNewParticles());
m_particles->update(dt, RectF(particleRegion), m_weather.wind());
if (auto audioSample = m_ambientSounds.updateAmbient(currentAmbientNoises(), m_sky->isDayTime()))
m_samples.append(audioSample);
if (auto audioSample = m_ambientSounds.updateWeather(currentWeatherNoises()))
m_samples.append(audioSample);
if (inSpace()) {
m_samples.appendAll(m_sky->pullSounds());
if (m_spaceSound && m_spaceSound->finished()) {
m_spaceSound = {};
m_activeSpaceSound = "";
}
auto skyAmbientNoise = m_sky->ambientNoise();
if (skyAmbientNoise != m_activeSpaceSound) {
if (m_spaceSound) {
m_spaceSound->stop(skyAmbientNoise == "" ? 3.0 : 0.0);
} else {
m_activeSpaceSound = skyAmbientNoise;
if (!m_activeSpaceSound.empty()) {
m_spaceSound = make_shared<AudioInstance>(*assets->audio(m_activeSpaceSound));
m_samples.append(m_spaceSound);
}
}
}
}
if (auto newAltMusic = m_mainPlayer->pullPendingAltMusic()) {
if (newAltMusic->first)
playAltMusic(newAltMusic->first.get(), newAltMusic->second);
else
stopAltMusic(newAltMusic->second);
}
if (auto audioSample = m_altMusicTrack.updateAmbient(currentAltMusicTrack(), true))
m_music.append(audioSample);
if (auto audioSample = m_musicTrack.updateAmbient(currentMusicTrack(), m_sky->isDayTime()))
m_music.append(audioSample);
for (EntityId entityId : toRemove)
removeEntity(entityId, true);
queueUpdatePackets(m_entityUpdateTimer.wrapTick(dt));
if ((!m_clientState.legacy() && m_currentStep % 3 == 0) || m_pingTime.isNothing()) {
m_pingTime = Time::monotonicMilliseconds();
m_outgoingPackets.append(make_shared<PingPacket>(*m_pingTime));
}
LogMap::set("client_ping", m_latency);
// Remove active sectors that are outside of the current monitoring region
Set<ClientTileSectorArray::Sector> neededSectors;
auto monitoredRegions = m_clientState.monitoringRegions([this](EntityId entityId) -> Maybe<RectI> {
if (auto entity = this->entity(entityId))
return RectI::integral(entity->metaBoundBox().translated(entity->position()));
return {};
});
for (auto monitoredRegion : monitoredRegions)
neededSectors.addAll(m_tileArray->validSectorsFor(monitoredRegion.padded(WorldSectorSize)));
auto loadedSectors = m_tileArray->loadedSectors();
for (auto sector : loadedSectors) {
if (!neededSectors.contains(sector))
m_tileArray->unloadSector(sector);
}
if (m_collisionDebug)
renderCollisionDebug();
LogMap::set("client_entities", m_entityMap->size());
LogMap::set("client_sectors", toString(loadedSectors.size()));
LogMap::set("client_lua_mem", m_luaRoot->luaMemoryUsage());
}
ConnectionId WorldClient::connection() const {
return *m_clientId;
}
WorldGeometry WorldClient::geometry() const {
return m_geometry;
}
uint64_t WorldClient::currentStep() const {
return m_currentStep;
}
MaterialId WorldClient::material(Vec2I const& pos, TileLayer layer) const {
if (!inWorld())
return NullMaterialId;
return m_tileArray->tile(pos).material(layer);
}
MaterialHue WorldClient::materialHueShift(Vec2I const& position, TileLayer layer) const {
if (!inWorld())
return MaterialHue();
auto const& tile = m_tileArray->tile(position);
return layer == TileLayer::Foreground ? tile.foregroundHueShift : tile.backgroundHueShift;
}
ModId WorldClient::mod(Vec2I const& pos, TileLayer layer) const {
if (!inWorld())
return NoModId;
return m_tileArray->tile(pos).mod(layer);
}
MaterialHue WorldClient::modHueShift(Vec2I const& position, TileLayer layer) const {
if (!inWorld())
return MaterialHue();
auto const& tile = m_tileArray->tile(position);
return layer == TileLayer::Foreground ? tile.foregroundModHueShift : tile.backgroundModHueShift;
}
MaterialColorVariant WorldClient::colorVariant(Vec2I const& position, TileLayer layer) const {
if (!inWorld())
return MaterialColorVariant();
auto const& tile = m_tileArray->tile(position);
return layer == TileLayer::Foreground ? tile.foregroundColorVariant : tile.backgroundColorVariant;
}
EntityPtr WorldClient::entity(EntityId entityId) const {
if (!inWorld())
return {};
return m_entityMap->entity(entityId);
}
void WorldClient::addEntity(EntityPtr const& entity, EntityId entityId) {
if (!entity)
return;
if (!inWorld())
return;
if (entity->clientEntityMode() != ClientEntityMode::ClientSlaveOnly) {
entity->init(this, m_entityMap->reserveEntityId(entityId), EntityMode::Master);
m_entityMap->addEntity(entity);
notifyEntityCreate(entity);
} else {
auto entityFactory = Root::singleton().entityFactory();
m_outgoingPackets.append(make_shared<SpawnEntityPacket>(entity->entityType(), entityFactory->netStoreEntity(entity), entity->writeNetState().first));
}
}
TileDamageResult WorldClient::damageTiles(List<Vec2I> const& pos, TileLayer layer, Vec2F const& sourcePosition, TileDamage const& tileDamage, Maybe<EntityId> sourceEntity) {
if (!inWorld())
return TileDamageResult::None;
// Filter out any tiles that are not currently occupied or are protected
auto occupied = pos.filtered([this, layer](Vec2I pos) { return tileIsOccupied(pos, layer, true); });
auto toDamage = occupied.filtered([this](Vec2I pos) { return !isTileProtected(pos); });
auto toDing = occupied.filtered([this](Vec2I pos) { return isTileProtected(pos); });
if (toDamage.size() + toDing.size() == 0)
return TileDamageResult::None;
auto res = TileDamageResult::None;
if (toDing.size()) {
auto dingDamage = tileDamage;
dingDamage.type = TileDamageType::Protected;
m_outgoingPackets.append(make_shared<DamageTileGroupPacket>(std::move(toDing), layer, sourcePosition, dingDamage, Maybe<EntityId>()));
res = TileDamageResult::Protected;
}
if (toDamage.size()) {
m_outgoingPackets.append(make_shared<DamageTileGroupPacket>(std::move(toDamage), layer, sourcePosition, tileDamage, sourceEntity));
res = TileDamageResult::Normal;
}
return res;
}
DungeonId WorldClient::dungeonId(Vec2I const& pos) const {
if (!inWorld())
return NoDungeonId;
return m_tileArray->tile(pos).dungeonId;
}
void WorldClient::collectLiquid(List<Vec2I> const& tilePositions, LiquidId liquidId) {
if (!inWorld())
return;
float bucketSize = Root::singleton().assets()->json("/items/defaultParameters.config:liquidItems.bucketSize").toFloat();
float nextUnit = bucketSize;
List<Vec2I> maybeDrainTiles;
for (auto& pos : tilePositions) {
if (isTileProtected(pos))
continue;
auto& p = m_predictedTiles[pos];
auto const& tile = m_tileArray->tile(pos);
if ((p.liquid ? p.liquid->liquid : tile.liquid.liquid) == liquidId) {
if (!p.liquid)
p.liquid.emplace(tile.liquid.liquid, tile.liquid.level);
auto& liquid = *p.liquid;
if (liquid.level >= nextUnit) {
liquid.take(nextUnit);
nextUnit = bucketSize;
for (size_t i = 0; i < maybeDrainTiles.size(); ++i)
m_predictedTiles[pos].liquid.emplace(EmptyLiquidId, 0.0f);
maybeDrainTiles.clear();
}
if (liquid.level > 0) {
nextUnit -= liquid.level;
maybeDrainTiles.append(pos);
}
}
}
m_outgoingPackets.append(make_shared<CollectLiquidPacket>(tilePositions, liquidId));
}
bool WorldClient::waitForLighting(WorldRenderData* renderData) {
MutexLocker prepLocker(m_lightMapPrepMutex);
MutexLocker lightMapLocker(m_lightMapMutex);
if (renderData && !m_lightMap.empty()) {
for (auto& previewTile : m_previewTiles) {
if (previewTile.updateLight) {
Vec2I lightArrayPos = m_geometry.diff(previewTile.position, m_lightMinPosition);
if (lightArrayPos[0] >= 0 && lightArrayPos[0] < (int)m_lightMap.width()
&& lightArrayPos[1] >= 0 && lightArrayPos[1] < (int)m_lightMap.height())
m_lightMap.set(lightArrayPos[0], lightArrayPos[1], Color::v3bToFloat(previewTile.light));
}
}
renderData->lightMap = std::move(m_lightMap);
renderData->lightMinPosition = m_lightMinPosition;
return true;
}
return false;
}
WorldClient::BroadcastCallback& WorldClient::broadcastCallback() {
return m_broadcastCallback;
}
bool WorldClient::isTileProtected(Vec2I const& pos) const {
if (!inWorld())
return true;
auto tile = m_tileArray->tile(pos);
return m_protectedDungeonIds.contains(tile.dungeonId);
}
void WorldClient::setTileProtection(DungeonId dungeonId, bool isProtected) {
if (isProtected) {
m_protectedDungeonIds.add(dungeonId);
} else {
m_protectedDungeonIds.remove(dungeonId);
}
}
void WorldClient::queueUpdatePackets(bool sendEntityUpdates) {
auto& root = Root::singleton();
auto assets = root.assets();
auto entityFactory = root.entityFactory();
m_outgoingPackets.append(make_shared<StepUpdatePacket>(m_currentTime));
if (m_currentStep % m_clientConfig.getInt("worldClientStateUpdateDelta") == 0)
m_outgoingPackets.append(make_shared<WorldClientStateUpdatePacket>(m_clientState.writeDelta()));
m_entityMap->forAllEntities([&](EntityPtr const& entity) { notifyEntityCreate(entity); });
if (sendEntityUpdates) {
auto entityUpdateSet = make_shared<EntityUpdateSetPacket>();
entityUpdateSet->forConnection = *m_clientId;
m_entityMap->forAllEntities([&](EntityPtr const& entity) {
if (auto version = m_masterEntitiesNetVersion.ptr(entity->entityId())) {
auto updateAndVersion = entity->writeNetState(*version);
if (!updateAndVersion.first.empty())
entityUpdateSet->deltas[entity->entityId()] = std::move(updateAndVersion.first);
*version = updateAndVersion.second;
}
});
m_outgoingPackets.append(std::move(entityUpdateSet));
}
for (auto& remoteHitRequest : m_damageManager->pullRemoteHitRequests())
m_outgoingPackets.append(make_shared<HitRequestPacket>(std::move(remoteHitRequest)));
for (auto& remoteDamageRequest : m_damageManager->pullRemoteDamageRequests())
m_outgoingPackets.append(make_shared<DamageRequestPacket>(std::move(remoteDamageRequest)));
for (auto& remoteDamageNotification : m_damageManager->pullRemoteDamageNotifications())
m_outgoingPackets.append(make_shared<DamageNotificationPacket>(std::move(remoteDamageNotification)));
}
void WorldClient::handleDamageNotifications() {
if (!inWorld())
return;
auto renderParticle = [&](Vec2F position, float amount, String const& damageNumberParticleKind) {
int displayValue = (int)ceil(amount - 0.1f);
if (displayValue <= 0)
return;
Particle particle = Root::singleton().particleDatabase()->particle(damageNumberParticleKind);
particle.position += position;
particle.string = particle.string.replace("$dmg$", toString(displayValue));
m_particles->add(particle);
};
eraseWhere(m_damageNumbers, [&](std::pair<DamageNumberKey, DamageNumber> const& entry) -> bool {
if (Time::monotonicTime() - entry.second.timestamp > m_damageNotificationBatchDuration) {
renderParticle(entry.second.position, entry.second.amount, entry.first.damageNumberParticleKind);
return true;
}
return false;
});
for (auto const& damageNotification : m_damageManager->pullPendingNotifications()) {
auto damageDatabase = Root::singleton().damageDatabase();
DamageKind const& damageKind = damageDatabase->damageKind(damageNotification.damageSourceKind);
ElementalType const& elementalType = damageDatabase->elementalType(damageKind.elementalType);
auto damageNumberParticleKind = elementalType.damageNumberParticles.get(damageNotification.hitType);
auto damageNumberKey = DamageNumberKey{ damageNumberParticleKind, damageNotification.sourceEntityId, damageNotification.targetEntityId};
DamageNumber number;
if (m_damageNumbers.contains(damageNumberKey)) {
number = m_damageNumbers.take(damageNumberKey);
if (damageNotification.hitType == HitType::Kill)
renderParticle(damageNotification.position,
damageNotification.damageDealt + number.amount,
damageNumberKey.damageNumberParticleKind);
} else {
if (damageNotification.hitType == HitType::Kill)
renderParticle(damageNotification.position, damageNotification.damageDealt, damageNumberParticleKind);
number.amount = 0;
number.timestamp = Time::monotonicTime();
}
if (damageNotification.hitType != HitType::Kill) {
number.position = damageNotification.position;
number.amount += damageNotification.damageDealt;
m_damageNumbers[damageNumberKey] = number;
}
String material = damageNotification.targetMaterialKind;
if (!material.empty() && damageKind.effects.contains(material)) {
// default to normal hit
HitType effectHitType = damageKind.effects.get(material).contains(damageNotification.hitType) ? damageNotification.hitType : HitType::Hit;
m_samples.appendAll(soundsFromDefinition(damageKind.effects.get(material).get(effectHitType).sounds, damageNotification.position));
auto hitParticles = particlesFromDefinition(damageKind.effects.get(material).get(effectHitType).particles, damageNotification.position);
const List<Directives>* directives = nullptr;
if (auto& worldTemplate = m_worldTemplate) {
if (const auto& parameters = worldTemplate->worldParameters())
if (auto& globalDirectives = m_worldTemplate->worldParameters()->globalDirectives)
directives = &globalDirectives.get();
}
if (directives) {
int directiveIndex = unsigned(damageNotification.targetEntityId) % directives->size();
for (auto& p : hitParticles)
p.directives.append(directives->get(directiveIndex));
}
m_particles->addParticles(hitParticles);
}
}
}
void WorldClient::sparkDamagedBlocks() {
if (!inWorld())
return;
auto materialDatabase = Root::singleton().materialDatabase();
for (auto pos : m_damagedBlocks.values()) {
if (auto tile = m_tileArray->modifyTile(pos)) {
if (tile->backgroundDamage.healthy() && tile->foregroundDamage.healthy())
m_damagedBlocks.remove(pos);
if (isRealMaterial(tile->foreground) && tile->foregroundDamage.damageEffectPercentage() - Random::randf() > 0.0f
&& (Random::randf() < m_blockDamageParticleProbability)) {
auto particle = m_blockDamageParticle;
particle.color = materialDatabase->materialParticleColor(tile->foreground, tile->foregroundHueShift);
if (isTileProtected(pos))
particle = m_blockDingParticle;
particle.position += centerOfTile(pos);
particle.velocity = particle.velocity.magnitude()
* vnorm(m_geometry.diff(tile->foregroundDamage.sourcePosition(), particle.position));
particle.applyVariance(m_blockDamageParticleVariance);
m_particles->add(particle);
}
if (isRealMaterial(tile->background) && tile->backgroundDamage.damageEffectPercentage() - Random::randf() > 0.0f
&& (Random::randf() < m_blockDamageParticleProbability)) {
auto particle = m_blockDamageParticle;
particle.color = materialDatabase->materialParticleColor(tile->background, tile->backgroundHueShift);
if (isTileProtected(pos))
particle = m_blockDingParticle;
particle.position += centerOfTile(pos);
particle.velocity = particle.velocity.magnitude()
* vnorm(m_geometry.diff(tile->backgroundDamage.sourcePosition(), particle.position));
particle.applyVariance(m_blockDamageParticleVariance);
m_particles->add(particle);
}
}
}
}
InteractiveEntityPtr WorldClient::getInteractiveInRange(Vec2F const& targetPosition, Vec2F const& sourcePosition, float maxRange) const {
if (!inWorld())
return {};
return WorldImpl::getInteractiveInRange(m_geometry, m_entityMap, targetPosition, sourcePosition, maxRange);
}
bool WorldClient::canReachEntity(Vec2F const& position, float radius, EntityId targetEntity, bool preferInteractive) const {
if (!inWorld())
return false;
return WorldImpl::canReachEntity(m_geometry, m_tileArray, m_entityMap, position, radius, targetEntity, preferInteractive);
}
RpcPromise<InteractAction> WorldClient::interact(InteractRequest const& request) {
if (!inWorld())
return RpcPromise<InteractAction>::createFailed("not initialized in world");
if (auto targetEntity = m_entityMap->entity(request.targetId)) {
if (targetEntity->isMaster()) {
// client-side-master entities need to be handled here rather than over network
auto interactiveTarget = as<InteractiveEntity>(targetEntity);
starAssert(interactiveTarget);
return RpcPromise<InteractAction>::createFulfilled(interactiveTarget->interact(request));
}
}
auto pair = RpcPromise<InteractAction>::createPair();
Uuid requestId;
m_entityInteractionResponses[requestId] = pair.second;
m_outgoingPackets.append(make_shared<EntityInteractPacket>(request, requestId));
return pair.first;
}
void WorldClient::lightingTileGather() {
Vec3F environmentLight = m_sky->environmentLight().toRgbF();
float undergroundLevel = m_worldTemplate->undergroundLevel();
auto liquidsDatabase = Root::singleton().liquidsDatabase();
auto materialDatabase = Root::singleton().materialDatabase();
// Each column in tileEvalColumns is guaranteed to be no larger than the sector size.
size_t lights = 0;
m_tileArray->tileEvalColumns(m_lightingCalculator.calculationRegion(), [&](Vec2I const& pos, ClientTile const* column, size_t ySize) {
size_t baseIndex = m_lightingCalculator.baseIndexFor(pos);
for (size_t y = 0; y < ySize; ++y) {
auto& tile = column[y];
Vec3F light;
if (tile.foreground != EmptyMaterialId || tile.foregroundMod != NoModId)
light += materialDatabase->radiantLight(tile.foreground, tile.foregroundMod);
if (tile.liquid.liquid != EmptyLiquidId && tile.liquid.level != 0.0f)
light += liquidsDatabase->radiantLight(tile.liquid);
if (tile.foregroundLightTransparent) {
if (tile.background != EmptyMaterialId || tile.backgroundMod != NoModId)
light += materialDatabase->radiantLight(tile.background, tile.backgroundMod);
if (tile.backgroundLightTransparent && pos[1] + y > undergroundLevel)
light += environmentLight;
}
if (light.max() > 0.0f)
++lights;
m_lightingCalculator.setCellIndex(baseIndex + y, light, !tile.foregroundLightTransparent);
}
});
LogMap::set("client_render_world_async_light_tiles", toString(lights));
}
void WorldClient::lightingCalc() {
MutexLocker prepLocker(m_lightMapPrepMutex);
RectI lightRange = m_pendingLightRange;
List<LightSource> lights = std::move(m_pendingLights);
List<std::pair<Vec2F, Vec3F>> particleLights = std::move(m_pendingParticleLights);
m_lightingCalculator.setMonochrome(Root::singleton().configuration()->get("monochromeLighting").toBool());
m_lightingCalculator.begin(lightRange);
lightingTileGather();
prepLocker.unlock();
for (auto const& light : lights) {
Vec2F position = m_geometry.nearestTo(Vec2F(m_lightingCalculator.calculationRegion().min()), light.position);
if (light.type == LightType::Spread)
m_lightingCalculator.addSpreadLight(position, light.color);
else {
if (light.type == LightType::PointAsSpread) {
// hybrid (used for auto-converted object lights) - 75% spread, 25% point (2nd is applied elsewhere)
m_lightingCalculator.addSpreadLight(position, light.color * 0.75f);
m_lightingCalculator.addPointLight(position, light.color, light.pointBeam, light.beamAngle, light.beamAmbience, true);
} else // fully additive point light
m_lightingCalculator.addPointLight(position, light.color, light.pointBeam, light.beamAngle, light.beamAmbience);
}
}
for (auto const& lightPair : particleLights) {
Vec2F position = m_geometry.nearestTo(Vec2F(m_lightingCalculator.calculationRegion().min()), lightPair.first);
m_lightingCalculator.addSpreadLight(position, lightPair.second);
}
m_lightingCalculator.calculate(m_pendingLightMap);
{
MutexLocker mapLocker(m_lightMapMutex);
m_lightMinPosition = lightRange.min();
m_lightMap = std::move(m_pendingLightMap);
}
}
void WorldClient::lightingMain() {
MutexLocker condLocker(m_lightingMutex);
while (true) {
m_lightingCond.wait(m_lightingMutex);
if (m_stopLightingThread)
return;
int64_t start = Time::monotonicMicroseconds();
lightingCalc();
LogMap::set("client_render_world_async_light_calc", strf(u8"{:05d}\u00b5s", Time::monotonicMicroseconds() - start));
}
}
void WorldClient::initWorld(WorldStartPacket const& startPacket) {
clearWorld();
m_outgoingPackets.append(make_shared<WorldStartAcknowledgePacket>());
auto assets = Root::singleton().assets();
if (startPacket.localInterpolationMode)
m_interpolationTracker = InterpolationTracker(m_clientConfig.query("interpolationSettings.local"));
else
m_interpolationTracker = InterpolationTracker(m_clientConfig.query("interpolationSettings.normal"));
m_entityUpdateTimer = GameTimer(m_interpolationTracker.entityUpdateDelta());
m_clientId = startPacket.clientId;
auto entitySpace = connectionEntitySpace(startPacket.clientId);
m_worldTemplate = make_shared<WorldTemplate>(startPacket.templateData);
m_entityMap = make_shared<EntityMap>(m_worldTemplate->size(), entitySpace.first, entitySpace.second);
m_tileArray = make_shared<ClientTileSectorArray>(m_worldTemplate->size());
m_tileGetterFunction = [&, tile = ClientTile()](Vec2I pos) mutable -> ClientTile const& {
if (!m_predictedTiles.empty()) {
if (auto p = m_predictedTiles.ptr(pos)) {
p->apply(tile = m_tileArray->tile(pos));
if (p->liquid) {
if (p->liquid->liquid == tile.liquid.liquid)
tile.liquid.level += p->liquid->level;
else {
tile.liquid.liquid = p->liquid->liquid;
tile.liquid.level = p->liquid->level;
}
}
return tile;
}
}
return m_tileArray->tile(pos);
};
m_damageManager = make_shared<DamageManager>(this, startPacket.clientId);
m_luaRoot->restart();
m_luaRoot->tuneAutoGarbageCollection(m_clientConfig.getFloat("luaGcPause"), m_clientConfig.getFloat("luaGcStepMultiplier"));
m_playerStart = startPacket.playerRespawn;
m_respawnInWorld = startPacket.respawnInWorld;
m_worldProperties = startPacket.worldProperties.optObject().value();
m_dungeonIdGravity = startPacket.dungeonIdGravity;
m_dungeonIdBreathable = startPacket.dungeonIdBreathable;
m_protectedDungeonIds = startPacket.protectedDungeonIds;
m_geometry = WorldGeometry(m_worldTemplate->size());
m_particles = make_shared<ParticleManager>(m_geometry, m_tileArray);
m_particles->setUndergroundLevel(m_worldTemplate->undergroundLevel());
setupForceRegions();
if (!m_mainPlayer->isDead()) {
m_mainPlayer->init(this, m_entityMap->reserveEntityId(), EntityMode::Master);
m_entityMap->addEntity(m_mainPlayer);
}
m_mainPlayer->moveTo(startPacket.playerStart);
if (m_worldTemplate->worldParameters())
m_mainPlayer->overrideTech(m_worldTemplate->worldParameters()->overrideTech);
else
m_mainPlayer->overrideTech({});
// Auto reposition the client window on the player when the main player
// changes position.
centerClientWindowOnPlayer();
m_sky = make_shared<Sky>();
m_sky->readUpdate(startPacket.skyData);
m_weather.setup(m_geometry, [this](Vec2I const& pos) {
auto const& tile = m_tileArray->tile(pos);
return !isRealMaterial(tile.background) && !isSolidColliding(tile.getCollision());
});
m_weather.readUpdate(startPacket.weatherData);
m_lightingCalculator.setMonochrome(Root::singleton().configuration()->get("monochromeLighting").toBool());
m_lightingCalculator.setParameters(assets->json("/lighting.config:lighting"));
m_lightIntensityCalculator.setParameters(assets->json("/lighting.config:intensity"));
m_inWorld = true;
}
void WorldClient::clearWorld() {
if (m_entityMap) {
while (m_entityMap->size() > 0) {
for (auto entityId : m_entityMap->entityIds())
removeEntity(entityId, false);
}
}
waitForLighting();
m_currentStep = 0;
m_currentTime = 0;
m_inWorld = false;
m_clientId.reset();
m_interpolationTracker = InterpolationTracker();
m_masterEntitiesNetVersion.clear();
m_outgoingPackets.clear();
m_pingTime.reset();
m_entityMap.reset();
m_worldTemplate.reset();
m_worldProperties.clear();
m_tileArray.reset();
m_damageManager.reset();
m_luaRoot->shutdown();
m_particles.reset();
m_sky.reset();
m_currentParallax.reset();
m_nextParallax.reset();
m_parallaxFadeTimer.setDone();
m_clientState.reset();
m_ambientSounds.cancelAll();
m_musicTrack.cancelAll();
m_musicTrack.setVolume(1, 0, 0);
m_altMusicTrack.cancelAll();
m_altMusicTrack.setVolume(0, 0, 0);
m_altMusicActive = false;
if (m_spaceSound) {
m_spaceSound->stop();
m_spaceSound = {};
}
m_entityMessageResponses = {};
m_forceRegions.clear();
}
void WorldClient::tryGiveMainPlayerItem(ItemPtr item, bool silent) {
if (auto spill = m_mainPlayer->pickupItems(item, silent))
addEntity(ItemDrop::createRandomizedDrop(spill->descriptor(), m_mainPlayer->position()));
}
void WorldClient::notifyEntityCreate(EntityPtr const& entity) {
if (entity->isMaster() && !m_masterEntitiesNetVersion.contains(entity->entityId())) {
// Server was unaware of this entity until now
auto firstNetState = entity->writeNetState();
m_masterEntitiesNetVersion[entity->entityId()] = firstNetState.second;
m_outgoingPackets.append(make_shared<EntityCreatePacket>(entity->entityType(),
Root::singleton().entityFactory()->netStoreEntity(entity), std::move(firstNetState.first), entity->entityId()));
}
}
Vec2I WorldClient::environmentBiomeTrackPosition() const {
if (!inWorld())
return {};
auto pos = Vec2I::floor(m_clientState.windowCenter());
return {m_geometry.xwrap(pos[0]), pos[1]};
}
AmbientNoisesDescriptionPtr WorldClient::currentAmbientNoises() const {
if (!inWorld())
return {};
Vec2I pos = environmentBiomeTrackPosition();
return m_worldTemplate->ambientNoises(pos[0], pos[1]);
}
WeatherNoisesDescriptionPtr WorldClient::currentWeatherNoises() const {
if (!inWorld())
return {};
auto trackOptions = m_weather.weatherTrackOptions();
if (trackOptions.empty())
return {};
else
return make_shared<WeatherNoisesDescription>(std::move(trackOptions));
}
AmbientNoisesDescriptionPtr WorldClient::currentMusicTrack() const {
if (!inWorld())
return {};
Vec2I pos = environmentBiomeTrackPosition();
return m_worldTemplate->musicTrack(pos[0], pos[1]);
}
AmbientNoisesDescriptionPtr WorldClient::currentAltMusicTrack() const {
if (!inWorld())
return {};
return m_altMusicTrackDescription;
}
void WorldClient::playAltMusic(StringList const& newTracks, float fadeTime) {
auto newTrackGroup = AmbientTrackGroup(newTracks);
m_altMusicTrackDescription = make_shared<AmbientNoisesDescription>(AmbientTrackGroup(newTracks), AmbientTrackGroup());
if (!m_altMusicActive) {
m_musicTrack.setVolume(0.0, 0.0, fadeTime);
m_altMusicTrack.setVolume(1.0, 0.0, fadeTime);
m_altMusicActive = true;
}
}
void WorldClient::stopAltMusic(float fadeTime) {
if (m_altMusicActive) {
m_musicTrack.setVolume(1.0, 0.0, fadeTime);
m_altMusicTrack.setVolume(0.0, 0.0, fadeTime);
m_altMusicActive = false;
}
}
BiomeConstPtr WorldClient::mainEnvironmentBiome() const {
if (!inWorld())
return {};
Vec2I pos = environmentBiomeTrackPosition();
return m_worldTemplate->environmentBiome(pos[0], pos[1]);
}
bool WorldClient::readNetTile(Vec2I const& pos, NetTile const& netTile, bool updateCollision) {
ClientTile* tile = m_tileArray->modifyTile(pos);
if (!tile)
return false;
if (!m_predictedTiles.empty()) {
auto findPrediction = m_predictedTiles.find(pos);
if (findPrediction != m_predictedTiles.end()) {
auto& p = findPrediction->second;
if (p.collision && *p.collision == netTile.collision)
p.collision.reset();
if (p.foreground && (*p.foreground == StructureMaterialId || *p.foreground == netTile.foreground))
p.foreground.reset();
if (p.foregroundMod && *p.foregroundMod == netTile.foregroundMod)
p.foregroundMod.reset();
if (p.foregroundHueShift && *p.foregroundHueShift == netTile.foregroundHueShift)
p.foregroundHueShift.reset();
if (p.foregroundModHueShift && *p.foregroundModHueShift == netTile.foregroundModHueShift)
p.foregroundModHueShift.reset();
if (p.background && *p.background == netTile.background)
p.background.reset();
if (p.backgroundMod && *p.backgroundMod == netTile.backgroundMod)
p.backgroundMod.reset();
if (p.backgroundHueShift && *p.backgroundHueShift == netTile.backgroundHueShift)
p.backgroundHueShift.reset();
if (p.backgroundModHueShift && *p.backgroundModHueShift == netTile.backgroundModHueShift)
p.backgroundModHueShift.reset();
if (!p)
m_predictedTiles.erase(findPrediction);
}
}
tile->background = netTile.background;
tile->backgroundHueShift = netTile.backgroundHueShift;
tile->backgroundColorVariant = netTile.backgroundColorVariant;
tile->backgroundMod = netTile.backgroundMod;
tile->backgroundModHueShift = netTile.backgroundModHueShift;
tile->foreground = netTile.foreground;
tile->foregroundHueShift = netTile.foregroundHueShift;
tile->foregroundColorVariant = netTile.foregroundColorVariant;
tile->foregroundMod = netTile.foregroundMod;
tile->foregroundModHueShift = netTile.foregroundModHueShift;
tile->collision = netTile.collision;
tile->blockBiomeIndex = netTile.blockBiomeIndex;
tile->environmentBiomeIndex = netTile.environmentBiomeIndex;
tile->liquid = netTile.liquid.liquidLevel();
tile->dungeonId = netTile.dungeonId;
auto materialDatabase = Root::singleton().materialDatabase();
tile->backgroundLightTransparent = materialDatabase->backgroundLightTransparent(tile->background);
tile->foregroundLightTransparent =
materialDatabase->foregroundLightTransparent(tile->foreground) && tile->collision != CollisionKind::Dynamic;
if (updateCollision)
dirtyCollision(RectI::withSize(pos, {1, 1}));
return true;
}
void WorldClient::dirtyCollision(RectI const& region) {
if (!inWorld())
return;
auto dirtyRegion = region.padded(CollisionGenerator::BlockInfluenceRadius);
for (int x = dirtyRegion.xMin(); x < dirtyRegion.xMax(); ++x) {
for (int y = dirtyRegion.yMin(); y < dirtyRegion.yMax(); ++y) {
if (auto tile = m_tileArray->modifyTile({x, y}))
tile->collisionCacheDirty = true;
}
}
}
void WorldClient::freshenCollision(RectI const& region) {
if (!inWorld())
return;
RectI freshenRegion = RectI::null();
for (int x = region.xMin(); x < region.xMax(); ++x) {
for (int y = region.yMin(); y < region.yMax(); ++y) {
if (auto tile = m_tileArray->modifyTile({x, y})) {
if (tile->collisionCacheDirty)
freshenRegion.combine(RectI(x, y, x + 1, y + 1));
}
}
}
if (!freshenRegion.isNull()) {
for (int x = freshenRegion.xMin(); x < freshenRegion.xMax(); ++x) {
for (int y = freshenRegion.yMin(); y < freshenRegion.yMax(); ++y) {
if (auto tile = m_tileArray->modifyTile({x, y})) {
tile->collisionCacheDirty = false;
tile->collisionCache.clear();
}
}
}
for (auto& collisionBlock : m_collisionGenerator.getBlocks(freshenRegion)) {
if (auto tile = m_tileArray->modifyTile(collisionBlock.space))
tile->collisionCache.append(std::move(collisionBlock));
}
}
}
float WorldClient::lightLevel(Vec2F const& pos) const {
if (!inWorld())
return 0.0f;
return WorldImpl::lightLevel(m_tileArray, m_entityMap, m_geometry, m_worldTemplate, m_sky, m_lightIntensityCalculator, pos);
}
bool WorldClient::breathable(Vec2F const& pos) const {
if (!inWorld())
return true;
return WorldImpl::breathable(this, m_tileArray, m_dungeonIdBreathable, m_worldTemplate, pos);
}
float WorldClient::threatLevel() const {
if (!inWorld())
return 0.0f;
return m_worldTemplate->threatLevel();
}
StringList WorldClient::environmentStatusEffects(Vec2F const& pos) const {
if (!inWorld())
return {};
return m_worldTemplate->environmentStatusEffects(floor(pos[0]), floor(pos[1]));
}
StringList WorldClient::weatherStatusEffects(Vec2F const& pos) const {
if (!inWorld())
return {};
if (!m_weather.statusEffects().empty()) {
if (exposedToWeather(pos))
return m_weather.statusEffects();
}
return {};
}
bool WorldClient::exposedToWeather(Vec2F const& pos) const {
if (!inWorld())
return false;
if (!isUnderground(pos) && liquidLevel(Vec2I::floor(pos)).liquid == EmptyLiquidId) {
auto assets = Root::singleton().assets();
float weatherRayCheckDistance = assets->json("/weather.config:weatherRayCheckDistance").toFloat();
float weatherRayCheckWindInfluence = assets->json("/weather.config:weatherRayCheckWindInfluence").toFloat();
auto offset = Vec2F(-m_weather.wind() * weatherRayCheckWindInfluence, weatherRayCheckDistance).normalized() * weatherRayCheckDistance;
return !lineCollision({pos, pos + offset});
}
return false;
}
bool WorldClient::isUnderground(Vec2F const& pos) const {
if (!inWorld())
return true;
return m_worldTemplate->undergroundLevel() >= pos[1];
}
bool WorldClient::disableDeathDrops() const {
if (m_worldTemplate->worldParameters())
return m_worldTemplate->worldParameters()->disableDeathDrops;
return false;
}
List<PhysicsForceRegion> WorldClient::forceRegions() const {
return m_forceRegions;
}
Json WorldClient::getProperty(String const& propertyName, Json const& def) const {
if (!inWorld())
return {};
return m_worldProperties.value(propertyName, def);
}
void WorldClient::setProperty(String const& propertyName, Json const& property) {
if (!inWorld())
return;
if (m_worldProperties[propertyName] == property)
return;
m_outgoingPackets.append(make_shared<UpdateWorldPropertiesPacket>(JsonObject{{propertyName, property}}));
}
bool WorldClient::playerCanReachEntity(EntityId entityId, bool preferInteractive) const {
return m_mainPlayer->isAdmin() || canReachEntity(m_mainPlayer->position(), m_mainPlayer->interactRadius(), entityId, preferInteractive);
}
void WorldClient::disconnectAllWires(Vec2I wireEntityPosition, WireNode const& node) {
m_outgoingPackets.append(make_shared<DisconnectAllWiresPacket>(wireEntityPosition, node));
}
void WorldClient::connectWire(WireConnection const& output, WireConnection const& input) {
m_outgoingPackets.append(make_shared<ConnectWirePacket>(output, input));
}
bool WorldClient::sendSecretBroadcast(StringView broadcast, bool raw, bool compress) {
if (!inWorld() || !m_mainPlayer || !m_mainPlayer->getSecretPropertyView(SECRET_BROADCAST_PUBLIC_KEY))
return false;
auto signature = Curve25519::sign((void*)broadcast.utf8Ptr(), broadcast.utf8Size());
auto damageNotification = make_shared<DamageNotificationPacket>();
auto& remDmg = damageNotification->remoteDamageNotification;
auto& dmg = remDmg.damageNotification;
dmg.targetEntityId = dmg.sourceEntityId = remDmg.sourceEntityId = m_mainPlayer->entityId();
dmg.damageDealt = dmg.healthLost = 0.0f;
dmg.hitType = HitType::Hit;
dmg.damageSourceKind = "nodamage";
dmg.targetMaterialKind = raw ? broadcast : strf("{}{}{}", SECRET_BROADCAST_PREFIX, StringView((char*)&signature, sizeof(signature)), broadcast);
dmg.position = m_mainPlayer->position();
if (!compress)
damageNotification->setCompressionMode(PacketCompressionMode::Disabled);
m_outgoingPackets.emplace_back(std::move(damageNotification));
return true;
}
bool WorldClient::handleSecretBroadcast(PlayerPtr player, StringView broadcast) {
if (m_broadcastCallback)
return m_broadcastCallback(player, broadcast);
else
return false;
}
void WorldClient::ClientRenderCallback::addDrawable(Drawable drawable, EntityRenderLayer renderLayer) {
drawables[renderLayer].append(std::move(drawable));
}
void WorldClient::ClientRenderCallback::addLightSource(LightSource lightSource) {
lightSources.append(std::move(lightSource));
}
void WorldClient::ClientRenderCallback::addParticle(Particle particle) {
particles.append(std::move(particle));
}
void WorldClient::ClientRenderCallback::addAudio(AudioInstancePtr audio) {
audios.append(std::move(audio));
}
void WorldClient::ClientRenderCallback::addTilePreview(PreviewTile preview) {
previewTiles.append(std::move(preview));
}
void WorldClient::ClientRenderCallback::addOverheadBar(OverheadBar bar) {
overheadBars.append(std::move(bar));
}
double WorldClient::epochTime() const {
if (!inWorld())
return 0;
return m_sky->epochTime();
}
uint32_t WorldClient::day() const {
if (!inWorld())
return 0;
return m_sky->day();
}
float WorldClient::dayLength() const {
if (!inWorld())
return 0;
return m_sky->dayLength();
}
float WorldClient::timeOfDay() const {
if (!inWorld())
return 0;
return m_sky->timeOfDay();
}
LuaRootPtr WorldClient::luaRoot() {
return m_luaRoot;
}
RpcPromise<Vec2F> WorldClient::findUniqueEntity(String const& uniqueId) {
if (auto entity = m_entityMap->uniqueEntity(uniqueId))
return RpcPromise<Vec2F>::createFulfilled(entity->position());
auto pair = RpcPromise<Vec2F>::createPair();
auto& rpcPromises = m_findUniqueEntityResponses[uniqueId];
if (rpcPromises.empty())
m_outgoingPackets.append(make_shared<FindUniqueEntityPacket>(uniqueId));
rpcPromises.append(pair.second);
return pair.first;
}
RpcPromise<Json> WorldClient::sendEntityMessage(Variant<EntityId, String> const& entityId, String const& message, JsonArray const& args) {
EntityPtr entity;
if (entityId.is<EntityId>())
entity = m_entityMap->entity(entityId.get<EntityId>());
else
entity = m_entityMap->uniqueEntity(entityId.get<String>());
// Only fail with "unknown entity" if we know this entity should exist on the
// client, because it's entity id indicates it is master here.
if (entityId.is<EntityId>() && !entity && m_clientId == connectionForEntity(entityId.get<EntityId>())) {
return RpcPromise<Json>::createFailed("Unknown entity");
} else if (entity && entity->isMaster()) {
if (auto resp = entity->receiveMessage(*m_clientId, message, args))
return RpcPromise<Json>::createFulfilled(resp.take());
else
return RpcPromise<Json>::createFailed("Message not handled by entity");
} else {
auto pair = RpcPromise<Json>::createPair();
Uuid uuid;
m_entityMessageResponses[uuid] = pair.second;
m_outgoingPackets.append(make_shared<EntityMessagePacket>(entityId, message, args, uuid));
return pair.first;
}
}
List<ChatAction> WorldClient::pullPendingChatActions() {
List<ChatAction> result;
if (m_entityMap) {
for (auto const& entity : m_entityMap->all<ChattyEntity>())
result.appendAll(entity->pullPendingChatActions());
}
return result;
}
WorldStructure const& WorldClient::centralStructure() const {
return m_centralStructure;
}
bool WorldClient::DamageNumberKey::operator<(DamageNumberKey const& other) const {
return tie(sourceEntityId, targetEntityId, damageNumberParticleKind)
< tie(other.sourceEntityId, other.targetEntityId, other.damageNumberParticleKind);
}
void WorldClient::renderCollisionDebug() {
RectI clientWindow = m_clientState.window();
if (clientWindow.isEmpty())
return;
auto logPoly = [](PolyF poly, Vec2F position, float r, float g, float b) {
poly.translate(position);
SpatialLogger::logPoly("world", poly, {floatToByte(r, true), floatToByte(g, true), floatToByte(b, true), 255});
};
forEachCollisionBlock(clientWindow, [&](auto const& block) {
logPoly(block.poly, Vec2F{}, 1.0f, 0.0f, 0.0f);
});
for (auto const& object : query<TileEntity>(RectF(clientWindow))) {
for (auto const& space : object->spaces())
logPoly(PolyF(RectF(Vec2F(space), Vec2F(space) + Vec2F(1, 1))), Vec2F(object->tilePosition()), 0., 1., 0.);
}
for (auto const& physics : query<PhysicsEntity>(RectF(clientWindow))) {
for (auto const& forceRegion : physics->forceRegions()) {
if (auto dfr = forceRegion.ptr<DirectionalForceRegion>())
logPoly(dfr->region, {}, 1.0f, 1.0f, 0.0f);
else if (auto rfr = forceRegion.ptr<RadialForceRegion>())
logPoly(PolyF(rfr->boundBox()), {}, 0.0f, 1.0f, 1.0f);
}
for (size_t i = 0; i < physics->movingCollisionCount(); ++i) {
if (auto pmc = physics->movingCollision(i)) {
logPoly(pmc->collision, pmc->position, 1.0f, 1.0f, 1.0f);
}
}
}
}
void WorldClient::informTilePrediction(Vec2I const& pos, TileModification const& modification) {
auto now = Time::monotonicMilliseconds();
auto& p = m_predictedTiles[pos];
p.time = now;
if (auto placeMaterial = modification.ptr<PlaceMaterial>()) {
if (placeMaterial->layer == TileLayer::Foreground) {
auto materialDatabase = Root::singleton().materialDatabase();
if (!materialDatabase->isCascadingFallingMaterial(placeMaterial->material)
&& !materialDatabase-> isFallingMaterial(placeMaterial->material)) {
p.foreground = placeMaterial->material;
p.foregroundHueShift = placeMaterial->materialHueShift;
}
else
p.foreground = StructureMaterialId;
if (placeMaterial->collisionOverride != TileCollisionOverride::None)
p.collision = collisionKindFromOverride(placeMaterial->collisionOverride);
else
p.collision = materialDatabase->materialCollisionKind(placeMaterial->material);
dirtyCollision(RectI::withSize(pos, { 1, 1 }));
} else {
p.background = placeMaterial->material;
p.backgroundHueShift = placeMaterial->materialHueShift;
}
}
else if (auto placeMod = modification.ptr<PlaceMod>()) {
if (placeMod->layer == TileLayer::Foreground)
p.foregroundMod = placeMod->mod;
else
p.backgroundMod = placeMod->mod;
}
else if (auto placeColor = modification.ptr<PlaceMaterialColor>()) {
if (placeColor->layer == TileLayer::Foreground)
p.foregroundColorVariant = placeColor->color;
else
p.backgroundColorVariant = placeColor->color;
}
else if (auto placeLiquid = modification.ptr<PlaceLiquid>()) {
if (!p.liquid || p.liquid->liquid != placeLiquid->liquid)
p.liquid = LiquidLevel(placeLiquid->liquid, placeLiquid->liquidLevel);
else
p.liquid->level += placeLiquid->liquidLevel;
}
}
void WorldClient::setupForceRegions() {
m_forceRegions.clear();
if (!currentTemplate() || !currentTemplate()->worldParameters())
return;
auto forceRegionType = currentTemplate()->worldParameters()->worldEdgeForceRegions;
if (forceRegionType == WorldEdgeForceRegionType::None)
return;
bool addTopRegion = forceRegionType == WorldEdgeForceRegionType::Top || forceRegionType == WorldEdgeForceRegionType::TopAndBottom;
bool addBottomRegion = forceRegionType == WorldEdgeForceRegionType::Bottom || forceRegionType == WorldEdgeForceRegionType::TopAndBottom;
auto worldServerConfig = Root::singleton().assets()->json("/worldserver.config");
auto regionHeight = worldServerConfig.getFloat("worldEdgeForceRegionHeight");
auto regionForce = worldServerConfig.getFloat("worldEdgeForceRegionForce");
auto regionVelocity = worldServerConfig.getFloat("worldEdgeForceRegionVelocity");
auto regionCategoryFilter = PhysicsCategoryFilter::whitelist({"player", "monster", "npc", "vehicle"});
auto worldSize = Vec2F(currentTemplate()->size());
if (addTopRegion) {
auto topForceRegion = GradientForceRegion();
topForceRegion.region = PolyF({
{0, worldSize[1] - regionHeight},
{worldSize[0], worldSize[1] - regionHeight},
(worldSize),
{0, worldSize[1]}});
topForceRegion.gradient = Line2F({0, worldSize[1]}, {0, worldSize[1] - regionHeight});
topForceRegion.baseTargetVelocity = regionVelocity;
topForceRegion.baseControlForce = regionForce;
topForceRegion.categoryFilter = regionCategoryFilter;
m_forceRegions.append(topForceRegion);
}
if (addBottomRegion) {
auto bottomForceRegion = GradientForceRegion();
bottomForceRegion.region = PolyF({
{0, 0},
{worldSize[0], 0},
{worldSize[0], regionHeight},
{0, regionHeight}});
bottomForceRegion.gradient = Line2F({0, 0}, {0, regionHeight});
bottomForceRegion.baseTargetVelocity = regionVelocity;
bottomForceRegion.baseControlForce = regionForce;
bottomForceRegion.categoryFilter = regionCategoryFilter;
m_forceRegions.append(bottomForceRegion);
}
}
}