#include "main.h"
#include "constants.h"
#include "voxel.h"
+#include "materials.h"
+#include "mineral.h"
+
+#define BLOCK_EMERGE_FLAG_FROMDISK (1<<0)
void * ServerThread::Thread()
{
DSTACK(__FUNCTION_NAME);
+ BEGIN_DEBUG_EXCEPTION_HANDLER
+
while(getRun())
{
try{
catch(con::NoIncomingDataException &e)
{
}
-#if CATCH_UNHANDLED_EXCEPTIONS
- /*
- This is what has to be done in threads to get suitable debug info
- */
- catch(std::exception &e)
+ catch(con::PeerNotFoundException &e)
{
- dstream<<std::endl<<DTIME<<"An unhandled exception occurred: "
- <<e.what()<<std::endl;
- assert(0);
+ dout_server<<"Server: PeerNotFoundException"<<std::endl;
}
-#endif
}
+ END_DEBUG_EXCEPTION_HANDLER
return NULL;
}
DSTACK(__FUNCTION_NAME);
bool debug=false;
-#if CATCH_UNHANDLED_EXCEPTIONS
- try
- {
-#endif
+ BEGIN_DEBUG_EXCEPTION_HANDLER
+
/*
Get block info from queue, emerge them and send them
to clients.
//derr_server<<"EmergeThread::Thread(): running"<<std::endl;
- //TimeTaker timer("block emerge", g_device);
+ //TimeTaker timer("block emerge");
/*
Try to emerge it from somewhere.
// Check flags
u8 flags = i.getNode()->getValue();
- if((flags & TOSERVER_GETBLOCK_FLAG_OPTIONAL) == false)
+ if((flags & BLOCK_EMERGE_FLAG_FROMDISK) == false)
optional = false;
}
{//envlock
+ //TimeTaker envlockwaittimer("block emerge envlock wait time");
+
+ // 0-50ms
JMutexAutoLock envlock(m_server->m_env_mutex);
- //TimeTaker timer("block emerge envlock", g_device);
+ //envlockwaittimer.stop();
+
+ //TimeTaker timer("block emerge (while env locked)");
try{
bool only_from_disk = false;
if(optional)
only_from_disk = true;
-
- block = map.emergeBlock(
- p,
- only_from_disk,
- changed_blocks,
- lighting_invalidated_blocks);
+ // First check if the block already exists
+ //block = map.getBlockNoCreate(p);
+
+ if(block == NULL)
+ {
+ //dstream<<"Calling emergeBlock"<<std::endl;
+ block = map.emergeBlock(
+ p,
+ only_from_disk,
+ changed_blocks,
+ lighting_invalidated_blocks);
+
+#if 0
+ /*
+ EXPERIMENTAL: Create a few other blocks too
+ */
+
+ map.emergeBlock(
+ p + v3s16(0,1,0),
+ only_from_disk,
+ changed_blocks,
+ lighting_invalidated_blocks);
+
+ map.emergeBlock(
+ p + v3s16(0,-1,0),
+ only_from_disk,
+ changed_blocks,
+ lighting_invalidated_blocks);
+#if 0
+ map.emergeBlock(
+ p + v3s16(0,2,0),
+ only_from_disk,
+ changed_blocks,
+ lighting_invalidated_blocks);
+
+ map.emergeBlock(
+ p + v3s16(0,-2,0),
+ only_from_disk,
+ changed_blocks,
+ lighting_invalidated_blocks);
+#endif
+#endif
+ }
+
// If it is a dummy, block was not found on disk
if(block->isDummy())
{
//dstream<<"EmergeThread: Got a dummy block"<<std::endl;
got_block = false;
+
+ if(only_from_disk == false)
+ {
+ dstream<<"EmergeThread: wanted to generate a block but got a dummy"<<std::endl;
+ assert(0);
+ }
}
}
catch(InvalidPositionException &e)
dout_server<<std::endl;
}
- /*
- Update water pressure
- */
-
- m_server->UpdateBlockWaterPressure(block, modified_blocks);
-
- for(core::map<v3s16, MapBlock*>::Iterator i = changed_blocks.getIterator();
- i.atEnd() == false; i++)
- {
- MapBlock *block = i.getNode()->getValue();
- m_server->UpdateBlockWaterPressure(block, modified_blocks);
- //v3s16 p = i.getNode()->getKey();
- //m_server->UpdateBlockWaterPressure(p, modified_blocks);
- }
-
/*
Collect a list of blocks that have been modified in
addition to the fetched one.
}
/*dstream<<"lighting "<<lighting_invalidated_blocks.size()
- <<" blocks"<<std::endl;
- TimeTaker timer("** updateLighting", g_device);*/
+ <<" blocks"<<std::endl;*/
+
+ //TimeTaker timer("** updateLighting");
// Update lighting without locking the environment mutex,
// add modified blocks to changed blocks
}
}
-#if CATCH_UNHANDLED_EXCEPTIONS
- }//try
- /*
- This is what has to be done in threads to get suitable debug info
- */
- catch(std::exception &e)
- {
- dstream<<std::endl<<DTIME<<"An unhandled exception occurred: "
- <<e.what()<<std::endl;
- assert(0);
- }
-#endif
+
+ END_DEBUG_EXCEPTION_HANDLER
return NULL;
}
{
DSTACK(__FUNCTION_NAME);
+ // Increment timers
+ {
+ JMutexAutoLock lock(m_blocks_sent_mutex);
+ m_nearest_unsent_reset_timer += dtime;
+ }
+
// Won't send anything if already sending
{
JMutexAutoLock lock(m_blocks_sending_mutex);
Player *player = server->m_env.getPlayer(peer_id);
+ assert(player != NULL);
+
v3f playerpos = player->getPosition();
v3f playerspeed = player->getSpeed();
v3s16 center_nodepos = floatToInt(playerpos);
v3s16 center = getNodeBlockPos(center_nodepos);
+
+ // Camera position and direction
+ v3f camera_pos =
+ playerpos + v3f(0, BS+BS/2, 0);
+ v3f camera_dir = v3f(0,0,1);
+ camera_dir.rotateYZBy(player->getPitch());
+ camera_dir.rotateXZBy(player->getYaw());
/*
Get the starting value of the block finder radius.
m_last_center = center;
}
- static float reset_counter = 0;
- reset_counter += dtime;
- if(reset_counter > 5.0)
+ /*dstream<<"m_nearest_unsent_reset_timer="
+ <<m_nearest_unsent_reset_timer<<std::endl;*/
+ if(m_nearest_unsent_reset_timer > 5.0)
{
- reset_counter = 0;
+ m_nearest_unsent_reset_timer = 0;
m_nearest_unsent_d = 0;
+ //dstream<<"Resetting m_nearest_unsent_d"<<std::endl;
}
last_nearest_unsent_d = m_nearest_unsent_d;
{
SharedPtr<JMutexAutoLock> lock(m_time_from_building.getLock());
m_time_from_building.m_value += dtime;
- if(m_time_from_building.m_value
- < FULL_BLOCK_SEND_ENABLE_MIN_TIME_FROM_BUILDING)
+ /*if(m_time_from_building.m_value
+ < FULL_BLOCK_SEND_ENABLE_MIN_TIME_FROM_BUILDING)*/
+ if(m_time_from_building.m_value < g_settings.getFloat(
+ "full_block_send_enable_min_time_from_building"))
{
maximum_simultaneous_block_sends
= LIMITED_MAX_SIMULTANEOUS_BLOCK_SENDS;
}
}
+
+ u32 num_blocks_selected;
+ {
+ JMutexAutoLock lock(m_blocks_sending_mutex);
+ num_blocks_selected = m_blocks_sending.size();
+ }
+
+ /*
+ next time d will be continued from the d from which the nearest
+ unsent block was found this time.
+
+ This is because not necessarily any of the blocks found this
+ time are actually sent.
+ */
+ s32 new_nearest_unsent_d = -1;
// Serialization version used
//u8 ser_version = serialization_version;
if(m_nearest_unsent_d != last_nearest_unsent_d)
{
d = m_nearest_unsent_d;
+ last_nearest_unsent_d = m_nearest_unsent_d;
}
- else
- {
- m_nearest_unsent_d = d;
- }
- last_nearest_unsent_d = m_nearest_unsent_d;
}
/*
JMutexAutoLock lock(m_blocks_sending_mutex);
// Limit is dynamically lowered when building
- if(m_blocks_sending.size()
+ if(num_blocks_selected
>= maximum_simultaneous_block_sends_now)
{
/*dstream<<"Not sending more blocks. Queue full. "
<<m_blocks_sending.size()
<<std::endl;*/
- return;
+ goto queue_full;
}
if(m_blocks_sending.find(p) != NULL)
|| p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
continue;
-
- bool generate = d <= d_max_gen;
- // Limit the generating area vertically to half
- if(abs(p.Y - center.Y) > d_max_gen / 2)
- generate = false;
+ // If this is true, inexistent block will be made from scratch
+ bool generate = d <= d_max_gen;
+
+ {
+ /*// Limit the generating area vertically to 2/3
+ if(abs(p.Y - center.Y) > d_max_gen - d_max_gen / 3)
+ generate = false;*/
+
+ // Limit the send area vertically to 2/3
+ if(abs(p.Y - center.Y) > d_max_gen - d_max_gen / 3)
+ continue;
+ }
+
+#if 0
+ /*
+ If block is far away, don't generate it unless it is
+ near ground level
+
+ NOTE: We can't know the ground level this way with the
+ new generator.
+ */
+ if(d > 4)
+ {
+ v2s16 p2d(p.X, p.Z);
+ MapSector *sector = NULL;
+ try
+ {
+ sector = server->m_env.getMap().getSectorNoGenerate(p2d);
+ }
+ catch(InvalidPositionException &e)
+ {
+ }
+
+ if(sector != NULL)
+ {
+ // Get center ground height in nodes
+ f32 gh = sector->getGroundHeight(
+ v2s16(MAP_BLOCKSIZE/2, MAP_BLOCKSIZE/2));
+ // Block center y in nodes
+ f32 y = (f32)(p.Y * MAP_BLOCKSIZE + MAP_BLOCKSIZE/2);
+ // If differs a lot, don't generate
+ if(fabs(gh - y) > MAP_BLOCKSIZE*2)
+ generate = false;
+ }
+ }
+#endif
+
+ /*
+ Don't draw if not in sight
+ */
+
+ if(isBlockInSight(p, camera_pos, camera_dir, 10000*BS) == false)
+ {
+ continue;
+ }
/*
Don't send already sent blocks
if(m_blocks_sent.find(p) != NULL)
continue;
}
-
+
/*
Check if map has this block
*/
- MapBlock *block = NULL;
- try
- {
- block = server->m_env.getMap().getBlockNoCreate(p);
- }
- catch(InvalidPositionException &e)
- {
- }
+ MapBlock *block = server->m_env.getMap().getBlockNoCreateNoEx(p);
bool surely_not_found_on_disk = false;
+ bool block_is_invalid = false;
if(block != NULL)
{
/*if(block->isIncomplete())
{
surely_not_found_on_disk = true;
}
+
+ if(block->isValid() == false)
+ {
+ block_is_invalid = true;
+ }
+
+ v2s16 p2d(p.X, p.Z);
+ ServerMap *map = (ServerMap*)(&server->m_env.getMap());
+ v2s16 chunkpos = map->sector_to_chunk(p2d);
+ if(map->chunkNonVolatile(chunkpos) == false)
+ block_is_invalid = true;
+ /*MapChunk *chunk = map->getChunk(chunkpos);
+ if(chunk == NULL)
+ block_is_invalid = true;
+ else if(chunk->getIsVolatile() == true)
+ block_is_invalid = true;*/
}
/*
continue;
}
+ /*
+ Record the lowest d from which a a block has been
+ found being not sent and possibly to exist
+ */
+ if(new_nearest_unsent_d == -1 || d < new_nearest_unsent_d)
+ {
+ new_nearest_unsent_d = d;
+ }
+
/*
Add inexistent block to emerge queue.
*/
- if(block == NULL || surely_not_found_on_disk)
+ if(block == NULL || surely_not_found_on_disk || block_is_invalid)
{
+ //dstream<<"asd"<<std::endl;
+
/*SharedPtr<JMutexAutoLock> lock
(m_num_blocks_in_emerge_queue.getLock());*/
// Allow only one block in emerge queue
if(server->m_emerge_queue.peerItemCount(peer_id) < 1)
{
+ //dstream<<"Adding block to emerge queue"<<std::endl;
+
// Add it to the emerge queue and trigger the thread
u8 flags = 0;
if(generate == false)
- flags |= TOSERVER_GETBLOCK_FLAG_OPTIONAL;
+ flags |= BLOCK_EMERGE_FLAG_FROMDISK;
server->m_emerge_queue.addBlock(peer_id, p, flags);
server->m_emergethread.trigger();
PrioritySortedBlockTransfer q((float)d, p, peer_id);
dest.push_back(q);
+
+ num_blocks_selected += 1;
}
}
+queue_full:
- // Don't add anything here. The loop breaks by returning.
+ if(new_nearest_unsent_d != -1)
+ {
+ JMutexAutoLock lock(m_blocks_sent_mutex);
+ m_nearest_unsent_d = new_nearest_unsent_d;
+ }
}
void RemoteClient::SendObjectData(
/*
Get and write player data
*/
-
- core::list<Player*> players = server->m_env.getPlayers();
+
+ // Get connected players
+ core::list<Player*> players = server->m_env.getPlayers(true);
// Write player count
u16 playercount = players.size();
- Add blocks to emerge queue if they are not found
SUGGESTION: These could be ignored from the backside of the player
-
- TODO: Keep track of total size of packet and stop when it is too big
*/
Player *player = server->m_env.getPlayer(peer_id);
+ assert(player);
+
v3f playerpos = player->getPosition();
v3f playerspeed = player->getSpeed();
v3s16 center_nodepos = floatToInt(playerpos);
v3s16 center = getNodeBlockPos(center_nodepos);
- //s16 d_max = ACTIVE_OBJECT_D_BLOCKS;
s16 d_max = g_settings.getS16("active_object_range");
// Number of blocks whose objects were written to bos
u16 blockcount = 0;
- //core::map<v3s16, MapBlock*> blocks;
std::ostringstream bos(std::ios_base::binary);
for(s16 d = 0; d <= d_max; d++)
// Get block
MapBlock *block = server->m_env.getMap().getBlockNoCreate(p);
- // Skip block if there are no objects
- if(block->getObjectCount() == 0)
- continue;
-
- // Step block if not in stepped_blocks and add to stepped_blocks
+ /*
+ Step block if not in stepped_blocks and add to stepped_blocks.
+ */
if(stepped_blocks.find(p) == NULL)
{
- block->stepObjects(dtime, true);
+ block->stepObjects(dtime, true, server->getDayNightRatio());
stepped_blocks.insert(p, true);
block->setChangedFlag();
}
+ // Skip block if there are no objects
+ if(block->getObjectCount() == 0)
+ continue;
+
/*
Write objects
*/
m_num_blocks_in_emerge_queue.m_value++;*/
// Add to queue as an anonymous fetch from disk
- u8 flags = TOSERVER_GETBLOCK_FLAG_OPTIONAL;
+ u8 flags = BLOCK_EMERGE_FLAG_FROMDISK;
server->m_emerge_queue.addBlock(0, p, flags);
server->m_emergethread.trigger();
}
if(m_blocks_sending.find(p) != NULL)
m_blocks_sending.remove(p);
else
- dstream<<"RemoteClient::GotBlock(): Didn't find in"
- " m_blocks_sending"<<std::endl;
+ {
+ /*dstream<<"RemoteClient::GotBlock(): Didn't find in"
+ " m_blocks_sending"<<std::endl;*/
+ m_excess_gotblocks++;
+ }
m_blocks_sent.insert(p, true);
}
void RemoteClient::SentBlock(v3s16 p)
{
JMutexAutoLock lock(m_blocks_sending_mutex);
- if(m_blocks_sending.size() > 15)
+ /*if(m_blocks_sending.size() > 15)
{
dstream<<"RemoteClient::SentBlock(): "
<<"m_blocks_sending.size()="
<<m_blocks_sending.size()<<std::endl;
- }
+ }*/
if(m_blocks_sending.find(p) == NULL)
m_blocks_sending.insert(p, 0.0);
else
}
}
-/*void RemoteClient::BlockEmerged()
-{
- SharedPtr<JMutexAutoLock> lock(m_num_blocks_in_emerge_queue.getLock());
- assert(m_num_blocks_in_emerge_queue.m_value > 0);
- m_num_blocks_in_emerge_queue.m_value--;
-}*/
-
-/*void RemoteClient::RunSendingTimeouts(float dtime, float timeout)
-{
- JMutexAutoLock sendinglock(m_blocks_sending_mutex);
-
- core::list<v3s16> remove_queue;
- for(core::map<v3s16, float>::Iterator
- i = m_blocks_sending.getIterator();
- i.atEnd()==false; i++)
- {
- v3s16 p = i.getNode()->getKey();
- float t = i.getNode()->getValue();
- t += dtime;
- i.getNode()->setValue(t);
-
- if(t > timeout)
- {
- remove_queue.push_back(p);
- }
- }
- for(core::list<v3s16>::Iterator
- i = remove_queue.begin();
- i != remove_queue.end(); i++)
- {
- m_blocks_sending.remove(*i);
- }
-}*/
-
/*
PlayerInfo
*/
void PlayerInfo::PrintLine(std::ostream *s)
{
- (*s)<<id<<": \""<<name<<"\" ("
- <<position.X<<","<<position.Y
- <<","<<position.Z<<") ";
+ (*s)<<id<<": ";
+ (*s)<<"\""<<name<<"\" ("
+ <<(position.X/10)<<","<<(position.Y/10)
+ <<","<<(position.Z/10)<<") ";
address.print(s);
(*s)<<" avg_rtt="<<avg_rtt;
(*s)<<std::endl;
*/
Server::Server(
- std::string mapsavedir,
- HMParams hm_params,
- MapParams map_params
+ std::string mapsavedir
):
- m_env(new ServerMap(mapsavedir, hm_params, map_params), dout_server),
+ m_env(new ServerMap(mapsavedir), dout_server),
m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, this),
m_thread(this),
- m_emergethread(this)
+ m_emergethread(this),
+ m_time_of_day(9000),
+ m_time_counter(0),
+ m_time_of_day_send_timer(0),
+ m_uptime(0),
+ m_mapsavedir(mapsavedir)
{
+ //m_flowwater_timer = 0.0;
+ m_liquid_transform_timer = 0.0;
+ m_print_info_timer = 0.0;
+ m_objectdata_timer = 0.0;
+ m_emergethread_trigger_timer = 0.0;
+ m_savemap_timer = 0.0;
+
m_env_mutex.Init();
m_con_mutex.Init();
m_step_dtime_mutex.Init();
m_step_dtime = 0.0;
+
+ // Load players
+ m_env.deSerializePlayers(m_mapsavedir);
}
Server::~Server()
{
+ // Save players
+ m_env.serializePlayers(m_mapsavedir);
+
// Stop threads
stop();
i = m_clients.getIterator();
i.atEnd() == false; i++)
{
- u16 peer_id = i.getNode()->getKey();
-
- // Delete player
+ /*// Delete player
+ // NOTE: These are removed by env destructor
{
+ u16 peer_id = i.getNode()->getKey();
JMutexAutoLock envlock(m_env_mutex);
m_env.removePlayer(peer_id);
- }
+ }*/
// Delete client
delete i.getNode()->getValue();
if(dtime < 0.001)
return;
+ //dstream<<"Server steps "<<dtime<<std::endl;
+ //dstream<<"Server::AsyncRunStep(): dtime="<<dtime<<std::endl;
+
{
JMutexAutoLock lock1(m_step_dtime_mutex);
- m_step_dtime = 0.0;
+ m_step_dtime -= dtime;
}
- //dstream<<"Server steps "<<dtime<<std::endl;
+ /*
+ Update uptime
+ */
+ {
+ m_uptime.set(m_uptime.get() + dtime);
+ }
- //dstream<<"Server::AsyncRunStep(): dtime="<<dtime<<std::endl;
+ /*
+ Update m_time_of_day
+ */
+ {
+ m_time_counter += dtime;
+ f32 speed = g_settings.getFloat("time_speed") * 24000./(24.*3600);
+ u32 units = (u32)(m_time_counter*speed);
+ m_time_counter -= (f32)units / speed;
+ m_time_of_day.set((m_time_of_day.get() + units) % 24000);
+
+ //dstream<<"Server: m_time_of_day = "<<m_time_of_day.get()<<std::endl;
+
+ /*
+ Send to clients at constant intervals
+ */
+
+ m_time_of_day_send_timer -= dtime;
+ if(m_time_of_day_send_timer < 0.0)
+ {
+ m_time_of_day_send_timer = g_settings.getFloat("time_send_interval");
+
+ //JMutexAutoLock envlock(m_env_mutex);
+ JMutexAutoLock conlock(m_con_mutex);
+
+ for(core::map<u16, RemoteClient*>::Iterator
+ i = m_clients.getIterator();
+ i.atEnd() == false; i++)
+ {
+ RemoteClient *client = i.getNode()->getValue();
+ //Player *player = m_env.getPlayer(client->peer_id);
+
+ SharedBuffer<u8> data = makePacket_TOCLIENT_TIME_OF_DAY(
+ m_time_of_day.get());
+ // Send as reliable
+ m_con.Send(client->peer_id, 0, data, true);
+ }
+ }
+ }
+
{
- // Has to be locked for peerAdded/Removed
- JMutexAutoLock lock1(m_env_mutex);
// Process connection's timeouts
JMutexAutoLock lock2(m_con_mutex);
m_con.RunTimeouts(dtime);
}
+
+ {
+ // This has to be called so that the client list gets synced
+ // with the peer list of the connection
+ handlePeerChanges();
+ }
+
{
// Step environment
// This also runs Map's timers
/*
Do background stuff
*/
-
+
/*
- Flow water
+ Transform liquids
*/
+ m_liquid_transform_timer += dtime;
+ if(m_liquid_transform_timer >= 1.00)
{
- float interval;
+ m_liquid_transform_timer -= 1.00;
- if(g_settings.getBool("endless_water") == false)
- interval = 1.0;
- else
- interval = 0.25;
-
- static float counter = 0.0;
- counter += dtime;
- if(counter >= 0.25 && m_flow_active_nodes.size() > 0)
- {
+ JMutexAutoLock lock(m_env_mutex);
- counter = 0.0;
-
core::map<v3s16, MapBlock*> modified_blocks;
-
+ m_env.getMap().transformLiquids(modified_blocks);
+#if 0
+ /*
+ Update lighting
+ */
+ core::map<v3s16, MapBlock*> lighting_modified_blocks;
+ ServerMap &map = ((ServerMap&)m_env.getMap());
+ map.updateLighting(modified_blocks, lighting_modified_blocks);
+
+ // Add blocks modified by lighting to modified_blocks
+ for(core::map<v3s16, MapBlock*>::Iterator
+ i = lighting_modified_blocks.getIterator();
+ i.atEnd() == false; i++)
{
-
- JMutexAutoLock envlock(m_env_mutex);
-
- MapVoxelManipulator v(&m_env.getMap());
- v.m_disable_water_climb =
- g_settings.getBool("disable_water_climb");
-
- if(g_settings.getBool("endless_water") == false)
- v.flowWater(m_flow_active_nodes, 0, false, 250);
- else
- v.flowWater(m_flow_active_nodes, 0, false, 50);
-
- v.blitBack(modified_blocks);
-
- ServerMap &map = ((ServerMap&)m_env.getMap());
-
- // Update lighting
- core::map<v3s16, MapBlock*> lighting_modified_blocks;
- map.updateLighting(modified_blocks, lighting_modified_blocks);
-
- // Add blocks modified by lighting to modified_blocks
- for(core::map<v3s16, MapBlock*>::Iterator
- i = lighting_modified_blocks.getIterator();
- i.atEnd() == false; i++)
- {
- MapBlock *block = i.getNode()->getValue();
- modified_blocks.insert(block->getPos(), block);
- }
- } // envlock
-
+ MapBlock *block = i.getNode()->getValue();
+ modified_blocks.insert(block->getPos(), block);
+ }
+#endif
/*
Set the modified blocks unsent for all the clients
*/
client->SetBlocksNotSent(modified_blocks);
}
}
-
- } // interval counter
}
-
+
// Periodically print some info
{
- static float counter = 0.0;
+ float &counter = m_print_info_timer;
counter += dtime;
if(counter >= 30.0)
{
}
}
- // Run time- and client- related stuff
- // NOTE: If you intend to add something here, check that it
- // doesn't fit in RemoteClient::GetNextBlocks for example.
- /*{
- // Clients are behind connection lock
- JMutexAutoLock lock(m_con_mutex);
+ /*
+ Update digging
+
+ NOTE: Some of this could be moved to RemoteClient
+ */
+#if 0
+ {
+ JMutexAutoLock envlock(m_env_mutex);
+ JMutexAutoLock conlock(m_con_mutex);
for(core::map<u16, RemoteClient*>::Iterator
i = m_clients.getIterator();
i.atEnd() == false; i++)
{
RemoteClient *client = i.getNode()->getValue();
- //con::Peer *peer = m_con.GetPeer(client->peer_id);
- //client->RunSendingTimeouts(dtime, peer->resend_timeout);
- }
- }*/
+ Player *player = m_env.getPlayer(client->peer_id);
- // Send object positions
- {
- static float counter = 0.0;
- counter += dtime;
- if(counter >= g_settings.getFloat("objectdata_interval"))
- {
- JMutexAutoLock lock1(m_env_mutex);
- JMutexAutoLock lock2(m_con_mutex);
- SendObjectData(counter);
+ JMutexAutoLock digmutex(client->m_dig_mutex);
- counter = 0.0;
- }
- }
-
- // Trigger emergethread (it gets somehow gets to a
- // non-triggered but bysy state sometimes)
- {
- static float counter = 0.0;
- counter += dtime;
- if(counter >= 2.0)
+ if(client->m_dig_tool_item == -1)
+ continue;
+
+ client->m_dig_time_remaining -= dtime;
+
+ if(client->m_dig_time_remaining > 0)
+ {
+ client->m_time_from_building.set(0.0);
+ continue;
+ }
+
+ v3s16 p_under = client->m_dig_position;
+
+ // Mandatory parameter; actually used for nothing
+ core::map<v3s16, MapBlock*> modified_blocks;
+
+ u8 material;
+
+ try
+ {
+ // Get material at position
+ material = m_env.getMap().getNode(p_under).d;
+ // If it's not diggable, do nothing
+ if(content_diggable(material) == false)
+ {
+ derr_server<<"Server: Not finishing digging: Node not diggable"
+ <<std::endl;
+ client->m_dig_tool_item = -1;
+ break;
+ }
+ }
+ catch(InvalidPositionException &e)
+ {
+ derr_server<<"Server: Not finishing digging: Node not found"
+ <<std::endl;
+ client->m_dig_tool_item = -1;
+ break;
+ }
+
+ // Create packet
+ u32 replysize = 8;
+ SharedBuffer<u8> reply(replysize);
+ writeU16(&reply[0], TOCLIENT_REMOVENODE);
+ writeS16(&reply[2], p_under.X);
+ writeS16(&reply[4], p_under.Y);
+ writeS16(&reply[6], p_under.Z);
+ // Send as reliable
+ m_con.SendToAll(0, reply, true);
+
+ if(g_settings.getBool("creative_mode") == false)
+ {
+ // Add to inventory and send inventory
+ InventoryItem *item = new MaterialItem(material, 1);
+ player->inventory.addItem("main", item);
+ SendInventory(player->peer_id);
+ }
+
+ /*
+ Remove the node
+ (this takes some time so it is done after the quick stuff)
+ */
+ m_env.getMap().removeNodeAndUpdate(p_under, modified_blocks);
+
+ /*
+ Update water
+ */
+
+ // Update water pressure around modification
+ // This also adds it to m_flow_active_nodes if appropriate
+
+ MapVoxelManipulator v(&m_env.getMap());
+ v.m_disable_water_climb =
+ g_settings.getBool("disable_water_climb");
+
+ VoxelArea area(p_under-v3s16(1,1,1), p_under+v3s16(1,1,1));
+
+ try
+ {
+ v.updateAreaWaterPressure(area, m_flow_active_nodes);
+ }
+ catch(ProcessingLimitException &e)
+ {
+ dstream<<"Processing limit reached (1)"<<std::endl;
+ }
+
+ v.blitBack(modified_blocks);
+ }
+ }
+#endif
+
+ // Send object positions
+ {
+ float &counter = m_objectdata_timer;
+ counter += dtime;
+ if(counter >= g_settings.getFloat("objectdata_interval"))
+ {
+ JMutexAutoLock lock1(m_env_mutex);
+ JMutexAutoLock lock2(m_con_mutex);
+ SendObjectData(counter);
+
+ counter = 0.0;
+ }
+ }
+
+ /*
+ Trigger emergethread (it somehow gets to a non-triggered but
+ bysy state sometimes)
+ */
+ {
+ float &counter = m_emergethread_trigger_timer;
+ counter += dtime;
+ if(counter >= 2.0)
{
counter = 0.0;
// Save map
{
- static float counter = 0.0;
+ float &counter = m_savemap_timer;
counter += dtime;
- if(counter >= SERVER_MAP_SAVE_INTERVAL)
+ if(counter >= g_settings.getFloat("server_map_save_interval"))
{
counter = 0.0;
JMutexAutoLock lock(m_env_mutex);
+
// Save only changed parts
m_env.getMap().save(true);
+
+ // Delete unused sectors
+ u32 deleted_count = m_env.getMap().deleteUnusedSectors(
+ g_settings.getFloat("server_unload_unused_sectors_timeout"));
+ if(deleted_count > 0)
+ {
+ dout_server<<"Server: Unloaded "<<deleted_count
+ <<" sectors from memory"<<std::endl;
+ }
+
+ // Save players
+ m_env.serializePlayers(m_mapsavedir);
}
}
}
u32 datasize;
try{
{
- JMutexAutoLock lock(m_con_mutex);
+ JMutexAutoLock conlock(m_con_mutex);
datasize = m_con.Receive(peer_id, *data, data_maxsize);
}
+
+ // This has to be called so that the client list gets synced
+ // with the peer list of the connection
+ handlePeerChanges();
+
ProcessData(*data, datasize, peer_id);
}
catch(con::InvalidIncomingDataException &e)
/*
Set up player
*/
+
+ // Get player name
+ const u32 playername_size = 20;
+ char playername[playername_size];
+ for(u32 i=0; i<playername_size-1; i++)
+ {
+ playername[i] = data[3+i];
+ }
+ playername[playername_size-1] = 0;
+
+ // Get player
+ Player *player = emergePlayer(playername, "", peer_id);
+ //Player *player = m_env.getPlayer(peer_id);
+
+ /*{
+ // DEBUG: Test serialization
+ std::ostringstream test_os;
+ player->serialize(test_os);
+ dstream<<"Player serialization test: \""<<test_os.str()
+ <<"\""<<std::endl;
+ std::istringstream test_is(test_os.str());
+ player->deSerialize(test_is);
+ }*/
+
+ // If failed, cancel
+ if(player == NULL)
+ {
+ derr_server<<DTIME<<"Server: peer_id="<<peer_id
+ <<": failed to emerge player"<<std::endl;
+ return;
+ }
- Player *player = m_env.getPlayer(peer_id);
+ /*
+ // If a client is already connected to the player, cancel
+ if(player->peer_id != 0)
+ {
+ derr_server<<DTIME<<"Server: peer_id="<<peer_id
+ <<" tried to connect to "
+ "an already connected player (peer_id="
+ <<player->peer_id<<")"<<std::endl;
+ return;
+ }
+ // Set client of player
+ player->peer_id = peer_id;
+ */
// Check if player doesn't exist
if(player == NULL)
throw con::InvalidIncomingDataException
("Server::ProcessData(): INIT: Player doesn't exist");
- // update name if it was supplied
+ /*// update name if it was supplied
if(datasize >= 20+3)
{
data[20+3-1] = 0;
player->updateName((const char*)&data[3]);
- }
+ }*/
// Now answer with a TOCLIENT_INIT
// Send inventory to player
SendInventory(peer->id);
+
+ // Send time of day
+ {
+ SharedBuffer<u8> data = makePacket_TOCLIENT_TIME_OF_DAY(
+ m_time_of_day.get());
+ m_con.Send(peer->id, 0, data, true);
+ }
+
+ // Send information about server to player in chat
+ {
+ std::wostringstream os(std::ios_base::binary);
+ os<<L"# Server: ";
+ // Uptime
+ os<<L"uptime="<<m_uptime.get();
+ // Information about clients
+ os<<L", clients={";
+ for(core::map<u16, RemoteClient*>::Iterator
+ i = m_clients.getIterator();
+ i.atEnd() == false; i++)
+ {
+ // Get client and check that it is valid
+ RemoteClient *client = i.getNode()->getValue();
+ assert(client->peer_id == i.getNode()->getKey());
+ if(client->serialization_version == SER_FMT_VER_INVALID)
+ continue;
+ // Get player
+ Player *player = m_env.getPlayer(client->peer_id);
+ // Get name of player
+ std::wstring name = L"unknown";
+ if(player != NULL)
+ name = narrow_to_wide(player->getName());
+ // Add name to information string
+ os<<name<<L",";
+ }
+ os<<L"}";
+ // Send message
+ SendChatMessage(peer_id, os.str());
+ }
+
+ // Send information about joining in chat
+ {
+ std::wstring name = L"unknown";
+ Player *player = m_env.getPlayer(peer_id);
+ if(player != NULL)
+ name = narrow_to_wide(player->getName());
+
+ std::wstring message;
+ message += L"*** ";
+ message += name;
+ message += L" joined game";
+ BroadcastChatMessage(message);
+ }
return;
}
}
catch(InvalidPositionException &e)
{
- derr_server<<"PICK_OBJECT block not found"<<std::endl;
+ derr_server<<"CLICK_OBJECT block not found"<<std::endl;
return;
}
if(obj == NULL)
{
- derr_server<<"PICK_OBJECT object not found"<<std::endl;
+ derr_server<<"CLICK_OBJECT object not found"<<std::endl;
return;
}
// Left click
if(button == 0)
{
- if(g_settings.getBool("creative_mode") == false)
+ InventoryList *ilist = player->inventory.getList("main");
+ if(g_settings.getBool("creative_mode") == false && ilist != NULL)
{
// Skip if inventory has no free space
- if(player->inventory.getUsedSlots() == player->inventory.getSize())
+ if(ilist->getUsedSlots() == ilist->getSize())
{
dout_server<<"Player inventory has no free space"<<std::endl;
return;
}
-
+
+ /*
+ Create the inventory item
+ */
+ InventoryItem *item = NULL;
+ // If it is an item-object, take the item from it
+ if(obj->getTypeId() == MAPBLOCKOBJECT_TYPE_ITEM)
+ {
+ item = ((ItemObject*)obj)->createInventoryItem();
+ }
+ // Else create an item of the object
+ else
+ {
+ item = new MapBlockObjectItem
+ (obj->getInventoryString());
+ }
+
// Add to inventory and send inventory
- InventoryItem *item = new MapBlockObjectItem
- (obj->getInventoryString());
- player->inventory.addItem(item);
+ ilist->addItem(item);
SendInventory(player->peer_id);
}
block->removeObject(id);
}
}
- else if(command == TOSERVER_PRESS_GROUND)
+ else if(command == TOSERVER_GROUND_ACTION)
{
if(datasize < 17)
return;
/*
length: 17
[0] u16 command
- [2] u8 button (0=left, 1=right)
+ [2] u8 action
[3] v3s16 nodepos_undersurface
[9] v3s16 nodepos_abovesurface
[15] u16 item
+ actions:
+ 0: start digging
+ 1: place block
+ 2: stop digging (all parameters ignored)
*/
- u8 button = readU8(&data[2]);
+ u8 action = readU8(&data[2]);
v3s16 p_under;
p_under.X = readS16(&data[3]);
p_under.Y = readS16(&data[5]);
//TODO: Check that target is reasonably close
/*
- Left button digs ground
+ 0: start digging
*/
- if(button == 0)
+ if(action == 0)
+ {
+ /*
+ NOTE: This can be used in the future to check if
+ somebody is cheating, by checking the timing.
+ */
+ } // action == 0
+
+ /*
+ 2: stop digging
+ */
+ else if(action == 2)
{
+#if 0
+ RemoteClient *client = getClient(peer->id);
+ JMutexAutoLock digmutex(client->m_dig_mutex);
+ client->m_dig_tool_item = -1;
+#endif
+ }
+ /*
+ 3: Digging completed
+ */
+ else if(action == 3)
+ {
+ // Mandatory parameter; actually used for nothing
core::map<v3s16, MapBlock*> modified_blocks;
u8 material;
+ u8 mineral = MINERAL_NONE;
try
{
+ MapNode n = m_env.getMap().getNode(p_under);
// Get material at position
- material = m_env.getMap().getNode(p_under).d;
+ material = n.d;
// If it's not diggable, do nothing
if(content_diggable(material) == false)
{
+ derr_server<<"Server: Not finishing digging: Node not diggable"
+ <<std::endl;
return;
}
+ // Get mineral
+ mineral = n.getMineral();
}
catch(InvalidPositionException &e)
{
- derr_server<<"Server: Ignoring REMOVENODE: Node not found"
+ derr_server<<"Server: Not finishing digging: Node not found."
+ <<" Adding block to emerge queue."
<<std::endl;
+ m_emerge_queue.addBlock(peer_id,
+ getNodeBlockPos(p_over), BLOCK_EMERGE_FLAG_FROMDISK);
return;
}
- // Reset build time counter
- getClient(peer->id)->m_time_from_building.set(0.0);
-
+ /*
+ Send the removal to all other clients
+ */
+
// Create packet
u32 replysize = 8;
SharedBuffer<u8> reply(replysize);
writeS16(&reply[2], p_under.X);
writeS16(&reply[4], p_under.Y);
writeS16(&reply[6], p_under.Z);
- // Send as reliable
- m_con.SendToAll(0, reply, true);
+
+ for(core::map<u16, RemoteClient*>::Iterator
+ i = m_clients.getIterator();
+ i.atEnd() == false; i++)
+ {
+ // Get client and check that it is valid
+ RemoteClient *client = i.getNode()->getValue();
+ assert(client->peer_id == i.getNode()->getKey());
+ if(client->serialization_version == SER_FMT_VER_INVALID)
+ continue;
+
+ // Don't send if it's the same one
+ if(peer_id == client->peer_id)
+ continue;
+
+ // Send as reliable
+ m_con.Send(client->peer_id, 0, reply, true);
+ }
+ /*
+ Update and send inventory
+ */
+
if(g_settings.getBool("creative_mode") == false)
{
- // Add to inventory and send inventory
- InventoryItem *item = new MaterialItem(material, 1);
- player->inventory.addItem(item);
+ /*
+ Wear out tool
+ */
+ InventoryList *mlist = player->inventory.getList("main");
+ if(mlist != NULL)
+ {
+ InventoryItem *item = mlist->getItem(item_i);
+ if(item && (std::string)item->getName() == "ToolItem")
+ {
+ ToolItem *titem = (ToolItem*)item;
+ std::string toolname = titem->getToolName();
+
+ // Get digging properties for material and tool
+ DiggingProperties prop =
+ getDiggingProperties(material, toolname);
+
+ if(prop.diggable == false)
+ {
+ derr_server<<"Server: WARNING: Player digged"
+ <<" with impossible material + tool"
+ <<" combination"<<std::endl;
+ }
+
+ bool weared_out = titem->addWear(prop.wear);
+
+ if(weared_out)
+ {
+ mlist->deleteItem(item_i);
+ }
+ }
+ }
+
+ /*
+ Add digged item to inventory
+ */
+
+ InventoryItem *item = NULL;
+
+ if(mineral != MINERAL_NONE)
+ item = getDiggedMineralItem(mineral);
+
+ if(item == NULL)
+ item = new MaterialItem(material, 1);
+
+ player->inventory.addItem("main", item);
+
+ /*
+ Send inventory
+ */
SendInventory(player->peer_id);
}
(this takes some time so it is done after the quick stuff)
*/
m_env.getMap().removeNodeAndUpdate(p_under, modified_blocks);
-
+
+#if 0
/*
Update water
*/
}
v.blitBack(modified_blocks);
-
- // Add the node to m_flow_active_nodes.
- //m_flow_active_nodes[p_under] = 1;
-
- } // button == 0
+#endif
+ }
+
/*
- Right button places blocks and stuff
+ 1: place block
*/
- else if(button == 1)
+ else if(action == 1)
{
+ InventoryList *ilist = player->inventory.getList("main");
+ if(ilist == NULL)
+ return;
+
// Get item
- InventoryItem *item = player->inventory.getItem(item_i);
+ InventoryItem *item = ilist->getItem(item_i);
// If there is no item, it is not possible to add it anywhere
if(item == NULL)
// Don't add a node if this is not a free space
MapNode n2 = m_env.getMap().getNode(p_over);
if(content_buildable_to(n2.d) == false)
+ {
+ // Client probably has wrong data.
+ // Set block not sent, so that client will get
+ // a valid one.
+ dstream<<"Client "<<peer_id<<" tried to place"
+ <<" node in invalid position; setting"
+ <<" MapBlock not sent."<<std::endl;
+ RemoteClient *client = getClient(peer_id);
+ v3s16 blockpos = getNodeBlockPos(p_over);
+ client->SetBlockNotSent(blockpos);
return;
+ }
}
catch(InvalidPositionException &e)
{
derr_server<<"Server: Ignoring ADDNODE: Node not found"
+ <<" Adding block to emerge queue."
<<std::endl;
+ m_emerge_queue.addBlock(peer_id,
+ getNodeBlockPos(p_over), BLOCK_EMERGE_FLAG_FROMDISK);
return;
}
MaterialItem *mitem = (MaterialItem*)item;
MapNode n;
n.d = mitem->getMaterial();
- if(content_directional(n.d))
+ if(content_features(n.d).wall_mounted)
n.dir = packDir(p_under - p_over);
#if 1
/*
Handle inventory
*/
- if(g_settings.getBool("creative_mode") == false)
+ InventoryList *ilist = player->inventory.getList("main");
+ if(g_settings.getBool("creative_mode") == false && ilist)
{
// Remove from inventory and send inventory
if(mitem->getCount() == 1)
- player->inventory.deleteItem(item_i);
+ ilist->deleteItem(item_i);
else
mitem->remove(1);
// Send inventory
/*
Handle inventory
*/
- if(g_settings.getBool("creative_mode") == false)
+ InventoryList *ilist = player->inventory.getList("main");
+ if(g_settings.getBool("creative_mode") == false && ilist)
{
// Remove from inventory and send inventory
if(mitem->getCount() == 1)
- player->inventory.deleteItem(item_i);
+ ilist->deleteItem(item_i);
else
mitem->remove(1);
// Send inventory
}
}
#endif
-
+
+#if 0
/*
Update water
*/
}
v.blitBack(modified_blocks);
+#endif
}
/*
- Handle block object items
+ Handle other items
*/
- else if(std::string("MBOItem") == item->getName())
+ else
{
- MapBlockObjectItem *oitem = (MapBlockObjectItem*)item;
-
- /*dout_server<<"Trying to place a MapBlockObjectItem: "
- "inventorystring=\""
- <<oitem->getInventoryString()
- <<"\""<<std::endl;*/
-
v3s16 blockpos = getNodeBlockPos(p_over);
MapBlock *block = NULL;
<<"("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"
<<std::endl;*/
+ MapBlockObject *obj = NULL;
- MapBlockObject *obj = oitem->createObject
- (pos, player->getYaw(), player->getPitch());
+ /*
+ Handle block object items
+ */
+ if(std::string("MBOItem") == item->getName())
+ {
+ MapBlockObjectItem *oitem = (MapBlockObjectItem*)item;
+
+ /*dout_server<<"Trying to place a MapBlockObjectItem: "
+ "inventorystring=\""
+ <<oitem->getInventoryString()
+ <<"\""<<std::endl;*/
+
+ obj = oitem->createObject
+ (pos, player->getYaw(), player->getPitch());
+ }
+ /*
+ Handle other items
+ */
+ else
+ {
+ dout_server<<"Placing a miscellaneous item on map"
+ <<std::endl;
+ /*
+ Create an ItemObject that contains the item.
+ */
+ ItemObject *iobj = new ItemObject(NULL, -1, pos);
+ std::ostringstream os(std::ios_base::binary);
+ item->serialize(os);
+ dout_server<<"Item string is \""<<os.str()<<"\""<<std::endl;
+ iobj->setItemString(os.str());
+ obj = iobj;
+ }
if(obj == NULL)
- derr_server<<"WARNING: oitem created NULL object"
+ {
+ derr_server<<"WARNING: item resulted in NULL object, "
+ <<"not placing onto map"
<<std::endl;
+ }
+ else
+ {
+ block->addObject(obj);
- block->addObject(obj);
-
- //dout_server<<"Placed object"<<std::endl;
+ dout_server<<"Placed object"<<std::endl;
- if(g_settings.getBool("creative_mode") == false)
- {
- // Remove from inventory and send inventory
- player->inventory.deleteItem(item_i);
- // Send inventory
- SendInventory(peer_id);
+ InventoryList *ilist = player->inventory.getList("main");
+ if(g_settings.getBool("creative_mode") == false && ilist)
+ {
+ // Remove from inventory and send inventory
+ ilist->deleteItem(item_i);
+ // Send inventory
+ SendInventory(peer_id);
+ }
}
}
- } // button == 1
+ } // action == 1
+
/*
- Catch invalid buttons
+ Catch invalid actions
*/
else
{
- derr_server<<"WARNING: Server: Invalid button "
- <<button<<std::endl;
+ derr_server<<"WARNING: Server: Invalid action "
+ <<action<<std::endl;
}
}
+#if 0
else if(command == TOSERVER_RELEASE)
{
if(datasize < 3)
[0] u16 command
[2] u8 button
*/
- //TODO
+ dstream<<"TOSERVER_RELEASE ignored"<<std::endl;
}
+#endif
else if(command == TOSERVER_SIGNTEXT)
{
/*
obj->getBlock()->setChangedFlag();
}
- else
- {
- derr_server<<"WARNING: Server::ProcessData(): Ignoring "
- "unknown command "<<command<<std::endl;
- }
-
- } //try
- catch(SendFailedException &e)
+ else if(command == TOSERVER_INVENTORY_ACTION)
{
- derr_server<<"Server::ProcessData(): SendFailedException: "
- <<"what="<<e.what()
- <<std::endl;
- }
-}
-
-/*void Server::Send(u16 peer_id, u16 channelnum,
- SharedBuffer<u8> data, bool reliable)
+ /*// Ignore inventory changes if in creative mode
+ if(g_settings.getBool("creative_mode") == true)
+ {
+ dstream<<"TOSERVER_INVENTORY_ACTION: ignoring in creative mode"
+ <<std::endl;
+ return;
+ }*/
+ // Strip command and create a stream
+ std::string datastring((char*)&data[2], datasize-2);
+ dstream<<"TOSERVER_INVENTORY_ACTION: data="<<datastring<<std::endl;
+ std::istringstream is(datastring, std::ios_base::binary);
+ // Create an action
+ InventoryAction *a = InventoryAction::deSerialize(is);
+ if(a != NULL)
+ {
+ /*
+ Handle craftresult specially if not in creative mode
+ */
+ bool disable_action = false;
+ if(a->getType() == IACTION_MOVE
+ && g_settings.getBool("creative_mode") == false)
+ {
+ IMoveAction *ma = (IMoveAction*)a;
+ // Don't allow moving anything to craftresult
+ if(ma->to_name == "craftresult")
+ {
+ // Do nothing
+ disable_action = true;
+ }
+ // When something is removed from craftresult
+ if(ma->from_name == "craftresult")
+ {
+ disable_action = true;
+ // Remove stuff from craft
+ InventoryList *clist = player->inventory.getList("craft");
+ if(clist)
+ {
+ u16 count = ma->count;
+ if(count == 0)
+ count = 1;
+ clist->decrementMaterials(count);
+ }
+ // Do action
+ // Feed action to player inventory
+ a->apply(&player->inventory);
+ // Eat it
+ delete a;
+ // If something appeared in craftresult, throw it
+ // in the main list
+ InventoryList *rlist = player->inventory.getList("craftresult");
+ InventoryList *mlist = player->inventory.getList("main");
+ if(rlist && mlist && rlist->getUsedSlots() == 1)
+ {
+ InventoryItem *item1 = rlist->changeItem(0, NULL);
+ mlist->addItem(item1);
+ }
+ }
+ }
+ if(disable_action == false)
+ {
+ // Feed action to player inventory
+ a->apply(&player->inventory);
+ // Eat it
+ delete a;
+ }
+ // Send inventory
+ SendInventory(player->peer_id);
+ }
+ else
+ {
+ dstream<<"TOSERVER_INVENTORY_ACTION: "
+ <<"InventoryAction::deSerialize() returned NULL"
+ <<std::endl;
+ }
+ }
+ else if(command == TOSERVER_CHAT_MESSAGE)
+ {
+ /*
+ u16 command
+ u16 length
+ wstring message
+ */
+ u8 buf[6];
+ std::string datastring((char*)&data[2], datasize-2);
+ std::istringstream is(datastring, std::ios_base::binary);
+
+ // Read stuff
+ is.read((char*)buf, 2);
+ u16 len = readU16(buf);
+
+ std::wstring message;
+ for(u16 i=0; i<len; i++)
+ {
+ is.read((char*)buf, 2);
+ message += (wchar_t)readU16(buf);
+ }
+
+ // Get player name of this client
+ std::wstring name = narrow_to_wide(player->getName());
+
+ std::wstring line = std::wstring(L"<")+name+L"> "+message;
+
+ dstream<<"CHAT: "<<wide_to_narrow(line)<<std::endl;
+
+ /*
+ Send the message to all other clients
+ */
+ for(core::map<u16, RemoteClient*>::Iterator
+ i = m_clients.getIterator();
+ i.atEnd() == false; i++)
+ {
+ // Get client and check that it is valid
+ RemoteClient *client = i.getNode()->getValue();
+ assert(client->peer_id == i.getNode()->getKey());
+ if(client->serialization_version == SER_FMT_VER_INVALID)
+ continue;
+
+ // Don't send if it's the same one
+ if(peer_id == client->peer_id)
+ continue;
+
+ SendChatMessage(client->peer_id, line);
+ }
+ }
+ else
+ {
+ derr_server<<"WARNING: Server::ProcessData(): Ignoring "
+ "unknown command "<<command<<std::endl;
+ }
+
+ } //try
+ catch(SendFailedException &e)
+ {
+ derr_server<<"Server::ProcessData(): SendFailedException: "
+ <<"what="<<e.what()
+ <<std::endl;
+ }
+}
+
+/*void Server::Send(u16 peer_id, u16 channelnum,
+ SharedBuffer<u8> data, bool reliable)
{
JMutexAutoLock lock(m_con_mutex);
m_con.Send(peer_id, channelnum, data, reliable);
PlayerInfo info;
Player *player = *i;
+
try{
con::Peer *peer = m_con.GetPeer(player->peer_id);
+ // Copy info from peer to info struct
info.id = peer->id;
info.address = peer->address;
info.avg_rtt = peer->avg_rtt;
}
catch(con::PeerNotFoundException &e)
{
- // Outdated peer info
+ // Set dummy peer info
info.id = 0;
info.address = Address(0,0,0,0,0);
info.avg_rtt = 0.0;
dout_server<<"Server::peerAdded(): peer->id="
<<peer->id<<std::endl;
- // Connection is already locked when this is called.
- //JMutexAutoLock lock(m_con_mutex);
-
- // Error check
- core::map<u16, RemoteClient*>::Node *n;
- n = m_clients.find(peer->id);
- // The client shouldn't already exist
- assert(n == NULL);
-
- // Create client
- RemoteClient *client = new RemoteClient();
- client->peer_id = peer->id;
- m_clients.insert(client->peer_id, client);
-
- // Create player
- {
- // Already locked when called
- //JMutexAutoLock envlock(m_env_mutex);
-
- Player *player = m_env.getPlayer(peer->id);
-
- // The player shouldn't already exist
- assert(player == NULL);
-
- player = new RemotePlayer();
- player->peer_id = peer->id;
-
- /*
- Set player position
- */
-
- // Get zero sector (it could have been unloaded to disk)
- m_env.getMap().emergeSector(v2s16(0,0));
- // Get ground height at origin
- f32 groundheight = m_env.getMap().getGroundHeight(v2s16(0,0), true);
- // The zero sector should have been generated
- assert(groundheight > GROUNDHEIGHT_VALID_MINVALUE);
- // Don't go underwater
- if(groundheight < WATER_LEVEL)
- groundheight = WATER_LEVEL;
-
- player->setPosition(intToFloat(v3s16(
- 0,
- groundheight + 1,
- 0
- )));
-
- /*
- Add player to environment
- */
-
- m_env.addPlayer(player);
-
- /*
- Add stuff to inventory
- */
-
- if(g_settings.getBool("creative_mode"))
- {
- // Give all materials
- assert(USEFUL_CONTENT_COUNT <= PLAYER_INVENTORY_SIZE);
- for(u16 i=0; i<USEFUL_CONTENT_COUNT; i++)
- {
- // Skip some materials
- if(i == CONTENT_OCEAN)
- continue;
-
- InventoryItem *item = new MaterialItem(i, 1);
- player->inventory.addItem(item);
- }
- // Sign
- {
- InventoryItem *item = new MapBlockObjectItem("Sign Example text");
- bool r = player->inventory.addItem(item);
- assert(r == true);
- }
- /*// Rat
- {
- InventoryItem *item = new MapBlockObjectItem("Rat");
- bool r = player->inventory.addItem(item);
- assert(r == true);
- }*/
- }
- else
- {
- // Give some lights
- {
- InventoryItem *item = new MaterialItem(3, 999);
- bool r = player->inventory.addItem(item);
- assert(r == true);
- }
- // and some signs
- for(u16 i=0; i<4; i++)
- {
- InventoryItem *item = new MapBlockObjectItem("Sign Example text");
- bool r = player->inventory.addItem(item);
- assert(r == true);
- }
- /*// and some rats
- for(u16 i=0; i<4; i++)
- {
- InventoryItem *item = new MapBlockObjectItem("Rat");
- bool r = player->inventory.addItem(item);
- assert(r == true);
- }*/
- }
- }
+ PeerChange c;
+ c.type = PEER_ADDED;
+ c.peer_id = peer->id;
+ c.timeout = false;
+ m_peer_change_queue.push_back(c);
}
void Server::deletingPeer(con::Peer *peer, bool timeout)
dout_server<<"Server::deletingPeer(): peer->id="
<<peer->id<<", timeout="<<timeout<<std::endl;
- // Connection is already locked when this is called.
- //JMutexAutoLock lock(m_con_mutex);
-
- // Error check
- core::map<u16, RemoteClient*>::Node *n;
- n = m_clients.find(peer->id);
- // The client should exist
- assert(n != NULL);
-
- // Delete player
- {
- // Already locked when called
- //JMutexAutoLock envlock(m_env_mutex);
- m_env.removePlayer(peer->id);
- }
-
- // Delete client
- delete m_clients[peer->id];
- m_clients.remove(peer->id);
-
- // Send player info to all clients
- SendPlayerInfos();
+ PeerChange c;
+ c.type = PEER_REMOVED;
+ c.peer_id = peer->id;
+ c.timeout = timeout;
+ m_peer_change_queue.push_back(c);
}
void Server::SendObjectData(float dtime)
//JMutexAutoLock envlock(m_env_mutex);
- core::list<Player*> players = m_env.getPlayers();
+ // Get connected players
+ core::list<Player*> players = m_env.getPlayers(true);
u32 player_count = players.getSize();
u32 datasize = 2+(2+PLAYERNAME_SIZE)*player_count;
"peer_id="<<player->peer_id<<std::endl;*/
writeU16(&data[start], player->peer_id);
+ memset((char*)&data[start+2], 0, PLAYERNAME_SIZE);
snprintf((char*)&data[start+2], PLAYERNAME_SIZE, "%s", player->getName());
start += 2+PLAYERNAME_SIZE;
}
m_con.SendToAll(0, data, true);
}
+enum ItemSpecType
+{
+ ITEM_NONE,
+ ITEM_MATERIAL,
+ ITEM_CRAFT,
+ ITEM_TOOL,
+ ITEM_MBO
+};
+
+struct ItemSpec
+{
+ ItemSpec():
+ type(ITEM_NONE)
+ {
+ }
+ ItemSpec(enum ItemSpecType a_type, std::string a_name):
+ type(a_type),
+ name(a_name),
+ num(65535)
+ {
+ }
+ ItemSpec(enum ItemSpecType a_type, u16 a_num):
+ type(a_type),
+ name(""),
+ num(a_num)
+ {
+ }
+ enum ItemSpecType type;
+ // Only other one of these is used
+ std::string name;
+ u16 num;
+};
+
+/*
+ items: a pointer to an array of 9 pointers to items
+ specs: a pointer to an array of 9 ItemSpecs
+*/
+bool checkItemCombination(InventoryItem **items, ItemSpec *specs)
+{
+ u16 items_min_x = 100;
+ u16 items_max_x = 100;
+ u16 items_min_y = 100;
+ u16 items_max_y = 100;
+ for(u16 y=0; y<3; y++)
+ for(u16 x=0; x<3; x++)
+ {
+ if(items[y*3 + x] == NULL)
+ continue;
+ if(items_min_x == 100 || x < items_min_x)
+ items_min_x = x;
+ if(items_min_y == 100 || y < items_min_y)
+ items_min_y = y;
+ if(items_max_x == 100 || x > items_max_x)
+ items_max_x = x;
+ if(items_max_y == 100 || y > items_max_y)
+ items_max_y = y;
+ }
+ // No items at all, just return false
+ if(items_min_x == 100)
+ return false;
+
+ u16 items_w = items_max_x - items_min_x + 1;
+ u16 items_h = items_max_y - items_min_y + 1;
+
+ u16 specs_min_x = 100;
+ u16 specs_max_x = 100;
+ u16 specs_min_y = 100;
+ u16 specs_max_y = 100;
+ for(u16 y=0; y<3; y++)
+ for(u16 x=0; x<3; x++)
+ {
+ if(specs[y*3 + x].type == ITEM_NONE)
+ continue;
+ if(specs_min_x == 100 || x < specs_min_x)
+ specs_min_x = x;
+ if(specs_min_y == 100 || y < specs_min_y)
+ specs_min_y = y;
+ if(specs_max_x == 100 || x > specs_max_x)
+ specs_max_x = x;
+ if(specs_max_y == 100 || y > specs_max_y)
+ specs_max_y = y;
+ }
+ // No specs at all, just return false
+ if(specs_min_x == 100)
+ return false;
+
+ u16 specs_w = specs_max_x - specs_min_x + 1;
+ u16 specs_h = specs_max_y - specs_min_y + 1;
+
+ // Different sizes
+ if(items_w != specs_w || items_h != specs_h)
+ return false;
+
+ for(u16 y=0; y<specs_h; y++)
+ for(u16 x=0; x<specs_w; x++)
+ {
+ u16 items_x = items_min_x + x;
+ u16 items_y = items_min_y + y;
+ u16 specs_x = specs_min_x + x;
+ u16 specs_y = specs_min_y + y;
+ InventoryItem *item = items[items_y * 3 + items_x];
+ ItemSpec &spec = specs[specs_y * 3 + specs_x];
+
+ if(spec.type == ITEM_NONE)
+ {
+ // Has to be no item
+ if(item != NULL)
+ return false;
+ continue;
+ }
+
+ // There should be an item
+ if(item == NULL)
+ return false;
+
+ std::string itemname = item->getName();
+
+ if(spec.type == ITEM_MATERIAL)
+ {
+ if(itemname != "MaterialItem")
+ return false;
+ MaterialItem *mitem = (MaterialItem*)item;
+ if(mitem->getMaterial() != spec.num)
+ return false;
+ }
+ else if(spec.type == ITEM_CRAFT)
+ {
+ if(itemname != "CraftItem")
+ return false;
+ CraftItem *mitem = (CraftItem*)item;
+ if(mitem->getSubName() != spec.name)
+ return false;
+ }
+ else if(spec.type == ITEM_TOOL)
+ {
+ // Not supported yet
+ assert(0);
+ }
+ else if(spec.type == ITEM_MBO)
+ {
+ // Not supported yet
+ assert(0);
+ }
+ else
+ {
+ // Not supported yet
+ assert(0);
+ }
+ }
+
+ return true;
+}
+
void Server::SendInventory(u16 peer_id)
{
DSTACK(__FUNCTION_NAME);
- //JMutexAutoLock envlock(m_env_mutex);
-
Player* player = m_env.getPlayer(peer_id);
+ /*
+ Calculate crafting stuff
+ */
+ if(g_settings.getBool("creative_mode") == false)
+ {
+ InventoryList *clist = player->inventory.getList("craft");
+ InventoryList *rlist = player->inventory.getList("craftresult");
+ if(rlist)
+ {
+ rlist->clearItems();
+ }
+ if(clist && rlist)
+ {
+ InventoryItem *items[9];
+ for(u16 i=0; i<9; i++)
+ {
+ items[i] = clist->getItem(i);
+ }
+
+ bool found = false;
+
+ // Wood
+ if(!found)
+ {
+ ItemSpec specs[9];
+ specs[0] = ItemSpec(ITEM_MATERIAL, CONTENT_TREE);
+ if(checkItemCombination(items, specs))
+ {
+ rlist->addItem(new MaterialItem(CONTENT_WOOD, 4));
+ found = true;
+ }
+ }
+
+ // Stick
+ if(!found)
+ {
+ ItemSpec specs[9];
+ specs[0] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD);
+ if(checkItemCombination(items, specs))
+ {
+ rlist->addItem(new CraftItem("Stick", 4));
+ found = true;
+ }
+ }
+
+ // Sign
+ if(!found)
+ {
+ ItemSpec specs[9];
+ specs[0] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD);
+ specs[1] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD);
+ specs[2] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD);
+ specs[3] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD);
+ specs[4] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD);
+ specs[5] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD);
+ specs[7] = ItemSpec(ITEM_CRAFT, "Stick");
+ if(checkItemCombination(items, specs))
+ {
+ rlist->addItem(new MapBlockObjectItem("Sign"));
+ found = true;
+ }
+ }
+
+ // Torch
+ if(!found)
+ {
+ ItemSpec specs[9];
+ specs[0] = ItemSpec(ITEM_CRAFT, "lump_of_coal");
+ specs[3] = ItemSpec(ITEM_CRAFT, "Stick");
+ if(checkItemCombination(items, specs))
+ {
+ rlist->addItem(new MaterialItem(CONTENT_TORCH, 4));
+ found = true;
+ }
+ }
+
+ // Wooden pick
+ if(!found)
+ {
+ ItemSpec specs[9];
+ specs[0] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD);
+ specs[1] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD);
+ specs[2] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD);
+ specs[4] = ItemSpec(ITEM_CRAFT, "Stick");
+ specs[7] = ItemSpec(ITEM_CRAFT, "Stick");
+ if(checkItemCombination(items, specs))
+ {
+ rlist->addItem(new ToolItem("WPick", 0));
+ found = true;
+ }
+ }
+
+ // Stone pick
+ if(!found)
+ {
+ ItemSpec specs[9];
+ specs[0] = ItemSpec(ITEM_MATERIAL, CONTENT_STONE);
+ specs[1] = ItemSpec(ITEM_MATERIAL, CONTENT_STONE);
+ specs[2] = ItemSpec(ITEM_MATERIAL, CONTENT_STONE);
+ specs[4] = ItemSpec(ITEM_CRAFT, "Stick");
+ specs[7] = ItemSpec(ITEM_CRAFT, "Stick");
+ if(checkItemCombination(items, specs))
+ {
+ rlist->addItem(new ToolItem("STPick", 0));
+ found = true;
+ }
+ }
+
+ // Mese pick
+ if(!found)
+ {
+ ItemSpec specs[9];
+ specs[0] = ItemSpec(ITEM_MATERIAL, CONTENT_MESE);
+ specs[1] = ItemSpec(ITEM_MATERIAL, CONTENT_MESE);
+ specs[2] = ItemSpec(ITEM_MATERIAL, CONTENT_MESE);
+ specs[4] = ItemSpec(ITEM_CRAFT, "Stick");
+ specs[7] = ItemSpec(ITEM_CRAFT, "Stick");
+ if(checkItemCombination(items, specs))
+ {
+ rlist->addItem(new ToolItem("MesePick", 0));
+ found = true;
+ }
+ }
+ }
+ } // if creative_mode == false
+
+ /*
+ Serialize it
+ */
+
std::ostringstream os;
//os.imbue(std::locale("C"));
writeU16(&data[0], TOCLIENT_INVENTORY);
memcpy(&data[2], s.c_str(), s.size());
- //JMutexAutoLock conlock(m_con_mutex);
+ // Send as reliable
+ m_con.Send(peer_id, 0, data, true);
+}
+void Server::SendChatMessage(u16 peer_id, const std::wstring &message)
+{
+ DSTACK(__FUNCTION_NAME);
+
+ std::ostringstream os(std::ios_base::binary);
+ u8 buf[12];
+
+ // Write command
+ writeU16(buf, TOCLIENT_CHAT_MESSAGE);
+ os.write((char*)buf, 2);
+
+ // Write length
+ writeU16(buf, message.size());
+ os.write((char*)buf, 2);
+
+ // Write string
+ for(u32 i=0; i<message.size(); i++)
+ {
+ u16 w = message[i];
+ writeU16(buf, w);
+ os.write((char*)buf, 2);
+ }
+
+ // Make data buffer
+ std::string s = os.str();
+ SharedBuffer<u8> data((u8*)s.c_str(), s.size());
// Send as reliable
m_con.Send(peer_id, 0, data, true);
}
+void Server::BroadcastChatMessage(const std::wstring &message)
+{
+ for(core::map<u16, RemoteClient*>::Iterator
+ i = m_clients.getIterator();
+ i.atEnd() == false; i++)
+ {
+ // Get client and check that it is valid
+ RemoteClient *client = i.getNode()->getValue();
+ assert(client->peer_id == i.getNode()->getKey());
+ if(client->serialization_version == SER_FMT_VER_INVALID)
+ continue;
+
+ SendChatMessage(client->peer_id, message);
+ }
+}
+
void Server::SendBlocks(float dtime)
{
DSTACK(__FUNCTION_NAME);
return n->getValue();
}
+void setCreativeInventory(Player *player)
+{
+ player->resetInventory();
+
+ // Give some good picks
+ {
+ InventoryItem *item = new ToolItem("STPick", 0);
+ void* r = player->inventory.addItem("main", item);
+ assert(r == NULL);
+ }
+ {
+ InventoryItem *item = new ToolItem("MesePick", 0);
+ void* r = player->inventory.addItem("main", item);
+ assert(r == NULL);
+ }
+
+ /*
+ Give materials
+ */
+ assert(USEFUL_CONTENT_COUNT <= PLAYER_INVENTORY_SIZE);
+
+ // add torch first
+ InventoryItem *item = new MaterialItem(CONTENT_TORCH, 1);
+ player->inventory.addItem("main", item);
+
+ // Then others
+ for(u16 i=0; i<USEFUL_CONTENT_COUNT; i++)
+ {
+ // Skip some materials
+ if(i == CONTENT_WATER || i == CONTENT_TORCH
+ || i == CONTENT_COALSTONE)
+ continue;
+
+ InventoryItem *item = new MaterialItem(i, 1);
+ player->inventory.addItem("main", item);
+ }
+ // Sign
+ {
+ InventoryItem *item = new MapBlockObjectItem("Sign Example text");
+ void* r = player->inventory.addItem("main", item);
+ assert(r == NULL);
+ }
+}
+
+Player *Server::emergePlayer(const char *name, const char *password,
+ u16 peer_id)
+{
+ /*
+ Try to get an existing player
+ */
+ Player *player = m_env.getPlayer(name);
+ if(player != NULL)
+ {
+ // If player is already connected, cancel
+ if(player->peer_id != 0)
+ {
+ dstream<<"emergePlayer(): Player already connected"<<std::endl;
+ return NULL;
+ }
+
+ // Got one.
+ player->peer_id = peer_id;
+
+ // Reset inventory to creative if in creative mode
+ if(g_settings.getBool("creative_mode"))
+ {
+ setCreativeInventory(player);
+ }
+
+ return player;
+ }
+
+ /*
+ If player with the wanted peer_id already exists, cancel.
+ */
+ if(m_env.getPlayer(peer_id) != NULL)
+ {
+ dstream<<"emergePlayer(): Player with wrong name but same"
+ " peer_id already exists"<<std::endl;
+ return NULL;
+ }
+
+ /*
+ Create a new player
+ */
+ {
+ player = new ServerRemotePlayer();
+ //player->peer_id = c.peer_id;
+ //player->peer_id = PEER_ID_INEXISTENT;
+ player->peer_id = peer_id;
+ player->updateName(name);
+
+ /*
+ Set player position
+ */
+
+ dstream<<"Server: Finding spawn place for player \""
+ <<player->getName()<<"\""<<std::endl;
+
+ v2s16 nodepos;
+#if 1
+ player->setPosition(intToFloat(v3s16(
+ 0,
+ 45, //64,
+ 0
+ )));
+#endif
+#if 0
+ f32 groundheight = 0;
+#if 0
+ // Try to find a good place a few times
+ for(s32 i=0; i<500; i++)
+ {
+ s32 range = 1 + i;
+ // We're going to try to throw the player to this position
+ nodepos = v2s16(-range + (myrand()%(range*2)),
+ -range + (myrand()%(range*2)));
+ v2s16 sectorpos = getNodeSectorPos(nodepos);
+ // Get sector
+ m_env.getMap().emergeSector(sectorpos);
+ // Get ground height at point
+ groundheight = m_env.getMap().getGroundHeight(nodepos, true);
+ // The sector should have been generated -> groundheight exists
+ assert(groundheight > GROUNDHEIGHT_VALID_MINVALUE);
+ // Don't go underwater
+ if(groundheight < WATER_LEVEL)
+ {
+ //dstream<<"-> Underwater"<<std::endl;
+ continue;
+ }
+#if 0 // Doesn't work, generating blocks is a bit too complicated for doing here
+ // Get block at point
+ v3s16 nodepos3d;
+ nodepos3d = v3s16(nodepos.X, groundheight+1, nodepos.Y);
+ v3s16 blockpos = getNodeBlockPos(nodepos3d);
+ ((ServerMap*)(&m_env.getMap()))->emergeBlock(blockpos);
+ // Don't go inside ground
+ try{
+ /*v3s16 footpos(nodepos.X, groundheight+1, nodepos.Y);
+ v3s16 headpos(nodepos.X, groundheight+2, nodepos.Y);*/
+ v3s16 footpos = nodepos3d + v3s16(0,0,0);
+ v3s16 headpos = nodepos3d + v3s16(0,1,0);
+ if(m_env.getMap().getNode(footpos).d != CONTENT_AIR
+ || m_env.getMap().getNode(headpos).d != CONTENT_AIR)
+ {
+ dstream<<"-> Inside ground"<<std::endl;
+ // In ground
+ continue;
+ }
+ }catch(InvalidPositionException &e)
+ {
+ dstream<<"-> Invalid position"<<std::endl;
+ // Ignore invalid position
+ continue;
+ }
+#endif
+ // Found a good place
+ dstream<<"Searched through "<<i<<" places."<<std::endl;
+ break;
+ }
+#endif
+
+ // If no suitable place was not found, go above water at least.
+ if(groundheight < WATER_LEVEL)
+ groundheight = WATER_LEVEL;
+
+ player->setPosition(intToFloat(v3s16(
+ nodepos.X,
+ //groundheight + 1,
+ groundheight + 15,
+ nodepos.Y
+ )));
+#endif
+
+ /*
+ Add player to environment
+ */
+
+ m_env.addPlayer(player);
+
+ /*
+ Add stuff to inventory
+ */
+
+ if(g_settings.getBool("creative_mode"))
+ {
+ setCreativeInventory(player);
+ }
+ else
+ {
+ /*{
+ InventoryItem *item = new ToolItem("WPick", 32000);
+ void* r = player->inventory.addItem("main", item);
+ assert(r == NULL);
+ }*/
+ /*{
+ InventoryItem *item = new MaterialItem(CONTENT_MESE, 6);
+ void* r = player->inventory.addItem("main", item);
+ assert(r == NULL);
+ }
+ {
+ InventoryItem *item = new MaterialItem(CONTENT_COALSTONE, 6);
+ void* r = player->inventory.addItem("main", item);
+ assert(r == NULL);
+ }
+ {
+ InventoryItem *item = new MaterialItem(CONTENT_WOOD, 6);
+ void* r = player->inventory.addItem("main", item);
+ assert(r == NULL);
+ }
+ {
+ InventoryItem *item = new CraftItem("Stick", 4);
+ void* r = player->inventory.addItem("main", item);
+ assert(r == NULL);
+ }
+ {
+ InventoryItem *item = new ToolItem("WPick", 32000);
+ void* r = player->inventory.addItem("main", item);
+ assert(r == NULL);
+ }
+ {
+ InventoryItem *item = new ToolItem("STPick", 32000);
+ void* r = player->inventory.addItem("main", item);
+ assert(r == NULL);
+ }*/
+ /*// Give some lights
+ {
+ InventoryItem *item = new MaterialItem(CONTENT_TORCH, 999);
+ bool r = player->inventory.addItem("main", item);
+ assert(r == true);
+ }
+ // and some signs
+ for(u16 i=0; i<4; i++)
+ {
+ InventoryItem *item = new MapBlockObjectItem("Sign Example text");
+ bool r = player->inventory.addItem("main", item);
+ assert(r == true);
+ }*/
+ /*// Give some other stuff
+ {
+ InventoryItem *item = new MaterialItem(CONTENT_TREE, 999);
+ bool r = player->inventory.addItem("main", item);
+ assert(r == true);
+ }*/
+ }
+
+ return player;
+
+ } // create new player
+}
+
+#if 0
void Server::UpdateBlockWaterPressure(MapBlock *block,
core::map<v3s16, MapBlock*> &modified_blocks)
{
v.blitBack(modified_blocks);
}
+#endif
+
+void Server::handlePeerChange(PeerChange &c)
+{
+ JMutexAutoLock envlock(m_env_mutex);
+ JMutexAutoLock conlock(m_con_mutex);
+ if(c.type == PEER_ADDED)
+ {
+ /*
+ Add
+ */
+
+ // Error check
+ core::map<u16, RemoteClient*>::Node *n;
+ n = m_clients.find(c.peer_id);
+ // The client shouldn't already exist
+ assert(n == NULL);
+
+ // Create client
+ RemoteClient *client = new RemoteClient();
+ client->peer_id = c.peer_id;
+ m_clients.insert(client->peer_id, client);
+
+ } // PEER_ADDED
+ else if(c.type == PEER_REMOVED)
+ {
+ /*
+ Delete
+ */
+
+ // Error check
+ core::map<u16, RemoteClient*>::Node *n;
+ n = m_clients.find(c.peer_id);
+ // The client should exist
+ assert(n != NULL);
+
+ // Collect information about leaving in chat
+ std::wstring message;
+ {
+ std::wstring name = L"unknown";
+ Player *player = m_env.getPlayer(c.peer_id);
+ if(player != NULL)
+ name = narrow_to_wide(player->getName());
+
+ message += L"*** ";
+ message += name;
+ message += L" left game";
+ if(c.timeout)
+ message += L" (timed out)";
+ }
+
+ /*// Delete player
+ {
+ m_env.removePlayer(c.peer_id);
+ }*/
+
+ // Set player client disconnected
+ {
+ Player *player = m_env.getPlayer(c.peer_id);
+ if(player != NULL)
+ player->peer_id = 0;
+ }
+
+ // Delete client
+ delete m_clients[c.peer_id];
+ m_clients.remove(c.peer_id);
+
+ // Send player info to all remaining clients
+ SendPlayerInfos();
+
+ // Send leave chat message to all remaining clients
+ BroadcastChatMessage(message);
+
+ } // PEER_REMOVED
+ else
+ {
+ assert(0);
+ }
+}
+
+void Server::handlePeerChanges()
+{
+ while(m_peer_change_queue.size() > 0)
+ {
+ PeerChange c = m_peer_change_queue.pop_front();
+
+ dout_server<<"Server: Handling peer change: "
+ <<"id="<<c.peer_id<<", timeout="<<c.timeout
+ <<std::endl;
+
+ handlePeerChange(c);
+ }
+}
+
+void dedicated_server_loop(Server &server)
+{
+ DSTACK(__FUNCTION_NAME);
+
+ std::cout<<std::endl;
+ std::cout<<"========================"<<std::endl;
+ std::cout<<"Running dedicated server"<<std::endl;
+ std::cout<<"========================"<<std::endl;
+ std::cout<<std::endl;
+
+ for(;;)
+ {
+ // This is kind of a hack but can be done like this
+ // because server.step() is very light
+ sleep_ms(30);
+ server.step(0.030);
+
+ static int counter = 0;
+ counter--;
+ if(counter <= 0)
+ {
+ counter = 10;
+
+ core::list<PlayerInfo> list = server.getPlayerInfo();
+ core::list<PlayerInfo>::Iterator i;
+ static u32 sum_old = 0;
+ u32 sum = PIChecksum(list);
+ if(sum != sum_old)
+ {
+ std::cout<<DTIME<<"Player info:"<<std::endl;
+ for(i=list.begin(); i!=list.end(); i++)
+ {
+ i->PrintLine(&std::cout);
+ }
+ }
+ sum_old = sum;
+ }
+ }
+}
projects / oweals / minetest.git / blobdiff