/*
Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "environment.h"
#include "filesys.h"
#include "porting.h"
-
-Environment::Environment()
+#include "collision.h"
+#include "content_mapnode.h"
+#include "mapblock.h"
+#include "serverobject.h"
+#include "content_sao.h"
+#include "mapgen.h"
+#include "settings.h"
+#include "log.h"
+#include "profiler.h"
+#include "scriptapi.h"
+#include "mapnode_contentfeatures.h"
+#include "nodemetadata.h"
+
+#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
+
+Environment::Environment():
+ m_time_of_day(9000)
{
- m_daynight_ratio = 0.5;
}
Environment::~Environment()
}
}
-void Environment::setDayNightRatio(u32 r)
+/*void Environment::setDayNightRatio(u32 r)
{
- m_daynight_ratio = r;
-}
+ getDayNightRatio() = r;
+}*/
u32 Environment::getDayNightRatio()
{
- return m_daynight_ratio;
+ //return getDayNightRatio();
+ return time_to_daynight_ratio(m_time_of_day);
+}
+
+/*
+ ActiveBlockList
+*/
+
+void fillRadiusBlock(v3s16 p0, s16 r, core::map<v3s16, bool> &list)
+{
+ v3s16 p;
+ for(p.X=p0.X-r; p.X<=p0.X+r; p.X++)
+ for(p.Y=p0.Y-r; p.Y<=p0.Y+r; p.Y++)
+ for(p.Z=p0.Z-r; p.Z<=p0.Z+r; p.Z++)
+ {
+ // Set in list
+ list[p] = true;
+ }
+}
+
+void ActiveBlockList::update(core::list<v3s16> &active_positions,
+ s16 radius,
+ core::map<v3s16, bool> &blocks_removed,
+ core::map<v3s16, bool> &blocks_added)
+{
+ /*
+ Create the new list
+ */
+ core::map<v3s16, bool> newlist;
+ for(core::list<v3s16>::Iterator i = active_positions.begin();
+ i != active_positions.end(); i++)
+ {
+ fillRadiusBlock(*i, radius, newlist);
+ }
+
+ /*
+ Find out which blocks on the old list are not on the new list
+ */
+ // Go through old list
+ for(core::map<v3s16, bool>::Iterator i = m_list.getIterator();
+ i.atEnd()==false; i++)
+ {
+ v3s16 p = i.getNode()->getKey();
+ // If not on new list, it's been removed
+ if(newlist.find(p) == NULL)
+ blocks_removed.insert(p, true);
+ }
+
+ /*
+ Find out which blocks on the new list are not on the old list
+ */
+ // Go through new list
+ for(core::map<v3s16, bool>::Iterator i = newlist.getIterator();
+ i.atEnd()==false; i++)
+ {
+ v3s16 p = i.getNode()->getKey();
+ // If not on old list, it's been added
+ if(m_list.find(p) == NULL)
+ blocks_added.insert(p, true);
+ }
+
+ /*
+ Update m_list
+ */
+ m_list.clear();
+ for(core::map<v3s16, bool>::Iterator i = newlist.getIterator();
+ i.atEnd()==false; i++)
+ {
+ v3s16 p = i.getNode()->getKey();
+ m_list.insert(p, true);
+ }
}
/*
ServerEnvironment
*/
-ServerEnvironment::ServerEnvironment(ServerMap *map, Server *server):
+ServerEnvironment::ServerEnvironment(ServerMap *map, lua_State *L):
m_map(map),
- m_server(server),
+ m_lua(L),
m_random_spawn_timer(3),
- m_send_recommended_timer(0)
+ m_send_recommended_timer(0),
+ m_game_time(0),
+ m_game_time_fraction_counter(0)
{
}
ServerEnvironment::~ServerEnvironment()
{
+ // Clear active block list.
+ // This makes the next one delete all active objects.
+ m_active_blocks.clear();
+
+ // Convert all objects to static and delete the active objects
+ deactivateFarObjects(true);
+
// Drop/delete map
m_map->drop();
}
// Full path to this file
std::string path = players_path + "/" + player_files[i].name;
- //
dstream<<"Checking player file "<<path<<std::endl;
+ //
infostream<<"Checking player file "<<path<<std::endl;
// Load player to see what is its name
ServerRemotePlayer testplayer;
std::ifstream is(path.c_str(), std::ios_base::binary);
if(is.good() == false)
{
-
dstream<<"Failed to read "<<path<<std::endl;
+
infostream<<"Failed to read "<<path<<std::endl;
continue;
}
testplayer.deSerialize(is);
}
- //dstream<<"Loaded test player with name "<<testplayer.getName()<<std::endl;
+ //infostream<<"Loaded test player with name "<<testplayer.getName()<<std::endl;
// Search for the player
std::string playername = testplayer.getName();
Player *player = getPlayer(playername.c_str());
if(player == NULL)
{
-
dstream<<"Didn't find matching player, ignoring file "<<path<<std::endl;
+
infostream<<"Didn't find matching player, ignoring file "<<path<<std::endl;
continue;
}
- //dstream<<"Found matching player, overwriting."<<std::endl;
+ //infostream<<"Found matching player, overwriting."<<std::endl;
// OK, found. Save player there.
{
std::ofstream os(path.c_str(), std::ios_base::binary);
if(os.good() == false)
{
-
dstream<<"Failed to overwrite "<<path<<std::endl;
+
infostream<<"Failed to overwrite "<<path<<std::endl;
continue;
}
player->serialize(os);
Player *player = *i;
if(saved_players.find(player) != NULL)
{
- /*
dstream<<"Player "<<player->getName()
+ /*
infostream<<"Player "<<player->getName()
<<" was already saved."<<std::endl;*/
continue;
}
// Don't save unnamed player
if(playername == "")
{
- //dstream<<"Not saving unnamed player."<<std::endl;
+ //infostream<<"Not saving unnamed player."<<std::endl;
continue;
}
/*
}
if(found == false)
{
- dstream<<"WARNING: Didn't find free file for player"<<std::endl;
+ infostream<<"Didn't find free file for player"<<std::endl;
continue;
}
{
- /*
dstream<<"Saving player "<<player->getName()<<" to "
+ /*
infostream<<"Saving player "<<player->getName()<<" to "
<<path<<std::endl;*/
// Open file and serialize
std::ofstream os(path.c_str(), std::ios_base::binary);
if(os.good() == false)
{
-
dstream<<"WARNING: Failed to overwrite "<<path<<std::endl;
+
infostream<<"Failed to overwrite "<<path<<std::endl;
continue;
}
player->serialize(os);
}
}
- //dstream<<"Saved "<<saved_players.size()<<" players."<<std::endl;
+ //infostream<<"Saved "<<saved_players.size()<<" players."<<std::endl;
}
void ServerEnvironment::deSerializePlayers(const std::string &savedir)
// Full path to this file
std::string path = players_path + "/" + player_files[i].name;
-
dstream<<"Checking player file "<<path<<std::endl;
+
infostream<<"Checking player file "<<path<<std::endl;
// Load player to see what is its name
ServerRemotePlayer testplayer;
std::ifstream is(path.c_str(), std::ios_base::binary);
if(is.good() == false)
{
-
dstream<<"Failed to read "<<path<<std::endl;
+
infostream<<"Failed to read "<<path<<std::endl;
continue;
}
testplayer.deSerialize(is);
}
- dstream<<"Loaded test player with name "<<testplayer.getName()<<std::endl;
+ if(!string_allowed(testplayer.getName(), PLAYERNAME_ALLOWED_CHARS))
+ {
+ infostream<<"Not loading player with invalid name: "
+ <<testplayer.getName()<<std::endl;
+ }
+
+ infostream<<"Loaded test player with name "<<testplayer.getName()
+ <<std::endl;
// Search for the player
std::string playername = testplayer.getName();
bool newplayer = false;
if(player == NULL)
{
- dstream<<"Is a new player"<<std::endl;
+ infostream<<"Is a new player"<<std::endl;
player = new ServerRemotePlayer();
newplayer = true;
}
// Load player
{
- dstream<<"Reading player "<<testplayer.getName()<<" from "
+ infostream<<"Reading player "<<testplayer.getName()<<" from "
<<path<<std::endl;
// Open file and deserialize
std::ifstream is(path.c_str(), std::ios_base::binary);
if(is.good() == false)
{
-
dstream<<"Failed to read "<<path<<std::endl;
+
infostream<<"Failed to read "<<path<<std::endl;
continue;
}
player->deSerialize(is);
}
}
-void ServerEnvironment::step(float dtime)
+void ServerEnvironment::saveMeta(const std::string &savedir)
{
- DSTACK(__FUNCTION_NAME);
-
- //TimeTaker timer("ServerEnv step");
+ std::string path = savedir + "/env_meta.txt";
- // Get some settings
- //bool free_move = g_settings.getBool("free_move");
- bool footprints = g_settings.getBool("footprints");
+ // Open file and serialize
+ std::ofstream os(path.c_str(), std::ios_base::binary);
+ if(os.good() == false)
+ {
+ infostream<<"ServerEnvironment::saveMeta(): Failed to open "
+ <<path<<std::endl;
+ throw SerializationError("Couldn't save env meta");
+ }
+
+ Settings args;
+ args.setU64("game_time", m_game_time);
+ args.setU64("time_of_day", getTimeOfDay());
+ args.writeLines(os);
+ os<<"EnvArgsEnd\n";
+}
+
+void ServerEnvironment::loadMeta(const std::string &savedir)
+{
+ std::string path = savedir + "/env_meta.txt";
+ // Open file and deserialize
+ std::ifstream is(path.c_str(), std::ios_base::binary);
+ if(is.good() == false)
{
- //TimeTaker timer("Server m_map->timerUpdate()", g_device);
- m_map->timerUpdate(dtime);
+ infostream<<"ServerEnvironment::loadMeta(): Failed to open "
+ <<path<<std::endl;
+ throw SerializationError("Couldn't load env meta");
}
- /*
- Handle players
- */
- for(core::list<Player*>::Iterator i = m_players.begin();
- i != m_players.end(); i++)
+ Settings args;
+
+ for(;;)
{
- Player *player = *i;
-
- // Ignore disconnected players
- if(player->peer_id == 0)
- continue;
+ if(is.eof())
+ throw SerializationError
+ ("ServerEnvironment::loadMeta(): EnvArgsEnd not found");
+ std::string line;
+ std::getline(is, line);
+ std::string trimmedline = trim(line);
+ if(trimmedline == "EnvArgsEnd")
+ break;
+ args.parseConfigLine(line);
+ }
+
+ try{
+ m_game_time = args.getU64("game_time");
+ }catch(SettingNotFoundException &e){
+ // Getting this is crucial, otherwise timestamps are useless
+ throw SerializationError("Couldn't load env meta game_time");
+ }
- v3f playerpos = player->getPosition();
-
- // Move
- player->move(dtime, *m_map, 100*BS);
-
- /*
- Add footsteps to grass
- */
- if(footprints)
+ try{
+ m_time_of_day = args.getU64("time_of_day");
+ }catch(SettingNotFoundException &e){
+ // This is not as important
+ m_time_of_day = 9000;
+ }
+}
+
+#if 0
+// This is probably very useless
+void spawnRandomObjects(MapBlock *block)
+{
+ for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
+ for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
+ {
+ bool last_node_walkable = false;
+ for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
{
- // Get node that is at BS/4 under player
- v3s16 bottompos = floatToInt(playerpos + v3f(0,-BS/4,0), BS);
- try{
- MapNode n = m_map->getNode(bottompos);
- if(n.d == CONTENT_GRASS)
- {
- n.d = CONTENT_GRASS_FOOTSTEPS;
- m_map->setNode(bottompos, n);
- }
+ v3s16 p(x0,y0,z0);
+ MapNode n = block->getNodeNoEx(p);
+ if(n.getContent() == CONTENT_IGNORE)
+ continue;
+ if(content_features(n).liquid_type != LIQUID_NONE)
+ continue;
+ if(content_features(n).walkable)
+ {
+ last_node_walkable = true;
+ continue;
}
- catch(InvalidPositionException &e)
+ if(last_node_walkable)
{
+ // If block contains light information
+ if(content_features(n).param_type == CPT_LIGHT)
+ {
+ if(n.getLight(LIGHTBANK_DAY) <= 5)
+ {
+ if(myrand() % 1000 == 0)
+ {
+ v3f pos_f = intToFloat(p+block->getPosRelative(), BS);
+ pos_f.Y -= BS*0.4;
+ ServerActiveObject *obj = new Oerkki1SAO(NULL,0,pos_f);
+ std::string data = obj->getStaticData();
+ StaticObject s_obj(obj->getType(),
+ obj->getBasePosition(), data);
+ // Add one
+ block->m_static_objects.insert(0, s_obj);
+ delete obj;
+ block->setChangedFlag();
+ }
+ }
+ }
}
+ last_node_walkable = false;
}
}
+}
+#endif
+
+void ServerEnvironment::activateBlock(MapBlock *block, u32 additional_dtime)
+{
+ // Get time difference
+ u32 dtime_s = 0;
+ u32 stamp = block->getTimestamp();
+ if(m_game_time > stamp && stamp != BLOCK_TIMESTAMP_UNDEFINED)
+ dtime_s = m_game_time - block->getTimestamp();
+ dtime_s += additional_dtime;
+
+ // Set current time as timestamp (and let it set ChangedFlag)
+ block->setTimestamp(m_game_time);
+
+ //infostream<<"Block is "<<dtime_s<<" seconds old."<<std::endl;
- /*
- Step active objects
- */
+ // Activate stored objects
+ activateObjects(block);
- bool send_recommended = false;
- m_send_recommended_timer += dtime;
- if(m_send_recommended_timer > 0.15)
+ // Run node metadata
+ bool changed = block->m_node_metadata->step((float)dtime_s);
+ if(changed)
{
- m_send_recommended_timer = 0;
- send_recommended = true;
- }
+ MapEditEvent event;
+ event.type = MEET_BLOCK_NODE_METADATA_CHANGED;
+ event.p = block->getPos();
+ m_map->dispatchEvent(&event);
- for(core::map<u16, ServerActiveObject*>::Iterator
- i = m_active_objects.getIterator();
- i.atEnd()==false; i++)
- {
- ServerActiveObject* obj = i.getNode()->getValue();
- // Step object, putting messages directly to the queue
- obj->step(dtime, m_active_object_messages, send_recommended);
+ block->setChangedFlag();
}
- if(m_object_management_interval.step(dtime, 0.5))
+ // TODO: Do something
+ // TODO: Implement usage of ActiveBlockModifier
+
+ // Here's a quick demonstration
+ v3s16 p0;
+ for(p0.X=0; p0.X<MAP_BLOCKSIZE; p0.X++)
+ for(p0.Y=0; p0.Y<MAP_BLOCKSIZE; p0.Y++)
+ for(p0.Z=0; p0.Z<MAP_BLOCKSIZE; p0.Z++)
{
- //TimeTaker timer("ServerEnv object management");
-
- /*
- Remove objects that satisfy (m_removed && m_known_by_count==0)
- */
+ v3s16 p = p0 + block->getPosRelative();
+ MapNode n = block->getNodeNoEx(p0);
+#if 1
+ // Test something:
+ // Convert all mud under proper day lighting to grass
+ if(n.getContent() == CONTENT_MUD)
{
- core::list<u16> objects_to_remove;
- for(core::map<u16, ServerActiveObject*>::Iterator
- i = m_active_objects.getIterator();
- i.atEnd()==false; i++)
+ if(dtime_s > 300)
{
- u16 id = i.getNode()->getKey();
- ServerActiveObject* obj = i.getNode()->getValue();
- // This shouldn't happen but check it
- if(obj == NULL)
- {
- dstream<<"WARNING: NULL object found in ServerEnvironment"
- <<" while finding removed objects. id="<<id<<std::endl;
- // Id to be removed from m_active_objects
- objects_to_remove.push_back(id);
- continue;
- }
- // If not m_removed, don't remove.
- if(obj->m_removed == false)
- continue;
- // Delete static data from block
- if(obj->m_static_exists)
+ MapNode n_top = block->getNodeNoEx(p0+v3s16(0,1,0));
+ if(content_features(n_top).air_equivalent &&
+ n_top.getLight(LIGHTBANK_DAY) >= 13)
{
- MapBlock *block = m_map->getBlockNoCreateNoEx(obj->m_static_block);
- if(block)
- {
- block->m_static_objects.remove(id);
- block->setChangedFlag();
- }
+ n.setContent(CONTENT_GRASS);
+ m_map->addNodeWithEvent(p, n);
}
- // If m_known_by_count > 0, don't actually remove.
- if(obj->m_known_by_count > 0)
- continue;
- // Delete
- delete obj;
- // Id to be removed from m_active_objects
- objects_to_remove.push_back(id);
}
- // Remove references from m_active_objects
- for(core::list<u16>::Iterator i = objects_to_remove.begin();
- i != objects_to_remove.end(); i++)
- {
- m_active_objects.remove(*i);
+ }
+#endif
+ }
+}
+
+void ServerEnvironment::clearAllObjects()
+{
+ infostream<<"ServerEnvironment::clearAllObjects(): "
+ <<"Removing all active objects"<<std::endl;
+ core::list<u16> objects_to_remove;
+ for(core::map<u16, ServerActiveObject*>::Iterator
+ i = m_active_objects.getIterator();
+ i.atEnd()==false; i++)
+ {
+ ServerActiveObject* obj = i.getNode()->getValue();
+ u16 id = i.getNode()->getKey();
+ v3f objectpos = obj->getBasePosition();
+ // Delete static object if block is loaded
+ if(obj->m_static_exists){
+ MapBlock *block = m_map->getBlockNoCreateNoEx(obj->m_static_block);
+ if(block){
+ block->m_static_objects.remove(id);
+ block->raiseModified(MOD_STATE_WRITE_NEEDED);
+ obj->m_static_exists = false;
}
}
-
+ // If known by some client, don't delete immediately
+ if(obj->m_known_by_count > 0){
+ obj->m_pending_deactivation = true;
+ obj->m_removed = true;
+ continue;
+ }
+ // Deregister in scripting api
+ scriptapi_rm_object_reference(m_lua, obj);
+ // Delete active object
+ delete obj;
+ // Id to be removed from m_active_objects
+ objects_to_remove.push_back(id);
+ }
+ // Remove references from m_active_objects
+ for(core::list<u16>::Iterator i = objects_to_remove.begin();
+ i != objects_to_remove.end(); i++)
+ {
+ m_active_objects.remove(*i);
+ }
+
+ core::list<v3s16> loadable_blocks;
+ infostream<<"ServerEnvironment::clearAllObjects(): "
+ <<"Listing all loadable blocks"<<std::endl;
+ m_map->listAllLoadableBlocks(loadable_blocks);
+ infostream<<"ServerEnvironment::clearAllObjects(): "
+ <<"Done listing all loadable blocks: "
+ <<loadable_blocks.size()
+ <<", now clearing"<<std::endl;
+ u32 report_interval = loadable_blocks.size() / 10;
+ u32 num_blocks_checked = 0;
+ u32 num_blocks_cleared = 0;
+ u32 num_objs_cleared = 0;
+ for(core::list<v3s16>::Iterator i = loadable_blocks.begin();
+ i != loadable_blocks.end(); i++)
+ {
+ v3s16 p = *i;
+ MapBlock *block = m_map->emergeBlock(p, false);
+ if(!block){
+ errorstream<<"ServerEnvironment::clearAllObjects(): "
+ <<"Failed to emerge block "<<PP(p)<<std::endl;
+ continue;
+ }
+ u32 num_stored = block->m_static_objects.m_stored.size();
+ u32 num_active = block->m_static_objects.m_active.size();
+ if(num_stored != 0 || num_active != 0){
+ block->m_static_objects.m_stored.clear();
+ block->m_static_objects.m_active.clear();
+ block->raiseModified(MOD_STATE_WRITE_NEEDED);
+ num_objs_cleared += num_stored + num_active;
+ num_blocks_cleared++;
+ }
+ num_blocks_checked++;
+
+ if(num_blocks_checked % report_interval == 0){
+ float percent = 100.0 * (float)num_blocks_checked /
+ loadable_blocks.size();
+ infostream<<"ServerEnvironment::clearAllObjects(): "
+ <<"Cleared "<<num_objs_cleared<<" objects"
+ <<" in "<<num_blocks_cleared<<" blocks ("
+ <<percent<<"%)"<<std::endl;
+ }
+ }
+ infostream<<"ServerEnvironment::clearAllObjects(): "
+ <<"Finished: Cleared "<<num_objs_cleared<<" objects"
+ <<" in "<<num_blocks_cleared<<" blocks"<<std::endl;
+}
- const s16 to_active_max_blocks = 3;
- const f32 to_static_max_f = (to_active_max_blocks+1)*MAP_BLOCKSIZE*BS;
+static void getMob_dungeon_master(Settings &properties)
+{
+ properties.set("looks", "dungeon_master");
+ properties.setFloat("yaw", 1.57);
+ properties.setFloat("hp", 30);
+ properties.setBool("bright_shooting", true);
+ properties.set("shoot_type", "fireball");
+ properties.set("shoot_y", "0.7");
+ properties.set("player_hit_damage", "1");
+ properties.set("player_hit_distance", "1.0");
+ properties.set("player_hit_interval", "0.5");
+ properties.setBool("mindless_rage", myrand_range(0,100)==0);
+}
- /*
- Convert stored objects from blocks near the players to active.
- */
+void ServerEnvironment::step(float dtime)
+{
+ DSTACK(__FUNCTION_NAME);
+
+ //TimeTaker timer("ServerEnv step");
+
+ // Get some settings
+ bool footprints = g_settings->getBool("footprints");
+
+ /*
+ Increment game time
+ */
+ {
+ m_game_time_fraction_counter += dtime;
+ u32 inc_i = (u32)m_game_time_fraction_counter;
+ m_game_time += inc_i;
+ m_game_time_fraction_counter -= (float)inc_i;
+ }
+
+ /*
+ Handle players
+ */
+ {
+ ScopeProfiler sp(g_profiler, "SEnv: handle players avg", SPT_AVG);
for(core::list<Player*>::Iterator i = m_players.begin();
i != m_players.end(); i++)
{
v3f playerpos = player->getPosition();
- v3s16 blockpos0 = getNodeBlockPos(floatToInt(playerpos, BS));
- v3s16 bpmin = blockpos0 - v3s16(1,1,1)*to_active_max_blocks;
- v3s16 bpmax = blockpos0 + v3s16(1,1,1)*to_active_max_blocks;
- // Loop through all nearby blocks
- for(s16 x=bpmin.X; x<=bpmax.X; x++)
- for(s16 y=bpmin.Y; y<=bpmax.Y; y++)
- for(s16 z=bpmin.Z; z<=bpmax.Z; z++)
+ // Move
+ player->move(dtime, *m_map, 100*BS);
+
+ /*
+ Add footsteps to grass
+ */
+ if(footprints)
{
- v3s16 blockpos(x,y,z);
- MapBlock *block = m_map->getBlockNoCreateNoEx(blockpos);
- if(block==NULL)
- continue;
- // Ignore if no stored objects (to not set changed flag)
- if(block->m_static_objects.m_stored.size() == 0)
- continue;
- // This will contain the leftovers of the stored list
- core::list<StaticObject> new_stored;
- // Loop through stored static objects
- for(core::list<StaticObject>::Iterator
- i = block->m_static_objects.m_stored.begin();
- i != block->m_static_objects.m_stored.end(); i++)
- {
- /*dstream<<"INFO: Server: Creating an active object from "
- <<"static data"<<std::endl;*/
- StaticObject &s_obj = *i;
- // Create an active object from the data
- ServerActiveObject *obj = ServerActiveObject::create
- (s_obj.type, this, 0, s_obj.pos, s_obj.data);
- if(obj==NULL)
+ // Get node that is at BS/4 under player
+ v3s16 bottompos = floatToInt(playerpos + v3f(0,-BS/4,0), BS);
+ try{
+ MapNode n = m_map->getNode(bottompos);
+ if(n.getContent() == CONTENT_GRASS)
{
- // This is necessary to preserve stuff during bugs
- // and errors
- new_stored.push_back(s_obj);
- continue;
+ n.setContent(CONTENT_GRASS_FOOTSTEPS);
+ m_map->setNode(bottompos, n);
}
- // This will also add the object to the active static list
- addActiveObject(obj);
- //u16 id = addActiveObject(obj);
}
- // Clear stored list
- block->m_static_objects.m_stored.clear();
- // Add leftover stuff to stored list
- for(core::list<StaticObject>::Iterator
- i = new_stored.begin();
- i != new_stored.end(); i++)
+ catch(InvalidPositionException &e)
{
- StaticObject &s_obj = *i;
- block->m_static_objects.m_stored.push_back(s_obj);
}
- block->setChangedFlag();
}
}
+ }
+ /*
+ Manage active block list
+ */
+ if(m_active_blocks_management_interval.step(dtime, 2.0))
+ {
+ ScopeProfiler sp(g_profiler, "SEnv: manage act. block list avg /2s", SPT_AVG);
/*
- Convert objects that are far away from all the players to static.
+ Get player block positions
*/
+ core::list<v3s16> players_blockpos;
+ for(core::list<Player*>::Iterator
+ i = m_players.begin();
+ i != m_players.end(); i++)
+ {
+ Player *player = *i;
+ // Ignore disconnected players
+ if(player->peer_id == 0)
+ continue;
+ v3s16 blockpos = getNodeBlockPos(
+ floatToInt(player->getPosition(), BS));
+ players_blockpos.push_back(blockpos);
+ }
+
+ /*
+ Update list of active blocks, collecting changes
+ */
+ const s16 active_block_range = g_settings->getS16("active_block_range");
+ core::map<v3s16, bool> blocks_removed;
+ core::map<v3s16, bool> blocks_added;
+ m_active_blocks.update(players_blockpos, active_block_range,
+ blocks_removed, blocks_added);
+
+ /*
+ Handle removed blocks
+ */
+
+ // Convert active objects that are no more in active blocks to static
+ deactivateFarObjects(false);
+
+ for(core::map<v3s16, bool>::Iterator
+ i = blocks_removed.getIterator();
+ i.atEnd()==false; i++)
{
- core::list<u16> objects_to_remove;
- for(core::map<u16, ServerActiveObject*>::Iterator
- i = m_active_objects.getIterator();
- i.atEnd()==false; i++)
+ v3s16 p = i.getNode()->getKey();
+
+ /*infostream<<"Server: Block ("<<p.X<<","<<p.Y<<","<<p.Z
+ <<") became inactive"<<std::endl;*/
+
+ MapBlock *block = m_map->getBlockNoCreateNoEx(p);
+ if(block==NULL)
+ continue;
+
+ // Set current time as timestamp (and let it set ChangedFlag)
+ block->setTimestamp(m_game_time);
+ }
+
+ /*
+ Handle added blocks
+ */
+
+ for(core::map<v3s16, bool>::Iterator
+ i = blocks_added.getIterator();
+ i.atEnd()==false; i++)
+ {
+ v3s16 p = i.getNode()->getKey();
+
+ /*infostream<<"Server: Block ("<<p.X<<","<<p.Y<<","<<p.Z
+ <<") became active"<<std::endl;*/
+
+ MapBlock *block = m_map->getBlockNoCreateNoEx(p);
+ if(block==NULL)
+ continue;
+
+ activateBlock(block);
+ }
+ }
+
+ /*
+ Mess around in active blocks
+ */
+ if(m_active_blocks_nodemetadata_interval.step(dtime, 1.0))
+ {
+ ScopeProfiler sp(g_profiler, "SEnv: mess in act. blocks avg /1s", SPT_AVG);
+
+ float dtime = 1.0;
+
+ for(core::map<v3s16, bool>::Iterator
+ i = m_active_blocks.m_list.getIterator();
+ i.atEnd()==false; i++)
+ {
+ v3s16 p = i.getNode()->getKey();
+
+ /*infostream<<"Server: Block ("<<p.X<<","<<p.Y<<","<<p.Z
+ <<") being handled"<<std::endl;*/
+
+ MapBlock *block = m_map->getBlockNoCreateNoEx(p);
+ if(block==NULL)
+ continue;
+
+ // Reset block usage timer
+ block->resetUsageTimer();
+
+ // Set current time as timestamp
+ block->setTimestampNoChangedFlag(m_game_time);
+
+ // Run node metadata
+ bool changed = block->m_node_metadata->step(dtime);
+ if(changed)
{
- ServerActiveObject* obj = i.getNode()->getValue();
- u16 id = i.getNode()->getKey();
- v3f objectpos = obj->getBasePosition();
+ MapEditEvent event;
+ event.type = MEET_BLOCK_NODE_METADATA_CHANGED;
+ event.p = p;
+ m_map->dispatchEvent(&event);
- // This shouldn't happen but check it
- if(obj == NULL)
- {
- dstream<<"WARNING: NULL object found in ServerEnvironment"
- <<std::endl;
- continue;
- }
- // If known by some client, don't convert to static.
- if(obj->m_known_by_count > 0)
+ block->setChangedFlag();
+ }
+ }
+ }
+
+ if(m_active_blocks_test_interval.step(dtime, 10.0))
+ {
+ ScopeProfiler sp(g_profiler, "SEnv: modify in blocks avg /10s", SPT_AVG);
+ //float dtime = 10.0;
+
+ for(core::map<v3s16, bool>::Iterator
+ i = m_active_blocks.m_list.getIterator();
+ i.atEnd()==false; i++)
+ {
+ v3s16 p = i.getNode()->getKey();
+
+ /*infostream<<"Server: Block ("<<p.X<<","<<p.Y<<","<<p.Z
+ <<") being handled"<<std::endl;*/
+
+ MapBlock *block = m_map->getBlockNoCreateNoEx(p);
+ if(block==NULL)
+ continue;
+
+ // Set current time as timestamp
+ block->setTimestampNoChangedFlag(m_game_time);
+
+ /*
+ Do stuff!
+
+ Note that map modifications should be done using the event-
+ making map methods so that the server gets information
+ about them.
+
+ Reading can be done quickly directly from the block.
+
+ Everything should bind to inside this single content
+ searching loop to keep things fast.
+ */
+ // TODO: Implement usage of ActiveBlockModifier
+
+ // Find out how many objects the block contains
+ //u32 active_object_count = block->m_static_objects.m_active.size();
+ // Find out how many objects this and all the neighbors contain
+ u32 active_object_count_wider = 0;
+ for(s16 x=-1; x<=1; x++)
+ for(s16 y=-1; y<=1; y++)
+ for(s16 z=-1; z<=1; z++)
+ {
+ MapBlock *block = m_map->getBlockNoCreateNoEx(p+v3s16(x,y,z));
+ if(block==NULL)
continue;
+ active_object_count_wider +=
+ block->m_static_objects.m_active.size()
+ + block->m_static_objects.m_stored.size();
+
+ /*if(block->m_static_objects.m_stored.size() != 0){
+ errorstream<<"ServerEnvironment::step(): "
+ <<PP(block->getPos())<<" contains "
+ <<block->m_static_objects.m_stored.size()
+ <<" stored objects; "
+ <<"when spawning objects, when counting active "
+ <<"objects in wide area. relative position: "
+ <<"("<<x<<","<<y<<","<<z<<")"<<std::endl;
+ }*/
+ }
+
+ v3s16 p0;
+ for(p0.X=0; p0.X<MAP_BLOCKSIZE; p0.X++)
+ for(p0.Y=0; p0.Y<MAP_BLOCKSIZE; p0.Y++)
+ for(p0.Z=0; p0.Z<MAP_BLOCKSIZE; p0.Z++)
+ {
+ v3s16 p = p0 + block->getPosRelative();
+ MapNode n = block->getNodeNoEx(p0);
- // If close to some player, don't convert to static.
- bool close_to_player = false;
- for(core::list<Player*>::Iterator i = m_players.begin();
- i != m_players.end(); i++)
+ /*
+ Test something:
+ Convert mud under proper lighting to grass
+ */
+ if(n.getContent() == CONTENT_MUD)
{
- Player *player = *i;
-
- // Ignore disconnected players
- if(player->peer_id == 0)
- continue;
-
- v3f playerpos = player->getPosition();
- f32 d = playerpos.getDistanceFrom(objectpos);
- if(d < to_static_max_f)
+ if(myrand()%20 == 0)
{
- close_to_player = true;
- break;
+ MapNode n_top = m_map->getNodeNoEx(p+v3s16(0,1,0));
+ if(content_features(n_top).air_equivalent &&
+ n_top.getLightBlend(getDayNightRatio()) >= 13)
+ {
+ n.setContent(CONTENT_GRASS);
+ m_map->addNodeWithEvent(p, n);
+ }
}
}
-
- if(close_to_player)
- continue;
-
/*
- Update the static data and remove the active object.
+ Convert grass into mud if under something else than air
*/
-
- // Delete old static object
- MapBlock *oldblock = NULL;
- if(obj->m_static_exists)
+ if(n.getContent() == CONTENT_GRASS)
{
- MapBlock *block = m_map->getBlockNoCreateNoEx
- (obj->m_static_block);
- if(block)
+ //if(myrand()%20 == 0)
{
- block->m_static_objects.remove(id);
- oldblock = block;
+ MapNode n_top = m_map->getNodeNoEx(p+v3s16(0,1,0));
+ if(content_features(n_top).air_equivalent == false)
+ {
+ n.setContent(CONTENT_MUD);
+ m_map->addNodeWithEvent(p, n);
+ }
}
}
- // Add new static object
- std::string staticdata = obj->getStaticData();
- StaticObject s_obj(obj->getType(), objectpos, staticdata);
- // Add to the block where the object is located in
- v3s16 blockpos = getNodeBlockPos(floatToInt(objectpos, BS));
- MapBlock *block = m_map->getBlockNoCreateNoEx(blockpos);
- if(block)
+ /*
+ Rats spawn around regular trees
+ */
+ if(n.getContent() == CONTENT_TREE ||
+ n.getContent() == CONTENT_JUNGLETREE)
{
- block->m_static_objects.insert(0, s_obj);
- block->setChangedFlag();
- obj->m_static_exists = true;
- obj->m_static_block = block->getPos();
+ if(myrand()%200 == 0 && active_object_count_wider == 0)
+ {
+ v3s16 p1 = p + v3s16(myrand_range(-2, 2),
+ 0, myrand_range(-2, 2));
+ MapNode n1 = m_map->getNodeNoEx(p1);
+ MapNode n1b = m_map->getNodeNoEx(p1+v3s16(0,-1,0));
+ if(n1b.getContent() == CONTENT_GRASS &&
+ n1.getContent() == CONTENT_AIR)
+ {
+ v3f pos = intToFloat(p1, BS);
+ ServerActiveObject *obj = new RatSAO(this, pos);
+ addActiveObject(obj);
+ }
+ }
}
- // If not possible, add back to previous block
- else if(oldblock)
+ /*
+ Fun things spawn in caves and dungeons
+ */
+ if(n.getContent() == CONTENT_STONE ||
+ n.getContent() == CONTENT_MOSSYCOBBLE)
{
- oldblock->m_static_objects.insert(0, s_obj);
- oldblock->setChangedFlag();
- obj->m_static_exists = true;
- obj->m_static_block = oldblock->getPos();
+ if(myrand()%200 == 0 && active_object_count_wider == 0)
+ {
+ v3s16 p1 = p + v3s16(0,1,0);
+ MapNode n1a = m_map->getNodeNoEx(p1+v3s16(0,0,0));
+ if(n1a.getLightBlend(getDayNightRatio()) <= 3){
+ MapNode n1b = m_map->getNodeNoEx(p1+v3s16(0,1,0));
+ if(n1a.getContent() == CONTENT_AIR &&
+ n1b.getContent() == CONTENT_AIR)
+ {
+ v3f pos = intToFloat(p1, BS);
+ int i = myrand()%5;
+ if(i == 0 || i == 1){
+ actionstream<<"A dungeon master spawns at "
+ <<PP(p1)<<std::endl;
+ Settings properties;
+ getMob_dungeon_master(properties);
+ ServerActiveObject *obj = new MobV2SAO(
+ this, pos, &properties);
+ addActiveObject(obj);
+ } else if(i == 2 || i == 3){
+ actionstream<<"Rats spawn at "
+ <<PP(p1)<<std::endl;
+ for(int j=0; j<3; j++){
+ ServerActiveObject *obj = new RatSAO(
+ this, pos);
+ addActiveObject(obj);
+ }
+ } else {
+ actionstream<<"An oerkki spawns at "
+ <<PP(p1)<<std::endl;
+ ServerActiveObject *obj = new Oerkki1SAO(
+ this, pos);
+ addActiveObject(obj);
+ }
+ }
+ }
+ }
}
- else{
- dstream<<"WARNING: Server: Could not find a block for "
- <<"storing static object"<<std::endl;
- obj->m_static_exists = false;
- continue;
+ /*
+ Make trees from saplings!
+ */
+ if(n.getContent() == CONTENT_SAPLING)
+ {
+ if(myrand()%50 == 0)
+ {
+ actionstream<<"A sapling grows into a tree at "
+ <<PP(p)<<std::endl;
+
+ core::map<v3s16, MapBlock*> modified_blocks;
+ v3s16 tree_p = p;
+ ManualMapVoxelManipulator vmanip(m_map);
+ v3s16 tree_blockp = getNodeBlockPos(tree_p);
+ vmanip.initialEmerge(tree_blockp - v3s16(1,1,1), tree_blockp + v3s16(1,1,1));
+ bool is_apple_tree = myrand()%4 == 0;
+ mapgen::make_tree(vmanip, tree_p, is_apple_tree);
+ vmanip.blitBackAll(&modified_blocks);
+
+ // update lighting
+ core::map<v3s16, MapBlock*> lighting_modified_blocks;
+ for(core::map<v3s16, MapBlock*>::Iterator
+ i = modified_blocks.getIterator();
+ i.atEnd() == false; i++)
+ {
+ lighting_modified_blocks.insert(i.getNode()->getKey(), i.getNode()->getValue());
+ }
+ m_map->updateLighting(lighting_modified_blocks, modified_blocks);
+
+ // Send a MEET_OTHER event
+ MapEditEvent event;
+ event.type = MEET_OTHER;
+ for(core::map<v3s16, MapBlock*>::Iterator
+ i = modified_blocks.getIterator();
+ i.atEnd() == false; i++)
+ {
+ v3s16 p = i.getNode()->getKey();
+ event.modified_blocks.insert(p, true);
+ }
+ m_map->dispatchEvent(&event);
+ }
}
- /*dstream<<"INFO: Server: Stored static data. Deleting object."
- <<std::endl;*/
- // Delete active object
- delete obj;
- // Id to be removed from m_active_objects
- objects_to_remove.push_back(id);
}
- // Remove references from m_active_objects
- for(core::list<u16>::Iterator i = objects_to_remove.begin();
- i != objects_to_remove.end(); i++)
+ }
+ }
+
+ /*
+ Step script environment (run global on_step())
+ */
+ scriptapi_environment_step(m_lua, dtime);
+
+ /*
+ Step active objects
+ */
+ {
+ ScopeProfiler sp(g_profiler, "SEnv: step act. objs avg", SPT_AVG);
+ //TimeTaker timer("Step active objects");
+
+ g_profiler->avg("SEnv: num of objects", m_active_objects.size());
+
+ // This helps the objects to send data at the same time
+ bool send_recommended = false;
+ m_send_recommended_timer += dtime;
+ if(m_send_recommended_timer > getSendRecommendedInterval())
+ {
+ m_send_recommended_timer -= getSendRecommendedInterval();
+ send_recommended = true;
+ }
+
+ for(core::map<u16, ServerActiveObject*>::Iterator
+ i = m_active_objects.getIterator();
+ i.atEnd()==false; i++)
+ {
+ ServerActiveObject* obj = i.getNode()->getValue();
+ // Remove non-peaceful mobs on peaceful mode
+ if(g_settings->getBool("only_peaceful_mobs")){
+ if(!obj->isPeaceful())
+ obj->m_removed = true;
+ }
+ // Don't step if is to be removed or stored statically
+ if(obj->m_removed || obj->m_pending_deactivation)
+ continue;
+ // Step object
+ obj->step(dtime, send_recommended);
+ // Read messages from object
+ while(obj->m_messages_out.size() > 0)
{
- m_active_objects.remove(*i);
+ m_active_object_messages.push_back(
+ obj->m_messages_out.pop_front());
}
}
}
+
+ /*
+ Manage active objects
+ */
+ if(m_object_management_interval.step(dtime, 0.5))
+ {
+ ScopeProfiler sp(g_profiler, "SEnv: remove removed objs avg /.5s", SPT_AVG);
+ /*
+ Remove objects that satisfy (m_removed && m_known_by_count==0)
+ */
+ removeRemovedObjects();
+ }
- if(g_settings.getBool("enable_experimental"))
+ if(g_settings->getBool("enable_experimental"))
{
/*
TEST CODE
*/
-#if 1
+#if 0
m_random_spawn_timer -= dtime;
if(m_random_spawn_timer < 0)
{
pos = player->getPosition();
pos += v3f(
myrand_range(-3,3)*BS,
- 0,
+ 5,
myrand_range(-3,3)*BS
);
Create a ServerActiveObject
*/
- //TestSAO *obj = new TestSAO(this, 0, pos);
- //ServerActiveObject *obj = new ItemSAO(this, 0, pos, "CraftItem Stick 1");
- ServerActiveObject *obj = new RatSAO(this, 0, pos);
+ //TestSAO *obj = new TestSAO(this, pos);
+ //ServerActiveObject *obj = new ItemSAO(this, pos, "CraftItem Stick 1");
+ //ServerActiveObject *obj = new RatSAO(this, pos);
+ //ServerActiveObject *obj = new Oerkki1SAO(this, pos);
+ //ServerActiveObject *obj = new FireflySAO(this, pos);
+
+ infostream<<"Server: Spawning MobV2SAO at "
+ <<"("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"<<std::endl;
+
+ Settings properties;
+ getMob_dungeon_master(properties);
+ ServerActiveObject *obj = new MobV2SAO(this, pos, &properties);
addActiveObject(obj);
}
#endif
u16 ServerEnvironment::addActiveObject(ServerActiveObject *object)
{
assert(object);
- if(object->getId() == 0)
- {
- u16 new_id = getFreeServerActiveObjectId(m_active_objects);
- if(new_id == 0)
- {
- dstream<<"WARNING: ServerEnvironment::addActiveObject(): "
- <<"no free ids available"<<std::endl;
- delete object;
- return 0;
- }
- object->setId(new_id);
- }
- if(isFreeServerActiveObjectId(object->getId(), m_active_objects) == false)
- {
- dstream<<"WARNING: ServerEnvironment::addActiveObject(): "
- <<"id is not free ("<<object->getId()<<")"<<std::endl;
- delete object;
- return 0;
- }
- /*dstream<<"INGO: ServerEnvironment::addActiveObject(): "
- <<"added (id="<<object->getId()<<")"<<std::endl;*/
-
- m_active_objects.insert(object->getId(), object);
+ u16 id = addActiveObjectRaw(object, true);
+ return id;
+}
- // Add static object to active static list of the block
- v3f objectpos = object->getBasePosition();
- std::string staticdata = object->getStaticData();
- StaticObject s_obj(object->getType(), objectpos, staticdata);
+bool ServerEnvironment::addActiveObjectAsStatic(ServerActiveObject *obj)
+{
+ assert(obj);
+
+ v3f objectpos = obj->getBasePosition();
+
+ // The block in which the object resides in
+ v3s16 blockpos_o = getNodeBlockPos(floatToInt(objectpos, BS));
+
+ /*
+ Update the static data
+ */
+
+ // Create new static object
+ std::string staticdata = obj->getStaticData();
+ StaticObject s_obj(obj->getType(), objectpos, staticdata);
// Add to the block where the object is located in
v3s16 blockpos = getNodeBlockPos(floatToInt(objectpos, BS));
- MapBlock *block = m_map->getBlockNoCreateNoEx(blockpos);
+ // Get or generate the block
+ MapBlock *block = m_map->emergeBlock(blockpos);
+
+ bool succeeded = false;
+
if(block)
{
- block->m_static_objects.m_active.insert(object->getId(), s_obj);
- object->m_static_exists = true;
- object->m_static_block = blockpos;
+ block->m_static_objects.insert(0, s_obj);
+ block->raiseModified(MOD_STATE_WRITE_AT_UNLOAD);
+ succeeded = true;
}
else{
- dstream<<"WARNING: Server: Could not find a block for "
- <<"storing newly added static active object"<<std::endl;
+ infostream<<"ServerEnvironment::addActiveObjectAsStatic: "
+ <<"Could not find or generate "
+ <<"a block for storing static object"<<std::endl;
+ succeeded = false;
}
- return object->getId();
+ delete obj;
+
+ return succeeded;
}
/*
ServerActiveObject *object = getActiveObject(id);
if(object == NULL)
{
- dstream<<"WARNING: ServerEnvironment::getRemovedActiveObjects():"
+ infostream<<"ServerEnvironment::getRemovedActiveObjects():"
<<" object in current_objects is NULL"<<std::endl;
}
else if(object->m_removed == false)
{
f32 distance_f = object->getBasePosition().getDistanceFrom(pos_f);
- /*dstream<<"removed == false"
+ /*infostream<<"removed == false"
<<"distance_f = "<<distance_f
<<", radius_f = "<<radius_f<<std::endl;*/
if(distance_f < radius_f)
return m_active_object_messages.pop_front();
}
+/*
+ ************ Private methods *************
+*/
+
+u16 ServerEnvironment::addActiveObjectRaw(ServerActiveObject *object,
+ bool set_changed)
+{
+ assert(object);
+ if(object->getId() == 0){
+ u16 new_id = getFreeServerActiveObjectId(m_active_objects);
+ if(new_id == 0)
+ {
+ errorstream<<"ServerEnvironment::addActiveObjectRaw(): "
+ <<"no free ids available"<<std::endl;
+ delete object;
+ return 0;
+ }
+ object->setId(new_id);
+ }
+ else{
+ verbosestream<<"ServerEnvironment::addActiveObjectRaw(): "
+ <<"supplied with id "<<object->getId()<<std::endl;
+ }
+ if(isFreeServerActiveObjectId(object->getId(), m_active_objects) == false)
+ {
+ errorstream<<"ServerEnvironment::addActiveObjectRaw(): "
+ <<"id is not free ("<<object->getId()<<")"<<std::endl;
+ delete object;
+ return 0;
+ }
+ /*infostream<<"ServerEnvironment::addActiveObjectRaw(): "
+ <<"added (id="<<object->getId()<<")"<<std::endl;*/
+
+ m_active_objects.insert(object->getId(), object);
+
+ verbosestream<<"ServerEnvironment::addActiveObjectRaw(): "
+ <<"Added id="<<object->getId()<<"; there are now "
+ <<m_active_objects.size()<<" active objects."
+ <<std::endl;
+
+ // Add static object to active static list of the block
+ v3f objectpos = object->getBasePosition();
+ std::string staticdata = object->getStaticData();
+ StaticObject s_obj(object->getType(), objectpos, staticdata);
+ // Add to the block where the object is located in
+ v3s16 blockpos = getNodeBlockPos(floatToInt(objectpos, BS));
+ MapBlock *block = m_map->getBlockNoCreateNoEx(blockpos);
+ if(block)
+ {
+ block->m_static_objects.m_active.insert(object->getId(), s_obj);
+ object->m_static_exists = true;
+ object->m_static_block = blockpos;
+
+ if(set_changed)
+ block->raiseModified(MOD_STATE_WRITE_NEEDED);
+ }
+ else{
+ errorstream<<"ServerEnvironment::addActiveObjectRaw(): "
+ <<"could not find block for storing id="<<object->getId()
+ <<" statically"<<std::endl;
+ }
+
+ // Register reference in scripting api (must be done before post-init)
+ scriptapi_add_object_reference(m_lua, object);
+ // Post-initialize object
+ object->addedToEnvironment(object->getId());
+
+ return object->getId();
+}
+
+/*
+ Remove objects that satisfy (m_removed && m_known_by_count==0)
+*/
+void ServerEnvironment::removeRemovedObjects()
+{
+ core::list<u16> objects_to_remove;
+ for(core::map<u16, ServerActiveObject*>::Iterator
+ i = m_active_objects.getIterator();
+ i.atEnd()==false; i++)
+ {
+ u16 id = i.getNode()->getKey();
+ ServerActiveObject* obj = i.getNode()->getValue();
+ // This shouldn't happen but check it
+ if(obj == NULL)
+ {
+ infostream<<"NULL object found in ServerEnvironment"
+ <<" while finding removed objects. id="<<id<<std::endl;
+ // Id to be removed from m_active_objects
+ objects_to_remove.push_back(id);
+ continue;
+ }
+
+ /*
+ We will delete objects that are marked as removed or thatare
+ waiting for deletion after deactivation
+ */
+ if(obj->m_removed == false && obj->m_pending_deactivation == false)
+ continue;
+
+ /*
+ Delete static data from block if is marked as removed
+ */
+ if(obj->m_static_exists && obj->m_removed)
+ {
+ MapBlock *block = m_map->emergeBlock(obj->m_static_block);
+ if(block)
+ {
+ block->m_static_objects.remove(id);
+ block->raiseModified(MOD_STATE_WRITE_NEEDED);
+ obj->m_static_exists = false;
+ }
+ }
+
+ // If m_known_by_count > 0, don't actually remove.
+ if(obj->m_known_by_count > 0)
+ continue;
+
+ // Deregister in scripting api
+ scriptapi_rm_object_reference(m_lua, obj);
+
+ // Delete
+ delete obj;
+ // Id to be removed from m_active_objects
+ objects_to_remove.push_back(id);
+ }
+ // Remove references from m_active_objects
+ for(core::list<u16>::Iterator i = objects_to_remove.begin();
+ i != objects_to_remove.end(); i++)
+ {
+ m_active_objects.remove(*i);
+ }
+}
+
+static void print_hexdump(std::ostream &o, const std::string &data)
+{
+ const int linelength = 16;
+ for(int l=0; ; l++){
+ int i0 = linelength * l;
+ bool at_end = false;
+ int thislinelength = linelength;
+ if(i0 + thislinelength > (int)data.size()){
+ thislinelength = data.size() - i0;
+ at_end = true;
+ }
+ for(int di=0; di<linelength; di++){
+ int i = i0 + di;
+ char buf[4];
+ if(di<thislinelength)
+ snprintf(buf, 4, "%.2x ", data[i]);
+ else
+ snprintf(buf, 4, " ");
+ o<<buf;
+ }
+ o<<" ";
+ for(int di=0; di<thislinelength; di++){
+ int i = i0 + di;
+ if(data[i] >= 32)
+ o<<data[i];
+ else
+ o<<".";
+ }
+ o<<std::endl;
+ if(at_end)
+ break;
+ }
+}
+
+/*
+ Convert stored objects from blocks near the players to active.
+*/
+void ServerEnvironment::activateObjects(MapBlock *block)
+{
+ if(block==NULL)
+ return;
+ // Ignore if no stored objects (to not set changed flag)
+ if(block->m_static_objects.m_stored.size() == 0)
+ return;
+ verbosestream<<"ServerEnvironment::activateObjects(): "
+ <<"activating objects of block "<<PP(block->getPos())
+ <<" ("<<block->m_static_objects.m_stored.size()
+ <<" objects)"<<std::endl;
+ bool large_amount = (block->m_static_objects.m_stored.size() > 49);
+ if(large_amount){
+ errorstream<<"suspiciously large amount of objects detected: "
+ <<block->m_static_objects.m_stored.size()<<" in "
+ <<PP(block->getPos())
+ <<"; removing all of them."<<std::endl;
+ // Clear stored list
+ block->m_static_objects.m_stored.clear();
+ block->raiseModified(MOD_STATE_WRITE_NEEDED);
+ return;
+ }
+ // A list for objects that couldn't be converted to static for some
+ // reason. They will be stored back.
+ core::list<StaticObject> new_stored;
+ // Loop through stored static objects
+ for(core::list<StaticObject>::Iterator
+ i = block->m_static_objects.m_stored.begin();
+ i != block->m_static_objects.m_stored.end(); i++)
+ {
+ /*infostream<<"Server: Creating an active object from "
+ <<"static data"<<std::endl;*/
+ StaticObject &s_obj = *i;
+ // Create an active object from the data
+ ServerActiveObject *obj = ServerActiveObject::create
+ (s_obj.type, this, 0, s_obj.pos, s_obj.data);
+ // If couldn't create object, store static data back.
+ if(obj==NULL)
+ {
+ errorstream<<"ServerEnvironment::activateObjects(): "
+ <<"failed to create active object from static object "
+ <<"in block "<<PP(s_obj.pos/BS)
+ <<" type="<<(int)s_obj.type<<" data:"<<std::endl;
+ print_hexdump(verbosestream, s_obj.data);
+
+ new_stored.push_back(s_obj);
+ continue;
+ }
+ verbosestream<<"ServerEnvironment::activateObjects(): "
+ <<"activated static object pos="<<PP(s_obj.pos/BS)
+ <<" type="<<(int)s_obj.type<<std::endl;
+ // This will also add the object to the active static list
+ addActiveObjectRaw(obj, false);
+ }
+ // Clear stored list
+ block->m_static_objects.m_stored.clear();
+ // Add leftover failed stuff to stored list
+ for(core::list<StaticObject>::Iterator
+ i = new_stored.begin();
+ i != new_stored.end(); i++)
+ {
+ StaticObject &s_obj = *i;
+ block->m_static_objects.m_stored.push_back(s_obj);
+ }
+ /*
+ Note: Block hasn't really been modified here.
+ The objects have just been activated and moved from the stored
+ static list to the active static list.
+ As such, the block is essentially the same.
+ Thus, do not call block->setChangedFlag().
+ Otherwise there would be a huge amount of unnecessary I/O.
+ */
+}
+
+/*
+ Convert objects that are not standing inside active blocks to static.
+
+ If m_known_by_count != 0, active object is not deleted, but static
+ data is still updated.
+
+ If force_delete is set, active object is deleted nevertheless. It
+ shall only be set so in the destructor of the environment.
+*/
+void ServerEnvironment::deactivateFarObjects(bool force_delete)
+{
+ core::list<u16> objects_to_remove;
+ for(core::map<u16, ServerActiveObject*>::Iterator
+ i = m_active_objects.getIterator();
+ i.atEnd()==false; i++)
+ {
+ ServerActiveObject* obj = i.getNode()->getValue();
+
+ // This shouldn't happen but check it
+ if(obj == NULL)
+ {
+ errorstream<<"NULL object found in ServerEnvironment"
+ <<std::endl;
+ assert(0);
+ continue;
+ }
+
+ // If pending deactivation, let removeRemovedObjects() do it
+ if(obj->m_pending_deactivation)
+ continue;
+
+ u16 id = i.getNode()->getKey();
+ v3f objectpos = obj->getBasePosition();
+
+ // The block in which the object resides in
+ v3s16 blockpos_o = getNodeBlockPos(floatToInt(objectpos, BS));
+
+ // If block is active, don't remove
+ if(m_active_blocks.contains(blockpos_o))
+ continue;
+
+ verbosestream<<"ServerEnvironment::deactivateFarObjects(): "
+ <<"deactivating object id="<<id<<" on inactive block "
+ <<PP(blockpos_o)<<std::endl;
+
+ // If known by some client, don't immediately delete.
+ bool pending_delete = (obj->m_known_by_count > 0 && !force_delete);
+
+ /*
+ Update the static data
+ */
+
+ // Create new static object
+ std::string staticdata_new = obj->getStaticData();
+ StaticObject s_obj(obj->getType(), objectpos, staticdata_new);
+
+ bool stays_in_same_block = false;
+ bool data_changed = true;
+
+ if(obj->m_static_exists){
+ if(obj->m_static_block == blockpos_o)
+ stays_in_same_block = true;
+
+ MapBlock *block = m_map->emergeBlock(obj->m_static_block, false);
+
+ core::map<u16, StaticObject>::Node *n =
+ block->m_static_objects.m_active.find(id);
+ if(n){
+ StaticObject static_old = n->getValue();
+
+ float save_movem = obj->getMinimumSavedMovement();
+
+ if(static_old.data == staticdata_new &&
+ (static_old.pos - objectpos).getLength() < save_movem)
+ data_changed = false;
+ } else {
+ errorstream<<"ServerEnvironment::deactivateFarObjects(): "
+ <<"id="<<id<<" m_static_exists=true but "
+ <<"static data doesn't actually exist in "
+ <<PP(obj->m_static_block)<<std::endl;
+ }
+ }
+
+ bool shall_be_written = (!stays_in_same_block || data_changed);
+
+ // Delete old static object
+ if(obj->m_static_exists)
+ {
+ MapBlock *block = m_map->emergeBlock(obj->m_static_block, false);
+ if(block)
+ {
+ block->m_static_objects.remove(id);
+ obj->m_static_exists = false;
+ // Only mark block as modified if data changed considerably
+ if(shall_be_written)
+ block->raiseModified(MOD_STATE_WRITE_NEEDED);
+ }
+ }
+
+ // Add to the block where the object is located in
+ v3s16 blockpos = getNodeBlockPos(floatToInt(objectpos, BS));
+ // Get or generate the block
+ MapBlock *block = m_map->emergeBlock(blockpos);
+
+ if(block)
+ {
+ if(block->m_static_objects.m_stored.size() >= 49){
+ errorstream<<"ServerEnv: Trying to store id="<<obj->getId()
+ <<" statically but block "<<PP(blockpos)
+ <<" already contains "
+ <<block->m_static_objects.m_stored.size()
+ <<" (over 49) objects."
+ <<" Forcing delete."<<std::endl;
+ force_delete = true;
+ } else {
+ u16 new_id = pending_delete ? id : 0;
+ block->m_static_objects.insert(new_id, s_obj);
+
+ // Only mark block as modified if data changed considerably
+ if(shall_be_written)
+ block->raiseModified(MOD_STATE_WRITE_NEEDED);
+
+ obj->m_static_exists = true;
+ obj->m_static_block = block->getPos();
+ }
+ }
+ else{
+ errorstream<<"ServerEnv: Could not find or generate "
+ <<"a block for storing id="<<obj->getId()
+ <<" statically"<<std::endl;
+ continue;
+ }
+
+ /*
+ If known by some client, set pending deactivation.
+ Otherwise delete it immediately.
+ */
+
+ if(pending_delete)
+ {
+ verbosestream<<"ServerEnvironment::deactivateFarObjects(): "
+ <<"object id="<<id<<" is known by clients"
+ <<"; not deleting yet"<<std::endl;
+
+ obj->m_pending_deactivation = true;
+ continue;
+ }
+
+ verbosestream<<"ServerEnvironment::deactivateFarObjects(): "
+ <<"object id="<<id<<" is not known by clients"
+ <<"; deleting"<<std::endl;
+
+ // Deregister in scripting api
+ scriptapi_rm_object_reference(m_lua, obj);
+
+ // Delete active object
+ delete obj;
+ // Id to be removed from m_active_objects
+ objects_to_remove.push_back(id);
+ }
+
+ // Remove references from m_active_objects
+ for(core::list<u16>::Iterator i = objects_to_remove.begin();
+ i != objects_to_remove.end(); i++)
+ {
+ m_active_objects.remove(*i);
+ }
+}
+
+
#ifndef SERVER
/*
DSTACK(__FUNCTION_NAME);
// Get some settings
- bool free_move = g_settings.getBool("free_move");
- bool footprints = g_settings.getBool("footprints");
-
- {
- //TimeTaker timer("Client m_map->timerUpdate()", g_device);
- m_map->timerUpdate(dtime);
- }
+ bool free_move = g_settings->getBool("free_move");
+ bool footprints = g_settings->getBool("footprints");
+ // Get local player
+ LocalPlayer *lplayer = getLocalPlayer();
+ assert(lplayer);
+ // collision info queue
+ core::list<CollisionInfo> player_collisions;
+
/*
Get the speed the player is going
*/
+ bool is_climbing = lplayer->is_climbing;
+
f32 player_speed = 0.001; // just some small value
- LocalPlayer *lplayer = getLocalPlayer();
- if(lplayer)
- player_speed = lplayer->getSpeed().getLength();
+ player_speed = lplayer->getSpeed().getLength();
/*
Maximum position increment
*/
{
- Player *player = getLocalPlayer();
-
- v3f playerpos = player->getPosition();
+ v3f lplayerpos = lplayer->getPosition();
// Apply physics
- if(free_move == false)
+ if(free_move == false && is_climbing == false)
{
// Gravity
- v3f speed = player->getSpeed();
- if(player->swimming_up == false)
+ v3f speed = lplayer->getSpeed();
+ if(lplayer->swimming_up == false)
speed.Y -= 9.81 * BS * dtime_part * 2;
// Water resistance
- if(player->in_water_stable || player->in_water)
+ if(lplayer->in_water_stable || lplayer->in_water)
{
f32 max_down = 2.0*BS;
if(speed.Y < -max_down) speed.Y = -max_down;
}
}
- player->setSpeed(speed);
+ lplayer->setSpeed(speed);
}
/*
- Move the player.
+ Move the lplayer.
This also does collision detection.
*/
- player->move(dtime_part, *m_map, position_max_increment);
+ lplayer->move(dtime_part, *m_map, position_max_increment,
+ &player_collisions);
}
}
while(dtime_downcount > 0.001);
//std::cout<<"Looped "<<loopcount<<" times."<<std::endl;
+ for(core::list<CollisionInfo>::Iterator
+ i = player_collisions.begin();
+ i != player_collisions.end(); i++)
+ {
+ CollisionInfo &info = *i;
+ if(info.t == COLLISION_FALL)
+ {
+ //f32 tolerance = BS*10; // 2 without damage
+ f32 tolerance = BS*12; // 3 without damage
+ f32 factor = 1;
+ if(info.speed > tolerance)
+ {
+ f32 damage_f = (info.speed - tolerance)/BS*factor;
+ u16 damage = (u16)(damage_f+0.5);
+ if(lplayer->hp > damage)
+ lplayer->hp -= damage;
+ else
+ lplayer->hp = 0;
+
+ ClientEnvEvent event;
+ event.type = CEE_PLAYER_DAMAGE;
+ event.player_damage.amount = damage;
+ m_client_event_queue.push_back(event);
+ }
+ }
+ }
+
+ /*
+ A quick draft of lava damage
+ */
+ if(m_lava_hurt_interval.step(dtime, 1.0))
+ {
+ v3f pf = lplayer->getPosition();
+
+ // Feet, middle and head
+ v3s16 p1 = floatToInt(pf + v3f(0, BS*0.1, 0), BS);
+ MapNode n1 = m_map->getNodeNoEx(p1);
+ v3s16 p2 = floatToInt(pf + v3f(0, BS*0.8, 0), BS);
+ MapNode n2 = m_map->getNodeNoEx(p2);
+ v3s16 p3 = floatToInt(pf + v3f(0, BS*1.6, 0), BS);
+ MapNode n3 = m_map->getNodeNoEx(p2);
+
+ u32 damage_per_second = 0;
+ damage_per_second = MYMAX(damage_per_second,
+ content_features(n1).damage_per_second);
+ damage_per_second = MYMAX(damage_per_second,
+ content_features(n2).damage_per_second);
+ damage_per_second = MYMAX(damage_per_second,
+ content_features(n3).damage_per_second);
+
+ if(damage_per_second != 0)
+ {
+ ClientEnvEvent event;
+ event.type = CEE_PLAYER_DAMAGE;
+ event.player_damage.amount = damage_per_second;
+ m_client_event_queue.push_back(event);
+ }
+ }
+
/*
Stuff that can be done in an arbitarily large dtime
*/
// Move
player->move(dtime, *m_map, 100*BS);
- // Update lighting on remote players on client
- u8 light = LIGHT_MAX;
- try{
- // Get node at head
- v3s16 p = floatToInt(playerpos + v3f(0,BS+BS/2,0), BS);
- MapNode n = m_map->getNode(p);
- light = n.getLightBlend(m_daynight_ratio);
- }
- catch(InvalidPositionException &e) {}
- player->updateLight(light);
}
+ // Update lighting on all players on client
+ u8 light = LIGHT_MAX;
+ try{
+ // Get node at head
+ v3s16 p = player->getLightPosition();
+ MapNode n = m_map->getNode(p);
+ light = n.getLightBlend(getDayNightRatio());
+ }
+ catch(InvalidPositionException &e) {}
+ player->updateLight(light);
+
/*
Add footsteps to grass
*/
v3s16 bottompos = floatToInt(playerpos + v3f(0,-BS/4,0), BS);
try{
MapNode n = m_map->getNode(bottompos);
- if(n.d == CONTENT_GRASS)
+ if(n.getContent() == CONTENT_GRASS)
{
- n.d = CONTENT_GRASS_FOOTSTEPS;
+ n.setContent(CONTENT_GRASS_FOOTSTEPS);
m_map->setNode(bottompos, n);
// Update mesh on client
if(m_map->mapType() == MAPTYPE_CLIENT)
{
v3s16 p_blocks = getNodeBlockPos(bottompos);
MapBlock *b = m_map->getBlockNoCreate(p_blocks);
- //b->updateMesh(m_daynight_ratio);
+ //b->updateMesh(getDayNightRatio());
b->setMeshExpired(true);
}
}
ClientActiveObject* obj = i.getNode()->getValue();
// Step object
obj->step(dtime, this);
- // Update lighting
- //u8 light = LIGHT_MAX;
- u8 light = 0;
- try{
- // Get node at head
- v3s16 p = obj->getLightPosition();
- MapNode n = m_map->getNode(p);
- light = n.getLightBlend(m_daynight_ratio);
+
+ if(m_active_object_light_update_interval.step(dtime, 0.21))
+ {
+ // Update lighting
+ //u8 light = LIGHT_MAX;
+ u8 light = 0;
+ try{
+ // Get node at head
+ v3s16 p = obj->getLightPosition();
+ MapNode n = m_map->getNode(p);
+ light = n.getLightBlend(getDayNightRatio());
+ }
+ catch(InvalidPositionException &e) {}
+ obj->updateLight(light);
}
- catch(InvalidPositionException &e) {}
- obj->updateLight(light);
}
}
void ClientEnvironment::updateMeshes(v3s16 blockpos)
{
- m_map->updateMeshes(blockpos, m_daynight_ratio);
+ m_map->updateMeshes(blockpos, getDayNightRatio());
}
void ClientEnvironment::expireMeshes(bool only_daynight_diffed)
u16 new_id = getFreeClientActiveObjectId(m_active_objects);
if(new_id == 0)
{
- dstream<<"WARNING: ClientEnvironment::addActiveObject(): "
+ infostream<<"ClientEnvironment::addActiveObject(): "
<<"no free ids available"<<std::endl;
delete object;
return 0;
}
if(isFreeClientActiveObjectId(object->getId(), m_active_objects) == false)
{
- dstream<<"WARNING: ClientEnvironment::addActiveObject(): "
+ infostream<<"ClientEnvironment::addActiveObject(): "
<<"id is not free ("<<object->getId()<<")"<<std::endl;
delete object;
return 0;
}
- dstream<<"INGO: ClientEnvironment::addActiveObject(): "
+ infostream<<"ClientEnvironment::addActiveObject(): "
<<"added (id="<<object->getId()<<")"<<std::endl;
m_active_objects.insert(object->getId(), object);
object->addToScene(m_smgr);
ClientActiveObject* obj = ClientActiveObject::create(type);
if(obj == NULL)
{
- dstream<<"WARNING: ClientEnvironment::addActiveObject(): "
+ infostream<<"ClientEnvironment::addActiveObject(): "
<<"id="<<id<<" type="<<type<<": Couldn't create object"
<<std::endl;
return;
obj->setId(id);
- addActiveObject(obj);
-
obj->initialize(init_data);
+
+ addActiveObject(obj);
}
void ClientEnvironment::removeActiveObject(u16 id)
{
- dstream<<"ClientEnvironment::removeActiveObject(): "
+ infostream<<"ClientEnvironment::removeActiveObject(): "
<<"id="<<id<<std::endl;
ClientActiveObject* obj = getActiveObject(id);
if(obj == NULL)
{
- dstream<<"WARNING: ClientEnvironment::removeActiveObject(): "
+ infostream<<"ClientEnvironment::removeActiveObject(): "
<<"id="<<id<<" not found"<<std::endl;
return;
}
ClientActiveObject* obj = getActiveObject(id);
if(obj == NULL)
{
- dstream<<"WARNING: ClientEnvironment::processActiveObjectMessage():"
+ infostream<<"ClientEnvironment::processActiveObjectMessage():"
<<" got message for id="<<id<<", which doesn't exist."
<<std::endl;
return;
obj->processMessage(data);
}
+/*
+ Callbacks for activeobjects
+*/
+
+void ClientEnvironment::damageLocalPlayer(u8 damage)
+{
+ LocalPlayer *lplayer = getLocalPlayer();
+ assert(lplayer);
+
+ if(lplayer->hp > damage)
+ lplayer->hp -= damage;
+ else
+ lplayer->hp = 0;
+
+ ClientEnvEvent event;
+ event.type = CEE_PLAYER_DAMAGE;
+ event.player_damage.amount = damage;
+ m_client_event_queue.push_back(event);
+}
+
+/*
+ Client likes to call these
+*/
+
void ClientEnvironment::getActiveObjects(v3f origin, f32 max_d,
core::array<DistanceSortedActiveObject> &dest)
{
}
}
+ClientEnvEvent ClientEnvironment::getClientEvent()
+{
+ if(m_client_event_queue.size() == 0)
+ {
+ ClientEnvEvent event;
+ event.type = CEE_NONE;
+ return event;
+ }
+ return m_client_event_queue.pop_front();
+}
#endif // #ifndef SERVER
projects / dragonfireclient.git / blobdiff