void StaticObjectList::serialize(std::ostream &os)
{
// version
u8 version = 0;
writeU8(os, version);
// count
u16 count = m_stored.size() + m_active.size();
writeU16(os, count);
for(std::list<StaticObject>::iterator
i = m_stored.begin();
i != m_stored.end(); ++i)
{
StaticObject &s_obj = *i;
s_obj.serialize(os);
}
for(std::map<u16, StaticObject>::iterator
i = m_active.begin();
i != m_active.end(); ++i)
{
StaticObject s_obj = i->second;
s_obj.serialize(os);
}
}
/*
u16 command
u16 number of files requested
for each file {
u16 length of name
string name
}
*/
void Client::request_media(const std::vector<std::string> &file_requests)
{
std::ostringstream os(std::ios_base::binary);
writeU16(os, TOSERVER_REQUEST_MEDIA);
size_t file_requests_size = file_requests.size();
FATAL_ERROR_IF(file_requests_size > 0xFFFF, "Unsupported number of file requests");
// Packet dynamicly resized
NetworkPacket pkt(TOSERVER_REQUEST_MEDIA, 2 + 0);
pkt << (u16) (file_requests_size & 0xFFFF);
for(std::vector<std::string>::const_iterator i = file_requests.begin();
i != file_requests.end(); ++i) {
pkt << (*i);
}
Send(&pkt);
infostream << "Client: Sending media request list to server ("
<< file_requests.size() << " files. packet size)" << std::endl;
}
status WAVEFile::writeFormat()
{
uint16_t formatTag, channelCount;
uint32_t sampleRate, averageBytesPerSecond;
uint16_t blockAlign;
uint32_t chunkSize;
uint16_t bitsPerSample;
Track *track = getTrack();
fh->write("fmt ", 4);
switch (track->f.compressionType)
{
case AF_COMPRESSION_NONE:
chunkSize = 16;
if (track->f.sampleFormat == AF_SAMPFMT_FLOAT ||
track->f.sampleFormat == AF_SAMPFMT_DOUBLE)
{
formatTag = WAVE_FORMAT_IEEE_FLOAT;
}
else if (track->f.sampleFormat == AF_SAMPFMT_TWOSCOMP ||
track->f.sampleFormat == AF_SAMPFMT_UNSIGNED)
{
formatTag = WAVE_FORMAT_PCM;
}
else
{
_af_error(AF_BAD_COMPTYPE, "bad sample format");
return AF_FAIL;
}
blockAlign = _af_format_frame_size(&track->f, false);
bitsPerSample = 8 * _af_format_sample_size(&track->f, false);
break;
/*
G.711 compression uses eight bits per sample.
*/
case AF_COMPRESSION_G711_ULAW:
chunkSize = 18;
formatTag = IBM_FORMAT_MULAW;
blockAlign = track->f.channelCount;
bitsPerSample = 8;
break;
case AF_COMPRESSION_G711_ALAW:
chunkSize = 18;
formatTag = IBM_FORMAT_ALAW;
blockAlign = track->f.channelCount;
bitsPerSample = 8;
break;
default:
_af_error(AF_BAD_COMPTYPE, "bad compression type");
return AF_FAIL;
}
writeU32(&chunkSize);
writeU16(&formatTag);
channelCount = track->f.channelCount;
writeU16(&channelCount);
sampleRate = track->f.sampleRate;
writeU32(&sampleRate);
averageBytesPerSecond =
track->f.sampleRate * _af_format_frame_size(&track->f, false);
writeU32(&averageBytesPerSecond);
blockAlign = _af_format_frame_size(&track->f, false);
writeU16(&blockAlign);
writeU16(&bitsPerSample);
if (track->f.compressionType == AF_COMPRESSION_G711_ULAW ||
track->f.compressionType == AF_COMPRESSION_G711_ALAW)
{
uint16_t zero = 0;
writeU16(&zero);
}
return AF_SUCCEED;
}
void libcdr::CDRContentCollector::_generateBitmapFromPattern(librevenge::RVNGBinaryData &bitmap, const CDRPattern &pattern, const CDRColor &fgColor, const CDRColor &bgColor)
{
unsigned height = pattern.height;
unsigned width = pattern.width;
unsigned tmpPixelSize = (unsigned)(height * width);
if (tmpPixelSize < (unsigned)height) // overflow
return;
unsigned tmpDIBImageSize = tmpPixelSize * 4;
if (tmpPixelSize > tmpDIBImageSize) // overflow !!!
return;
unsigned tmpDIBOffsetBits = 14 + 40;
unsigned tmpDIBFileSize = tmpDIBOffsetBits + tmpDIBImageSize;
if (tmpDIBImageSize > tmpDIBFileSize) // overflow !!!
return;
// Create DIB file header
writeU16(bitmap, 0x4D42); // Type
writeU32(bitmap, (int)tmpDIBFileSize); // Size
writeU16(bitmap, 0); // Reserved1
writeU16(bitmap, 0); // Reserved2
writeU32(bitmap, (int)tmpDIBOffsetBits); // OffsetBits
// Create DIB Info header
writeU32(bitmap, 40); // Size
writeU32(bitmap, (int)width); // Width
writeU32(bitmap, (int)height); // Height
writeU16(bitmap, 1); // Planes
writeU16(bitmap, 32); // BitCount
writeU32(bitmap, 0); // Compression
writeU32(bitmap, (int)tmpDIBImageSize); // SizeImage
writeU32(bitmap, 0); // XPelsPerMeter
writeU32(bitmap, 0); // YPelsPerMeter
writeU32(bitmap, 0); // ColorsUsed
writeU32(bitmap, 0); // ColorsImportant
// The Bitmaps in CDR are padded to 32bit border
unsigned lineWidth = (width + 7) / 8;
unsigned foreground = m_ps._getRGBColor(fgColor);
unsigned background = m_ps._getRGBColor(bgColor);
for (unsigned j = height; j > 0; --j)
{
unsigned i = 0;
unsigned k = 0;
while (i <lineWidth && k < width)
{
unsigned l = 0;
unsigned char c = 0;
const unsigned index = (j-1)*lineWidth+i;
if (index < pattern.pattern.size())
c = pattern.pattern[index];
i++;
while (k < width && l < 8)
{
if (c & 0x80)
writeU32(bitmap, (int)background);
else
writeU32(bitmap, (int)foreground);
c <<= 1;
l++;
k++;
}
}
}
}
void libcdr::CDRStylesCollector::collectBmp(unsigned imageId, unsigned colorModel, unsigned width, unsigned height, unsigned bpp, const std::vector<unsigned> &palette, const std::vector<unsigned char> &bitmap)
{
libcdr::CDRInternalStream stream(bitmap);
librevenge::RVNGBinaryData image;
unsigned tmpPixelSize = (unsigned)(height * width);
if (tmpPixelSize < (unsigned)height) // overflow
return;
unsigned tmpDIBImageSize = tmpPixelSize * 4;
if (tmpPixelSize > tmpDIBImageSize) // overflow !!!
return;
unsigned tmpDIBOffsetBits = 14 + 40;
unsigned tmpDIBFileSize = tmpDIBOffsetBits + tmpDIBImageSize;
if (tmpDIBImageSize > tmpDIBFileSize) // overflow !!!
return;
// Create DIB file header
writeU16(image, 0x4D42); // Type
writeU32(image, tmpDIBFileSize); // Size
writeU16(image, 0); // Reserved1
writeU16(image, 0); // Reserved2
writeU32(image, tmpDIBOffsetBits); // OffsetBits
// Create DIB Info header
writeU32(image, 40); // Size
writeU32(image, width); // Width
writeU32(image, height); // Height
writeU16(image, 1); // Planes
writeU16(image, 32); // BitCount
writeU32(image, 0); // Compression
writeU32(image, tmpDIBImageSize); // SizeImage
writeU32(image, 0); // XPelsPerMeter
writeU32(image, 0); // YPelsPerMeter
writeU32(image, 0); // ColorsUsed
writeU32(image, 0); // ColorsImportant
// Cater for eventual padding
unsigned lineWidth = bitmap.size() / height;
bool storeBMP = true;
for (unsigned j = 0; j < height; ++j)
{
unsigned i = 0;
unsigned k = 0;
if (colorModel == 6)
{
while (i <lineWidth && k < width)
{
unsigned l = 0;
unsigned char c = bitmap[j*lineWidth+i];
i++;
while (k < width && l < 8)
{
if (c & 0x80)
writeU32(image, 0xffffff);
else
writeU32(image, 0);
c <<= 1;
l++;
k++;
}
}
}
else if (colorModel == 5)
{
while (i <lineWidth && i < width)
{
unsigned char c = bitmap[j*lineWidth+i];
i++;
writeU32(image, m_ps.getBMPColor(libcdr::CDRColor(colorModel, c)));
}
}
else if (!palette.empty())
{
while (i < lineWidth && i < width)
{
unsigned char c = bitmap[j*lineWidth+i];
if (c >= palette.size())
c = palette.size() - 1;
i++;
writeU32(image, m_ps.getBMPColor(libcdr::CDRColor(colorModel, palette[c])));
}
}
else if (bpp == 24)
{
while (i < lineWidth && k < width)
{
unsigned c = ((unsigned)bitmap[j*lineWidth+i+2] << 16) | ((unsigned)bitmap[j*lineWidth+i+1] << 8) | ((unsigned)bitmap[j*lineWidth+i]);
i += 3;
writeU32(image, m_ps.getBMPColor(libcdr::CDRColor(colorModel, c)));
k++;
}
}
else if (bpp == 32)
{
while (i < lineWidth && k < width)
{
unsigned c = (bitmap[j*lineWidth+i+3] << 24) | (bitmap[j*lineWidth+i+2] << 16) | (bitmap[j*lineWidth+i+1] << 8) | (bitmap[j*lineWidth+i]);
i += 4;
writeU32(image, m_ps.getBMPColor(libcdr::CDRColor(colorModel, c)));
k++;
}
}
else
storeBMP = false;
}
if (storeBMP)
{
#if DUMP_IMAGE
librevenge::RVNGString filename;
filename.sprintf("bitmap%.8x.bmp", imageId);
FILE *f = fopen(filename.cstr(), "wb");
if (f)
{
const unsigned char *tmpBuffer = image.getDataBuffer();
for (unsigned long k = 0; k < image.size(); k++)
fprintf(f, "%c",tmpBuffer[k]);
fclose(f);
}
#endif
m_ps.m_bmps[imageId] = image;
}
}
/**
* 文字列として書き出す。
* 頭2byteに文字数（＋NULL文字）、続くn byteに文字＋NULL終端が書き込まれる
* | (u16)data.char_length + 1 | (charactor)string + NULL |
*/
void BinaryOutputStream::writeString(const String data) {
const u16 data_lenght = (data.length() + 1);
writeU16(data_lenght);
stream->write((u8*) data.c_str(), data_lenght);
}
/*
sender_peer_id given to this shall be quaranteed to be a valid peer
*/
void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
{
DSTACK(__FUNCTION_NAME);
// Ignore packets that don't even fit a command
if(datasize < 2)
{
m_packetcounter.add(60000);
return;
}
ToClientCommand command = (ToClientCommand)readU16(&data[0]);
//infostream<<"Client: received command="<<command<<std::endl;
m_packetcounter.add((u16)command);
/*
If this check is removed, be sure to change the queue
system to know the ids
*/
if(sender_peer_id != PEER_ID_SERVER)
{
infostream<<"Client::ProcessData(): Discarding data not "
"coming from server: peer_id="<<sender_peer_id
<<std::endl;
return;
}
u8 ser_version = m_server_ser_ver;
//infostream<<"Client received command="<<(int)command<<std::endl;
if(command == TOCLIENT_INIT)
{
if(datasize < 3)
return;
u8 deployed = data[2];
infostream<<"Client: TOCLIENT_INIT received with "
"deployed="<<((int)deployed&0xff)<<std::endl;
if(deployed < SER_FMT_VER_LOWEST
|| deployed > SER_FMT_VER_HIGHEST)
{
infostream<<"Client: TOCLIENT_INIT: Server sent "
<<"unsupported ser_fmt_ver"<<std::endl;
return;
}
m_server_ser_ver = deployed;
// Get player position
v3s16 playerpos_s16(0, BS*2+BS*20, 0);
if(datasize >= 2+1+6)
playerpos_s16 = readV3S16(&data[2+1]);
v3f playerpos_f = intToFloat(playerpos_s16, BS) - v3f(0, BS/2, 0);
{ //envlock
//JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
// Set player position
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
player->setPosition(playerpos_f);
}
if(datasize >= 2+1+6+8)
{
// Get map seed
m_map_seed = readU64(&data[2+1+6]);
infostream<<"Client: received map seed: "<<m_map_seed<<std::endl;
}
// Reply to server
u32 replysize = 2;
SharedBuffer<u8> reply(replysize);
writeU16(&reply[0], TOSERVER_INIT2);
// Send as reliable
m_con.Send(PEER_ID_SERVER, 1, reply, true);
return;
}
if(command == TOCLIENT_ACCESS_DENIED)
{
// The server didn't like our password. Note, this needs
// to be processed even if the serialisation format has
// not been agreed yet, the same as TOCLIENT_INIT.
m_access_denied = true;
m_access_denied_reason = L"Unknown";
if(datasize >= 4)
{
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
m_access_denied_reason = deSerializeWideString(is);
}
return;
}
if(ser_version == SER_FMT_VER_INVALID)
{
infostream<<"Client: Server serialization"
" format invalid or not initialized."
" Skipping incoming command="<<command<<std::endl;
return;
}
// Just here to avoid putting the two if's together when
// making some copypasta
{}
if(command == TOCLIENT_REMOVENODE)
{
if(datasize < 8)
return;
v3s16 p;
p.X = readS16(&data[2]);
p.Y = readS16(&data[4]);
p.Z = readS16(&data[6]);
//TimeTaker t1("TOCLIENT_REMOVENODE");
// This will clear the cracking animation after digging
((ClientMap&)m_env.getMap()).clearTempMod(p);
removeNode(p);
}
else if(command == TOCLIENT_ADDNODE)
{
if(datasize < 8 + MapNode::serializedLength(ser_version))
return;
v3s16 p;
p.X = readS16(&data[2]);
p.Y = readS16(&data[4]);
p.Z = readS16(&data[6]);
//TimeTaker t1("TOCLIENT_ADDNODE");
MapNode n;
n.deSerialize(&data[8], ser_version);
addNode(p, n);
}
else if(command == TOCLIENT_BLOCKDATA)
{
// Ignore too small packet
if(datasize < 8)
return;
v3s16 p;
p.X = readS16(&data[2]);
p.Y = readS16(&data[4]);
p.Z = readS16(&data[6]);
/*infostream<<"Client: Thread: BLOCKDATA for ("
<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
/*infostream<<"Client: Thread: BLOCKDATA for ("
<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
std::string datastring((char*)&data[8], datasize-8);
std::istringstream istr(datastring, std::ios_base::binary);
MapSector *sector;
MapBlock *block;
v2s16 p2d(p.X, p.Z);
sector = m_env.getMap().emergeSector(p2d);
assert(sector->getPos() == p2d);
//TimeTaker timer("MapBlock deSerialize");
// 0ms
block = sector->getBlockNoCreateNoEx(p.Y);
if(block)
{
/*
Update an existing block
*/
//infostream<<"Updating"<<std::endl;
block->deSerialize(istr, ser_version);
}
else
{
/*
Create a new block
*/
//infostream<<"Creating new"<<std::endl;
block = new MapBlock(&m_env.getMap(), p);
block->deSerialize(istr, ser_version);
sector->insertBlock(block);
//DEBUG
/*NodeMod mod;
mod.type = NODEMOD_CHANGECONTENT;
mod.param = CONTENT_MESE;
block->setTempMod(v3s16(8,10,8), mod);
block->setTempMod(v3s16(8,9,8), mod);
block->setTempMod(v3s16(8,8,8), mod);
block->setTempMod(v3s16(8,7,8), mod);
block->setTempMod(v3s16(8,6,8), mod);*/
}
#if 0
/*
Acknowledge block
*/
/*
[0] u16 command
[2] u8 count
[3] v3s16 pos_0
[3+6] v3s16 pos_1
...
*/
u32 replysize = 2+1+6;
SharedBuffer<u8> reply(replysize);
writeU16(&reply[0], TOSERVER_GOTBLOCKS);
reply[2] = 1;
writeV3S16(&reply[3], p);
// Send as reliable
m_con.Send(PEER_ID_SERVER, 1, reply, true);
#endif
/*
Update Mesh of this block and blocks at x-, y- and z-.
Environment should not be locked as it interlocks with the
main thread, from which is will want to retrieve textures.
*/
//m_env.getClientMap().updateMeshes(block->getPos(), getDayNightRatio());
/*
Add it to mesh update queue and set it to be acknowledged after update.
*/
//infostream<<"Adding mesh update task for received block"<<std::endl;
addUpdateMeshTaskWithEdge(p, true);
}
else if(command == TOCLIENT_PLAYERPOS)
{
infostream<<"Received deprecated TOCLIENT_PLAYERPOS"
<<std::endl;
/*u16 our_peer_id;
{
//JMutexAutoLock lock(m_con_mutex); //bulk comment-out
our_peer_id = m_con.GetPeerID();
}
// Cancel if we don't have a peer id
if(our_peer_id == PEER_ID_INEXISTENT){
infostream<<"TOCLIENT_PLAYERPOS cancelled: "
"we have no peer id"
<<std::endl;
return;
}*/
{ //envlock
//JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
u32 player_size = 2+12+12+4+4;
u32 player_count = (datasize-2) / player_size;
u32 start = 2;
for(u32 i=0; i<player_count; i++)
{
u16 peer_id = readU16(&data[start]);
Player *player = m_env.getPlayer(peer_id);
// Skip if player doesn't exist
if(player == NULL)
{
start += player_size;
continue;
}
// Skip if player is local player
if(player->isLocal())
{
start += player_size;
continue;
}
v3s32 ps = readV3S32(&data[start+2]);
v3s32 ss = readV3S32(&data[start+2+12]);
s32 pitch_i = readS32(&data[start+2+12+12]);
s32 yaw_i = readS32(&data[start+2+12+12+4]);
/*infostream<<"Client: got "
<<"pitch_i="<<pitch_i
<<" yaw_i="<<yaw_i<<std::endl;*/
f32 pitch = (f32)pitch_i / 100.0;
f32 yaw = (f32)yaw_i / 100.0;
v3f position((f32)ps.X/100., (f32)ps.Y/100., (f32)ps.Z/100.);
v3f speed((f32)ss.X/100., (f32)ss.Y/100., (f32)ss.Z/100.);
player->setPosition(position);
player->setSpeed(speed);
player->setPitch(pitch);
player->setYaw(yaw);
/*infostream<<"Client: player "<<peer_id
<<" pitch="<<pitch
<<" yaw="<<yaw<<std::endl;*/
start += player_size;
}
} //envlock
}
else if(command == TOCLIENT_PLAYERINFO)
{
u16 our_peer_id;
{
//JMutexAutoLock lock(m_con_mutex); //bulk comment-out
our_peer_id = m_con.GetPeerID();
}
// Cancel if we don't have a peer id
if(our_peer_id == PEER_ID_INEXISTENT){
infostream<<"TOCLIENT_PLAYERINFO cancelled: "
"we have no peer id"
<<std::endl;
return;
}
//infostream<<"Client: Server reports players:"<<std::endl;
{ //envlock
//JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
u32 item_size = 2+PLAYERNAME_SIZE;
u32 player_count = (datasize-2) / item_size;
u32 start = 2;
// peer_ids
core::list<u16> players_alive;
for(u32 i=0; i<player_count; i++)
{
// Make sure the name ends in '\0'
data[start+2+20-1] = 0;
u16 peer_id = readU16(&data[start]);
players_alive.push_back(peer_id);
/*infostream<<"peer_id="<<peer_id
<<" name="<<((char*)&data[start+2])<<std::endl;*/
// Don't update the info of the local player
if(peer_id == our_peer_id)
{
start += item_size;
continue;
}
Player *player = m_env.getPlayer(peer_id);
// Create a player if it doesn't exist
if(player == NULL)
{
player = new RemotePlayer(
m_device->getSceneManager()->getRootSceneNode(),
m_device,
-1);
player->peer_id = peer_id;
m_env.addPlayer(player);
infostream<<"Client: Adding new player "
<<peer_id<<std::endl;
}
player->updateName((char*)&data[start+2]);
start += item_size;
}
/*
Remove those players from the environment that
weren't listed by the server.
*/
//infostream<<"Removing dead players"<<std::endl;
core::list<Player*> players = m_env.getPlayers();
core::list<Player*>::Iterator ip;
for(ip=players.begin(); ip!=players.end(); ip++)
{
// Ingore local player
if((*ip)->isLocal())
continue;
// Warn about a special case
if((*ip)->peer_id == 0)
{
infostream<<"Client: Removing "
"dead player with id=0"<<std::endl;
}
bool is_alive = false;
core::list<u16>::Iterator i;
for(i=players_alive.begin(); i!=players_alive.end(); i++)
{
if((*ip)->peer_id == *i)
{
is_alive = true;
break;
}
}
/*infostream<<"peer_id="<<((*ip)->peer_id)
<<" is_alive="<<is_alive<<std::endl;*/
if(is_alive)
continue;
infostream<<"Removing dead player "<<(*ip)->peer_id
<<std::endl;
m_env.removePlayer((*ip)->peer_id);
}
} //envlock
}
else if(command == TOCLIENT_SECTORMETA)
{
infostream<<"Client received DEPRECATED TOCLIENT_SECTORMETA"<<std::endl;
#if 0
/*
[0] u16 command
[2] u8 sector count
[3...] v2s16 pos + sector metadata
*/
if(datasize < 3)
return;
//infostream<<"Client received TOCLIENT_SECTORMETA"<<std::endl;
{ //envlock
//JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
u8 buf[4];
is.read((char*)buf, 1);
u16 sector_count = readU8(buf);
//infostream<<"sector_count="<<sector_count<<std::endl;
for(u16 i=0; i<sector_count; i++)
{
// Read position
is.read((char*)buf, 4);
v2s16 pos = readV2S16(buf);
/*infostream<<"Client: deserializing sector at "
<<"("<<pos.X<<","<<pos.Y<<")"<<std::endl;*/
// Create sector
assert(m_env.getMap().mapType() == MAPTYPE_CLIENT);
((ClientMap&)m_env.getMap()).deSerializeSector(pos, is);
}
} //envlock
#endif
}
else if(command == TOCLIENT_INVENTORY)
{
if(datasize < 3)
return;
//TimeTaker t1("Parsing TOCLIENT_INVENTORY", m_device);
{ //envlock
//TimeTaker t2("mutex locking", m_device);
//JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
//t2.stop();
//TimeTaker t3("istringstream init", m_device);
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
//t3.stop();
//m_env.printPlayers(infostream);
//TimeTaker t4("player get", m_device);
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
//t4.stop();
//TimeTaker t1("inventory.deSerialize()", m_device);
player->inventory.deSerialize(is);
//t1.stop();
m_inventory_updated = true;
//infostream<<"Client got player inventory:"<<std::endl;
//player->inventory.print(infostream);
}
}
//DEBUG
else if(command == TOCLIENT_OBJECTDATA)
{
// Strip command word and create a stringstream
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
u8 buf[12];
/*
Read players
*/
is.read((char*)buf, 2);
u16 playercount = readU16(buf);
for(u16 i=0; i<playercount; i++)
{
is.read((char*)buf, 2);
u16 peer_id = readU16(buf);
is.read((char*)buf, 12);
v3s32 p_i = readV3S32(buf);
is.read((char*)buf, 12);
v3s32 s_i = readV3S32(buf);
is.read((char*)buf, 4);
s32 pitch_i = readS32(buf);
is.read((char*)buf, 4);
s32 yaw_i = readS32(buf);
Player *player = m_env.getPlayer(peer_id);
// Skip if player doesn't exist
if(player == NULL)
{
continue;
}
// Skip if player is local player
if(player->isLocal())
{
continue;
}
f32 pitch = (f32)pitch_i / 100.0;
f32 yaw = (f32)yaw_i / 100.0;
v3f position((f32)p_i.X/100., (f32)p_i.Y/100., (f32)p_i.Z/100.);
v3f speed((f32)s_i.X/100., (f32)s_i.Y/100., (f32)s_i.Z/100.);
player->setPosition(position);
player->setSpeed(speed);
player->setPitch(pitch);
player->setYaw(yaw);
}
/*
Read block objects
NOTE: Deprecated stuff
*/
// Read active block count
u16 blockcount = readU16(is);
if(blockcount != 0){
infostream<<"TOCLIENT_OBJECTDATA: blockcount != 0 "
"not supported"<<std::endl;
return;
}
}
else if(command == TOCLIENT_TIME_OF_DAY)
{
if(datasize < 4)
return;
u16 time_of_day = readU16(&data[2]);
time_of_day = time_of_day % 24000;
//infostream<<"Client: time_of_day="<<time_of_day<<std::endl;
/*
time_of_day:
0 = midnight
12000 = midday
*/
{
m_env.setTimeOfDay(time_of_day);
u32 dr = m_env.getDayNightRatio();
infostream<<"Client: time_of_day="<<time_of_day
<<", dr="<<dr
<<std::endl;
}
}
else if(command == TOCLIENT_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);
}
/*infostream<<"Client received chat message: "
<<wide_to_narrow(message)<<std::endl;*/
m_chat_queue.push_back(message);
}
else if(command == TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD)
{
//if(g_settings->getBool("enable_experimental"))
{
/*
u16 command
u16 count of removed objects
for all removed objects {
u16 id
}
u16 count of added objects
for all added objects {
u16 id
u8 type
u32 initialization data length
string initialization data
}
*/
char buf[6];
// Get all data except the command number
std::string datastring((char*)&data[2], datasize-2);
// Throw them in an istringstream
std::istringstream is(datastring, std::ios_base::binary);
// Read stuff
// Read removed objects
is.read(buf, 2);
u16 removed_count = readU16((u8*)buf);
for(u16 i=0; i<removed_count; i++)
{
is.read(buf, 2);
u16 id = readU16((u8*)buf);
// Remove it
{
//JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
m_env.removeActiveObject(id);
}
}
// Read added objects
is.read(buf, 2);
u16 added_count = readU16((u8*)buf);
for(u16 i=0; i<added_count; i++)
{
is.read(buf, 2);
u16 id = readU16((u8*)buf);
is.read(buf, 1);
u8 type = readU8((u8*)buf);
std::string data = deSerializeLongString(is);
// Add it
{
//JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
m_env.addActiveObject(id, type, data);
}
}
}
}
else if(command == TOCLIENT_ACTIVE_OBJECT_MESSAGES)
{
//if(g_settings->getBool("enable_experimental"))
{
/*
u16 command
for all objects
{
u16 id
u16 message length
string message
}
*/
char buf[6];
// Get all data except the command number
std::string datastring((char*)&data[2], datasize-2);
// Throw them in an istringstream
std::istringstream is(datastring, std::ios_base::binary);
while(is.eof() == false)
{
// Read stuff
is.read(buf, 2);
u16 id = readU16((u8*)buf);
if(is.eof())
break;
is.read(buf, 2);
u16 message_size = readU16((u8*)buf);
std::string message;
message.reserve(message_size);
for(u16 i=0; i<message_size; i++)
{
is.read(buf, 1);
message.append(buf, 1);
}
// Pass on to the environment
{
//JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
m_env.processActiveObjectMessage(id, message);
}
}
}
}
else if(command == TOCLIENT_HP)
{
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
u8 hp = readU8(is);
player->hp = hp;
}
else if(command == TOCLIENT_MOVE_PLAYER)
{
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
v3f pos = readV3F1000(is);
f32 pitch = readF1000(is);
f32 yaw = readF1000(is);
player->setPosition(pos);
/*player->setPitch(pitch);
player->setYaw(yaw);*/
infostream<<"Client got TOCLIENT_MOVE_PLAYER"
<<" pos=("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"
<<" pitch="<<pitch
<<" yaw="<<yaw
<<std::endl;
/*
Add to ClientEvent queue.
This has to be sent to the main program because otherwise
it would just force the pitch and yaw values to whatever
the camera points to.
*/
ClientEvent event;
event.type = CE_PLAYER_FORCE_MOVE;
event.player_force_move.pitch = pitch;
event.player_force_move.yaw = yaw;
m_client_event_queue.push_back(event);
// Ignore damage for a few seconds, so that the player doesn't
// get damage from falling on ground
m_ignore_damage_timer = 3.0;
}
else if(command == TOCLIENT_PLAYERITEM)
{
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
u16 count = readU16(is);
for (u16 i = 0; i < count; ++i) {
u16 peer_id = readU16(is);
Player *player = m_env.getPlayer(peer_id);
if (player == NULL)
{
infostream<<"Client: ignoring player item "
<< deSerializeString(is)
<< " for non-existing peer id " << peer_id
<< std::endl;
continue;
} else if (player->isLocal()) {
infostream<<"Client: ignoring player item "
<< deSerializeString(is)
<< " for local player" << std::endl;
continue;
} else {
InventoryList *inv = player->inventory.getList("main");
std::string itemstring(deSerializeString(is));
if (itemstring.empty()) {
inv->deleteItem(0);
infostream
<<"Client: empty player item for peer "
<< peer_id << std::endl;
} else {
std::istringstream iss(itemstring);
delete inv->changeItem(0, InventoryItem::deSerialize(iss));
infostream<<"Client: player item for peer " << peer_id << ": ";
player->getWieldItem()->serialize(infostream);
infostream<<std::endl;
}
}
}
}
else if(command == TOCLIENT_DEATHSCREEN)
{
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
bool set_camera_point_target = readU8(is);
v3f camera_point_target = readV3F1000(is);
ClientEvent event;
event.type = CE_DEATHSCREEN;
event.deathscreen.set_camera_point_target = set_camera_point_target;
event.deathscreen.camera_point_target_x = camera_point_target.X;
event.deathscreen.camera_point_target_y = camera_point_target.Y;
event.deathscreen.camera_point_target_z = camera_point_target.Z;
m_client_event_queue.push_back(event);
}
else
{
infostream<<"Client: Ignoring unknown command "
<<command<<std::endl;
}
}
/************************************************************************************
*
* ***********************************************************************************/
void ScopeDome::TimerHit()
{
if (!isConnected())
return; // No need to reset timer if we are not connected anymore
readU16(GetStatus, currentStatus);
// LOGF_INFO("Status: %x", currentStatus);
UpdatePosition();
UpdateShutterStatus();
IDSetSwitch(&DomeShutterSP, nullptr);
UpdateRelayStatus();
if (status == DOME_HOMING)
{
if ((currentStatus & 8) == 0 && getInputState(IN_HOME))
{
// Found home
status = DOME_READY;
targetAz = DomeHomePositionN[0].value;
// Reset counter
writeCmd(ResetCounter);
FindHomeSP.s = IPS_OK;
DomeAbsPosNP.s = IPS_OK;
IDSetSwitch(&FindHomeSP, nullptr);
}
IDSetNumber(&DomeAbsPosNP, nullptr);
}
else if (status == DOME_DEROTATING)
{
if ((currentStatus & 2) == 0)
{
readS32(GetCounterExt, currentRotation);
LOGF_INFO("Current rotation is %d", currentRotation);
if (abs(currentRotation) < 100)
{
// Close enough
status = DOME_READY;
DerotateSP.s = IPS_OK;
DomeAbsPosNP.s = IPS_OK;
IDSetSwitch(&DerotateSP, nullptr);
}
else
{
if (currentRotation < 0)
{
writeU16(CCWRotation, compensateInertia(-currentRotation));
}
else
{
writeU16(CWRotation, compensateInertia(currentRotation));
}
}
}
IDSetNumber(&DomeAbsPosNP, nullptr);
}
else if (DomeAbsPosNP.s == IPS_BUSY)
{
if ((currentStatus & 2) == 0)
{
// Rotation idle, are we close enough?
double azDiff = targetAz - DomeAbsPosN[0].value;
if (azDiff > 180)
{
azDiff -= 360;
}
if (azDiff < -180)
{
azDiff += 360;
}
if (fabs(azDiff) <= DomeParamN[0].value)
{
DomeAbsPosN[0].value = targetAz;
DomeAbsPosNP.s = IPS_OK;
LOG_INFO("Dome reached requested azimuth angle.");
if (getDomeState() == DOME_PARKING)
{
if (ParkShutterS[0].s == ISS_ON && getInputState(IN_CLOSED1) == ISS_OFF)
{
ControlShutter(SHUTTER_CLOSE);
}
else
{
SetParked(true);
}
}
else if (getDomeState() == DOME_UNPARKING)
SetParked(false);
else
setDomeState(DOME_SYNCED);
}
else
{
// Refine azimuth
MoveAbs(targetAz);
}
}
IDSetNumber(&DomeAbsPosNP, nullptr);
}
else
IDSetNumber(&DomeAbsPosNP, nullptr);
// Read temperatures only every 10th time
static int tmpCounter = 0;
if (--tmpCounter <= 0)
{
UpdateSensorStatus();
tmpCounter = 10;
}
SetTimer(POLLMS);
}
uv_err_t UVDData::write16(uint32_t offset, int16_t in, uint32_t endianness)
{
return UV_DEBUG(writeU16(offset, (uint16_t)in, endianness));
}
void MapBlock::serialize(std::ostream &os, u8 version, bool disk)
{
if(!ser_ver_supported(version))
throw VersionMismatchException("ERROR: MapBlock format not supported");
if (!data)
throw SerializationError("ERROR: Not writing dummy block.");
FATAL_ERROR_IF(version < SER_FMT_VER_LOWEST_WRITE, "Serialisation version error");
// First byte
u8 flags = 0;
if(is_underground)
flags |= 0x01;
if(getDayNightDiff())
flags |= 0x02;
if(m_generated == false)
flags |= 0x08;
writeU8(os, flags);
if (version >= 27) {
writeU16(os, m_lighting_complete);
}
/*
Bulk node data
*/
NameIdMapping nimap;
if(disk)
{
MapNode *tmp_nodes = new MapNode[nodecount];
for(u32 i=0; i<nodecount; i++)
tmp_nodes[i] = data[i];
getBlockNodeIdMapping(&nimap, tmp_nodes, m_gamedef->ndef());
u8 content_width = 2;
u8 params_width = 2;
writeU8(os, content_width);
writeU8(os, params_width);
MapNode::serializeBulk(os, version, tmp_nodes, nodecount,
content_width, params_width, true);
delete[] tmp_nodes;
}
else
{
u8 content_width = 2;
u8 params_width = 2;
writeU8(os, content_width);
writeU8(os, params_width);
MapNode::serializeBulk(os, version, data, nodecount,
content_width, params_width, true);
}
/*
Node metadata
*/
std::ostringstream oss(std::ios_base::binary);
m_node_metadata.serialize(oss, version, disk);
compressZlib(oss.str(), os);
/*
Data that goes to disk, but not the network
*/
if(disk)
{
if(version <= 24){
// Node timers
m_node_timers.serialize(os, version);
}
// Static objects
m_static_objects.serialize(os);
// Timestamp
writeU32(os, getTimestamp());
// Write block-specific node definition id mapping
nimap.serialize(os);
if(version >= 25){
// Node timers
m_node_timers.serialize(os, version);
}
}
}
void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
{
// protocol_version >= 36
u8 version = 12;
writeU8(os, version);
// general
os << serializeString(name);
writeU16(os, groups.size());
for (const auto &group : groups) {
os << serializeString(group.first);
writeS16(os, group.second);
}
writeU8(os, param_type);
writeU8(os, param_type_2);
// visual
writeU8(os, drawtype);
os << serializeString(mesh);
writeF1000(os, visual_scale);
writeU8(os, 6);
for (const TileDef &td : tiledef)
td.serialize(os, protocol_version);
for (const TileDef &td : tiledef_overlay)
td.serialize(os, protocol_version);
writeU8(os, CF_SPECIAL_COUNT);
for (const TileDef &td : tiledef_special) {
td.serialize(os, protocol_version);
}
writeU8(os, alpha);
writeU8(os, color.getRed());
writeU8(os, color.getGreen());
writeU8(os, color.getBlue());
os << serializeString(palette_name);
writeU8(os, waving);
writeU8(os, connect_sides);
writeU16(os, connects_to_ids.size());
for (u16 connects_to_id : connects_to_ids)
writeU16(os, connects_to_id);
writeU8(os, post_effect_color.getAlpha());
writeU8(os, post_effect_color.getRed());
writeU8(os, post_effect_color.getGreen());
writeU8(os, post_effect_color.getBlue());
writeU8(os, leveled);
// lighting
writeU8(os, light_propagates);
writeU8(os, sunlight_propagates);
writeU8(os, light_source);
// map generation
writeU8(os, is_ground_content);
// interaction
writeU8(os, walkable);
writeU8(os, pointable);
writeU8(os, diggable);
writeU8(os, climbable);
writeU8(os, buildable_to);
writeU8(os, rightclickable);
writeU32(os, damage_per_second);
// liquid
writeU8(os, liquid_type);
os << serializeString(liquid_alternative_flowing);
os << serializeString(liquid_alternative_source);
writeU8(os, liquid_viscosity);
writeU8(os, liquid_renewable);
writeU8(os, liquid_range);
writeU8(os, drowning);
writeU8(os, floodable);
// node boxes
node_box.serialize(os, protocol_version);
selection_box.serialize(os, protocol_version);
collision_box.serialize(os, protocol_version);
// sound
serializeSimpleSoundSpec(sound_footstep, os, version);
serializeSimpleSoundSpec(sound_dig, os, version);
serializeSimpleSoundSpec(sound_dug, os, version);
// legacy
writeU8(os, legacy_facedir_simple);
writeU8(os, legacy_wallmounted);
os << serializeString(node_dig_prediction);
}
status AVRFile::writeInit(AFfilesetup setup)
{
if (initFromSetup(setup) == AF_FAIL)
return AF_FAIL;
if (m_fh->seek(0, File::SeekFromBeginning) != 0)
{
_af_error(AF_BAD_LSEEK, "bad seek");
return AF_FAIL;
}
Track *track = getTrack();
char name[8];
uint16_t mono, resolution, sign, loop, midi;
uint32_t rate, size, loopStart, loopEnd;
char reserved[26];
char user[64];
m_fh->write("2BIT", 4);
memset(name, 0, 8);
if (m_fileName != NULL)
strncpy(name, af_basename(m_fileName), 8);
m_fh->write(name, 8);
if (track->f.channelCount == 1)
mono = 0x0;
else
mono = 0xffff;
writeU16(&mono);
resolution = track->f.sampleWidth;
writeU16(&resolution);
if (track->f.sampleFormat == AF_SAMPFMT_UNSIGNED)
sign = 0x0;
else
sign = 0xffff;
writeU16(&sign);
/* We do not currently support loops. */
loop = 0;
writeU16(&loop);
midi = 0xffff;
writeU16(&midi);
rate = track->f.sampleRate;
/* Set the high-order byte of rate to 0xff. */
rate |= 0xff000000;
size = track->totalfframes;
loopStart = 0;
loopEnd = size;
writeU32(&rate);
writeU32(&size);
writeU32(&loopStart);
writeU32(&loopEnd);
memset(reserved, 0, 26);
m_fh->write(reserved, 26);
memset(user, 0, 64);
m_fh->write(user, 64);
if (track->fpos_first_frame == 0)
track->fpos_first_frame = m_fh->tell();
return AF_SUCCEED;
}
void process(void)
{
FILE *outfile;
u8 *fwdata;
u8 *GCfwdata;
int bytes, GCbytes=-1;
if(verbose) printf("Create file '%s'\n", outfilename);
if ((outfile = fopen(outfilename, "wb")) == NULL)
{
fprintf(stderr, "Can't open output file '%s'\n", outfilename);
return;
}
else
{
FWHeader *header;
//write_file(outfile, f);
bytes=load_file(STMinfile,&fwdata,1);
//read stm part
if(bytes<FW_HEADER_OFFSET+sizeof(FWHeader))
{
fprintf(stderr,"File too small to be valid\n");
return;
}
//embed cksum to stm32 fw
embed_checksum(fwdata,bytes);
//read gc part
if(GCinfile!=NULL)
{
GCbytes=load_file(GCinfile,&GCfwdata,0);
if(verify_GC_firmware(GCfwdata,GCbytes)==0)
{
fprintf(stderr,"GC firmware file not correct for this device\n");
return;
}
}
//write header
writeU32(outfile,'WFDG');//writes "GDFW"
writeU16(outfile,300); //BL file version
writeU16(outfile,4000); //Target drive type
writeU32(outfile,bytes); //num of bytes of STM32 FW
writeU32(outfile,GCbytes); //num of bytes of GC FW
//write stm32 part
write_file(outfile,bytes,fwdata);
//write gc part
if(GCinfile!=NULL)
{
write_file(outfile,GCbytes,GCfwdata);
}
writeU32(outfile,outFileChecksum);
fclose(outfile);
}
}
//// Serialization of old ContentFeatures formats
void ContentFeatures::serializeOld(std::ostream &os, u16 protocol_version) const
{
if (protocol_version == 13)
{
writeU8(os, 5); // version
os<<serializeString(name);
writeU16(os, groups.size());
for (ItemGroupList::const_iterator
i = groups.begin(); i != groups.end(); ++i) {
os<<serializeString(i->first);
writeS16(os, i->second);
}
writeU8(os, drawtype);
writeF1000(os, visual_scale);
writeU8(os, 6);
for (u32 i = 0; i < 6; i++)
tiledef[i].serialize(os, protocol_version);
//CF_SPECIAL_COUNT = 2 before cf ver. 7 and protocol ver. 24
writeU8(os, 2);
for (u32 i = 0; i < 2; i++)
tiledef_special[i].serialize(os, protocol_version);
writeU8(os, alpha);
writeU8(os, post_effect_color.getAlpha());
writeU8(os, post_effect_color.getRed());
writeU8(os, post_effect_color.getGreen());
writeU8(os, post_effect_color.getBlue());
writeU8(os, param_type);
writeU8(os, param_type_2);
writeU8(os, is_ground_content);
writeU8(os, light_propagates);
writeU8(os, sunlight_propagates);
writeU8(os, walkable);
writeU8(os, pointable);
writeU8(os, diggable);
writeU8(os, climbable);
writeU8(os, buildable_to);
os<<serializeString(""); // legacy: used to be metadata_name
writeU8(os, liquid_type);
os<<serializeString(liquid_alternative_flowing);
os<<serializeString(liquid_alternative_source);
writeU8(os, liquid_viscosity);
writeU8(os, light_source);
writeU32(os, damage_per_second);
node_box.serialize(os, protocol_version);
selection_box.serialize(os, protocol_version);
writeU8(os, legacy_facedir_simple);
writeU8(os, legacy_wallmounted);
serializeSimpleSoundSpec(sound_footstep, os);
serializeSimpleSoundSpec(sound_dig, os);
serializeSimpleSoundSpec(sound_dug, os);
}
else if (protocol_version > 13 && protocol_version < 24) {
writeU8(os, 6); // version
os<<serializeString(name);
writeU16(os, groups.size());
for (ItemGroupList::const_iterator
i = groups.begin(); i != groups.end(); ++i) {
os<<serializeString(i->first);
writeS16(os, i->second);
}
writeU8(os, drawtype);
writeF1000(os, visual_scale);
writeU8(os, 6);
for (u32 i = 0; i < 6; i++)
tiledef[i].serialize(os, protocol_version);
//CF_SPECIAL_COUNT = 2 before cf ver. 7 and protocol ver. 24
writeU8(os, 2);
for (u32 i = 0; i < 2; i++)
tiledef_special[i].serialize(os, protocol_version);
writeU8(os, alpha);
writeU8(os, post_effect_color.getAlpha());
writeU8(os, post_effect_color.getRed());
writeU8(os, post_effect_color.getGreen());
writeU8(os, post_effect_color.getBlue());
writeU8(os, param_type);
writeU8(os, param_type_2);
writeU8(os, is_ground_content);
writeU8(os, light_propagates);
writeU8(os, sunlight_propagates);
writeU8(os, walkable);
writeU8(os, pointable);
writeU8(os, diggable);
writeU8(os, climbable);
writeU8(os, buildable_to);
os<<serializeString(""); // legacy: used to be metadata_name
writeU8(os, liquid_type);
os<<serializeString(liquid_alternative_flowing);
os<<serializeString(liquid_alternative_source);
writeU8(os, liquid_viscosity);
writeU8(os, liquid_renewable);
writeU8(os, light_source);
writeU32(os, damage_per_second);
node_box.serialize(os, protocol_version);
selection_box.serialize(os, protocol_version);
writeU8(os, legacy_facedir_simple);
writeU8(os, legacy_wallmounted);
serializeSimpleSoundSpec(sound_footstep, os);
serializeSimpleSoundSpec(sound_dig, os);
serializeSimpleSoundSpec(sound_dug, os);
writeU8(os, rightclickable);
writeU8(os, drowning);
writeU8(os, leveled);
writeU8(os, liquid_range);
} else
throw SerializationError("ContentFeatures::serialize(): "
"Unsupported version requested");
}
bool ItemsOtbWriter::writeItemsOtb(shared_ptr <DatObjectList> items, const wxString & filename, ProgressUpdatable * progressUpdatable)
{
file.open(filename.mb_str(), ios::out | ios::binary);
if (file.is_open())
{
auto & itemAttributes = AdvancedAttributesManager::getInstance().getCategoryAttributes(CategoryItem);
writeU32(0); // write 4 bytes for file version, they aren't used really, it seems
file.put((const char) NODE_START);
writeByte(0); // type info, seems to be unused
writeU32(0); // some flags maybe, also looks unused
writeByte(ROOT_ATTR_VERSION); // version attribute
writeU16(DATA_LENGTH); // data length here should be constant
// writing version, not sure why every version component is stored in U32 though, just waste of space...
writeU32(V_MAJOR);
writeU32(V_MINOR);
writeU32(V_BUILD);
// writing string version
int versionLen = strlen(OTB_VERSION_STR), remainingLen = DATA_LENGTH - versionLen;
file.write(OTB_VERSION_STR, versionLen);
// filling up to 128 bytes (format requirement)
char * zeros = new char[remainingLen];
memset(zeros, 0, remainingLen);
file.write(zeros, remainingLen);
delete [] zeros;
// writing actual items
unsigned int writings = 0, total = items->size();
shared_ptr <AdvancedObjectAttributes> attrs = nullptr;
for (auto & item : *items)
{
attrs = itemAttributes[item->id];
file.put((const char) NODE_START);
// writing group byte
if (attrs && attrs->group)
{
writeByte(attrs->group);
}
else if (item->isGround || item->isFullGround)
{
writeByte(ITEM_GROUP_GROUND);
}
else
{
writeByte(ITEM_GROUP_NONE);
}
// writing flags
unsigned int flags = 0;
if (!item->isWalkable) flags |= FLAG_BLOCK_SOLID;
if (item->blocksProjectiles) flags |= FLAG_BLOCK_PROJECTILE;
if (!item->isPathable) flags |= FLAG_BLOCK_PATHFIND;
if (item->isPickupable) flags |= FLAG_PICKUPABLE;
if (item->isMovable) flags |= FLAG_MOVEABLE;
if (item->isStackable) flags |= FLAG_STACKABLE;
if (item->isHangable) flags |= FLAG_HANGABLE;
if (item->isUsable) flags |= FLAG_USEABLE;
writeU32(flags);
// writing attributes
const unsigned short datalen = 2; // this is constant 2 bytes
// writing server ID, this will be simply item ID
writeByte(ITEM_ATTR_SERVER_ID);
writeU16(datalen);
writeU16(item->id);
// writing client ID, this will be SAME item ID, because we're making one-to-one mapping
writeByte(ITEM_ATTR_CLIENT_ID);
writeU16(datalen);
writeU16(item->id);
// if item 'isFullGround', writing ground speed, it's not used in RME, but just for compatibility
if (item->isFullGround)
{
writeByte(ITEM_ATTR_SPEED);
writeU16(datalen);
writeU16(item->groundSpeed);
}
// if item 'isLightSource', writing light intensity and color, it's not used in RME, but just for compatibility
if (item->isLightSource)
{
writeByte(ITEM_ATTR_LIGHT2);
writeU16(datalen * 2); // need x2 datalen here
writeU16(item->lightIntensity);
writeU16(item->lightColor);
}
file.put((const char) NODE_END);
if (file.bad()) return false;
progressUpdatable->updateProgress(++writings / (double) total);
}
file.put((const char) NODE_END); // closing root node
progressUpdatable->updateProgress(1);
file.close();
return true;
}
return false;
}
void NodeBox::serialize(std::ostream &os, u16 protocol_version) const
{
int version = 1;
if (protocol_version >= 27)
version = 3;
else if (protocol_version >= 21)
version = 2;
writeU8(os, version);
switch (type) {
case NODEBOX_LEVELED:
case NODEBOX_FIXED:
if (version == 1)
writeU8(os, NODEBOX_FIXED);
else
writeU8(os, type);
writeU16(os, fixed.size());
for (std::vector<aabb3f>::const_iterator
i = fixed.begin();
i != fixed.end(); ++i)
{
writeV3F1000(os, i->MinEdge);
writeV3F1000(os, i->MaxEdge);
}
break;
case NODEBOX_WALLMOUNTED:
writeU8(os, type);
writeV3F1000(os, wall_top.MinEdge);
writeV3F1000(os, wall_top.MaxEdge);
writeV3F1000(os, wall_bottom.MinEdge);
writeV3F1000(os, wall_bottom.MaxEdge);
writeV3F1000(os, wall_side.MinEdge);
writeV3F1000(os, wall_side.MaxEdge);
break;
case NODEBOX_CONNECTED:
if (version <= 2) {
// send old clients nodes that can't be walked through
// to prevent abuse
writeU8(os, NODEBOX_FIXED);
writeU16(os, 1);
writeV3F1000(os, v3f(-BS/2, -BS/2, -BS/2));
writeV3F1000(os, v3f(BS/2, BS/2, BS/2));
} else {
writeU8(os, type);
#define WRITEBOX(box) do { \
writeU16(os, (box).size()); \
for (std::vector<aabb3f>::const_iterator \
i = (box).begin(); \
i != (box).end(); ++i) { \
writeV3F1000(os, i->MinEdge); \
writeV3F1000(os, i->MaxEdge); \
}; } while (0)
WRITEBOX(fixed);
WRITEBOX(connect_top);
WRITEBOX(connect_bottom);
WRITEBOX(connect_front);
WRITEBOX(connect_left);
WRITEBOX(connect_back);
WRITEBOX(connect_right);
}
break;
default:
writeU8(os, type);
break;
}
}
void MapBlock::serialize_pre22(std::ostream &os, u8 version, bool disk)
{
u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
MapNode *tmp_data = new MapNode[nodecount];
// Legacy data changes
// This code has to change from post-22 to pre-22 format.
INodeDefManager *nodedef = m_gamedef->ndef();
for(u32 i=0; i<nodecount; i++)
{
const ContentFeatures &f = nodedef->get(tmp_data[i].getContent());
// Mineral
if(nodedef->getId("default:stone_with_coal") == tmp_data[i].getContent())
{
tmp_data[i].setContent(nodedef->getId("default:stone"));
tmp_data[i].setParam1(1); // MINERAL_COAL
}
else if(nodedef->getId("default:stone_with_iron") == tmp_data[i].getContent())
{
tmp_data[i].setContent(nodedef->getId("default:stone"));
tmp_data[i].setParam1(2); // MINERAL_IRON
}
// facedir_simple
if(f.legacy_facedir_simple)
{
tmp_data[i].setParam1(tmp_data[i].getParam2());
tmp_data[i].setParam2(0);
}
// wall_mounted
if(f.legacy_wallmounted)
{
u8 wallmounted_new_to_old[8] = {0x04, 0x08, 0x01, 0x02, 0x10, 0x20, 0, 0};
u8 dir_new_format = tmp_data[i].getParam2() & 7; // lowest 3 bits
u8 dir_old_format = wallmounted_new_to_old[dir_new_format];
tmp_data[i].setParam2(dir_old_format);
}
}
// Serialize nodes
u32 ser_length = MapNode::serializedLength(version);
SharedBuffer<u8> databuf_nodelist(nodecount * ser_length);
for(u32 i=0; i<nodecount; i++)
{
tmp_data[i].serialize(&databuf_nodelist[i*ser_length], version);
}
delete[] tmp_data;
// These have no compression
if(version <= 3 || version == 5 || version == 6)
{
writeU8(os, is_underground);
os.write((char*)*databuf_nodelist, databuf_nodelist.getSize());
}
else if(version <= 10)
{
/*
With compression.
Compress the materials and the params separately.
*/
// First byte
writeU8(os, is_underground);
// Get and compress materials
SharedBuffer<u8> materialdata(nodecount);
for(u32 i=0; i<nodecount; i++)
{
materialdata[i] = databuf_nodelist[i*ser_length];
}
compress(materialdata, os, version);
// Get and compress lights
SharedBuffer<u8> lightdata(nodecount);
for(u32 i=0; i<nodecount; i++)
{
lightdata[i] = databuf_nodelist[i*ser_length+1];
}
compress(lightdata, os, version);
if(version >= 10)
{
// Get and compress param2
SharedBuffer<u8> param2data(nodecount);
for(u32 i=0; i<nodecount; i++)
{
param2data[i] = databuf_nodelist[i*ser_length+2];
}
compress(param2data, os, version);
}
}
// All other versions (newest)
else
{
// First byte
u8 flags = 0;
if(is_underground)
flags |= 0x01;
if(m_day_night_differs)
flags |= 0x02;
if(m_lighting_expired)
flags |= 0x04;
if(version >= 18)
{
if(m_generated == false)
flags |= 0x08;
}
writeU8(os, flags);
/*
Get data
*/
// Create buffer with different parameters sorted
SharedBuffer<u8> databuf(nodecount*3);
for(u32 i=0; i<nodecount; i++)
{
databuf[i] = databuf_nodelist[i*ser_length];
databuf[i+nodecount] = databuf_nodelist[i*ser_length+1];
databuf[i+nodecount*2] = databuf_nodelist[i*ser_length+2];
}
/*
Compress data to output stream
*/
compress(databuf, os, version);
/*
NodeMetadata
*/
if(version >= 14)
{
if(version <= 15)
{
try{
std::ostringstream oss(std::ios_base::binary);
m_node_metadata->serialize(oss);
os<<serializeString(oss.str());
}
// This will happen if the string is longer than 65535
catch(SerializationError &e)
{
// Use an empty string
os<<serializeString("");
}
}
else
{
std::ostringstream oss(std::ios_base::binary);
m_node_metadata->serialize(oss);
compressZlib(oss.str(), os);
//os<<serializeLongString(oss.str());
}
}
}
if(disk)
{
// Versions up from 9 have block objects. (DEPRECATED)
if(version >= 9)
{
// count=0
writeU16(os, 0);
}
// Versions up from 15 have static objects.
if(version >= 15)
{
m_static_objects.serialize(os);
}
// Timestamp
if(version >= 17)
{
writeU32(os, getTimestamp());
}
// Scan and write node definition id mapping
if(version >= 21)
{
NameIdMapping nimap;
getBlockNodeIdMapping_pre22(&nimap, data, m_gamedef->ndef());
nimap.serialize(os);
}
}
}
void ContentFeatures::serialize(std::ostream &os, u16 protocol_version)
{
if(protocol_version < 14){
serializeOld(os, protocol_version);
return;
}
writeU8(os, 6); // version
os<<serializeString(name);
writeU16(os, groups.size());
for(ItemGroupList::const_iterator
i = groups.begin(); i != groups.end(); i++){
os<<serializeString(i->first);
writeS16(os, i->second);
}
writeU8(os, drawtype);
writeF1000(os, visual_scale);
writeU8(os, 6);
for(u32 i=0; i<6; i++)
tiledef[i].serialize(os, protocol_version);
writeU8(os, CF_SPECIAL_COUNT);
for(u32 i=0; i<CF_SPECIAL_COUNT; i++){
tiledef_special[i].serialize(os, protocol_version);
}
writeU8(os, alpha);
writeU8(os, post_effect_color.getAlpha());
writeU8(os, post_effect_color.getRed());
writeU8(os, post_effect_color.getGreen());
writeU8(os, post_effect_color.getBlue());
writeU8(os, param_type);
writeU8(os, param_type_2);
writeU8(os, is_ground_content);
writeU8(os, light_propagates);
writeU8(os, sunlight_propagates);
writeU8(os, walkable);
writeU8(os, pointable);
writeU8(os, diggable);
writeU8(os, climbable);
writeU8(os, buildable_to);
os<<serializeString(""); // legacy: used to be metadata_name
writeU8(os, liquid_type);
os<<serializeString(liquid_alternative_flowing);
os<<serializeString(liquid_alternative_source);
writeU8(os, liquid_viscosity);
writeU8(os, liquid_renewable);
writeU8(os, light_source);
writeU32(os, damage_per_second);
node_box.serialize(os, protocol_version);
selection_box.serialize(os, protocol_version);
writeU8(os, legacy_facedir_simple);
writeU8(os, legacy_wallmounted);
serializeSimpleSoundSpec(sound_footstep, os);
serializeSimpleSoundSpec(sound_dig, os);
serializeSimpleSoundSpec(sound_dug, os);
writeU8(os, rightclickable);
writeU8(os, drowning);
writeU8(os, leveled);
writeU8(os, liquid_range);
// Stuff below should be moved to correct place in a version that otherwise changes
// the protocol version
}
void Client::step(float dtime)
{
DSTACK(__FUNCTION_NAME);
// Limit a bit
if(dtime > 2.0)
dtime = 2.0;
if(m_ignore_damage_timer > dtime)
m_ignore_damage_timer -= dtime;
else
m_ignore_damage_timer = 0.0;
//infostream<<"Client steps "<<dtime<<std::endl;
{
//TimeTaker timer("ReceiveAll()", m_device);
// 0ms
ReceiveAll();
}
{
//TimeTaker timer("m_con_mutex + m_con.RunTimeouts()", m_device);
// 0ms
//JMutexAutoLock lock(m_con_mutex); //bulk comment-out
m_con.RunTimeouts(dtime);
}
/*
Packet counter
*/
{
float &counter = m_packetcounter_timer;
counter -= dtime;
if(counter <= 0.0)
{
counter = 20.0;
infostream<<"Client packetcounter (20s):"<<std::endl;
m_packetcounter.print(infostream);
m_packetcounter.clear();
}
}
// Get connection status
bool connected = connectedAndInitialized();
#if 0
{
/*
Delete unused sectors
NOTE: This jams the game for a while because deleting sectors
clear caches
*/
float &counter = m_delete_unused_sectors_timer;
counter -= dtime;
if(counter <= 0.0)
{
// 3 minute interval
//counter = 180.0;
counter = 60.0;
//JMutexAutoLock lock(m_env_mutex); //bulk comment-out
core::list<v3s16> deleted_blocks;
float delete_unused_sectors_timeout =
g_settings->getFloat("client_delete_unused_sectors_timeout");
// Delete sector blocks
/*u32 num = m_env.getMap().unloadUnusedData
(delete_unused_sectors_timeout,
true, &deleted_blocks);*/
// Delete whole sectors
m_env.getMap().unloadUnusedData
(delete_unused_sectors_timeout,
&deleted_blocks);
if(deleted_blocks.size() > 0)
{
/*infostream<<"Client: Deleted blocks of "<<num
<<" unused sectors"<<std::endl;*/
/*infostream<<"Client: Deleted "<<num
<<" unused sectors"<<std::endl;*/
/*
Send info to server
*/
// Env is locked so con can be locked.
//JMutexAutoLock lock(m_con_mutex); //bulk comment-out
core::list<v3s16>::Iterator i = deleted_blocks.begin();
core::list<v3s16> sendlist;
for(;;)
{
if(sendlist.size() == 255 || i == deleted_blocks.end())
{
if(sendlist.size() == 0)
break;
/*
[0] u16 command
[2] u8 count
[3] v3s16 pos_0
[3+6] v3s16 pos_1
...
*/
u32 replysize = 2+1+6*sendlist.size();
SharedBuffer<u8> reply(replysize);
writeU16(&reply[0], TOSERVER_DELETEDBLOCKS);
reply[2] = sendlist.size();
u32 k = 0;
for(core::list<v3s16>::Iterator
j = sendlist.begin();
j != sendlist.end(); j++)
{
writeV3S16(&reply[2+1+6*k], *j);
k++;
}
m_con.Send(PEER_ID_SERVER, 1, reply, true);
if(i == deleted_blocks.end())
break;
sendlist.clear();
}
sendlist.push_back(*i);
i++;
}
}
}
}
#endif
if(connected == false)
{
float &counter = m_connection_reinit_timer;
counter -= dtime;
if(counter <= 0.0)
{
counter = 2.0;
//JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
Player *myplayer = m_env.getLocalPlayer();
assert(myplayer != NULL);
// Send TOSERVER_INIT
// [0] u16 TOSERVER_INIT
// [2] u8 SER_FMT_VER_HIGHEST
// [3] u8[20] player_name
// [23] u8[28] password (new in some version)
// [51] u16 client network protocol version (new in some version)
SharedBuffer<u8> data(2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2);
writeU16(&data[0], TOSERVER_INIT);
writeU8(&data[2], SER_FMT_VER_HIGHEST);
memset((char*)&data[3], 0, PLAYERNAME_SIZE);
snprintf((char*)&data[3], PLAYERNAME_SIZE, "%s", myplayer->getName());
/*infostream<<"Client: sending initial password hash: \""<<m_password<<"\""
<<std::endl;*/
memset((char*)&data[23], 0, PASSWORD_SIZE);
snprintf((char*)&data[23], PASSWORD_SIZE, "%s", m_password.c_str());
// This should be incremented in each version
writeU16(&data[51], 3);
// Send as unreliable
Send(0, data, false);
}
// Not connected, return
return;
}
/*
Do stuff if connected
*/
/*
Run Map's timers and unload unused data
*/
const float map_timer_and_unload_dtime = 5.25;
if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime))
{
ScopeProfiler sp(g_profiler, "Client: map timer and unload");
core::list<v3s16> deleted_blocks;
m_env.getMap().timerUpdate(map_timer_and_unload_dtime,
g_settings->getFloat("client_unload_unused_data_timeout"),
&deleted_blocks);
/*if(deleted_blocks.size() > 0)
infostream<<"Client: Unloaded "<<deleted_blocks.size()
<<" unused blocks"<<std::endl;*/
/*
Send info to server
NOTE: This loop is intentionally iterated the way it is.
*/
core::list<v3s16>::Iterator i = deleted_blocks.begin();
core::list<v3s16> sendlist;
for(;;)
{
if(sendlist.size() == 255 || i == deleted_blocks.end())
{
if(sendlist.size() == 0)
break;
/*
[0] u16 command
[2] u8 count
[3] v3s16 pos_0
[3+6] v3s16 pos_1
...
*/
u32 replysize = 2+1+6*sendlist.size();
SharedBuffer<u8> reply(replysize);
writeU16(&reply[0], TOSERVER_DELETEDBLOCKS);
reply[2] = sendlist.size();
u32 k = 0;
for(core::list<v3s16>::Iterator
j = sendlist.begin();
j != sendlist.end(); j++)
{
writeV3S16(&reply[2+1+6*k], *j);
k++;
}
m_con.Send(PEER_ID_SERVER, 1, reply, true);
if(i == deleted_blocks.end())
break;
sendlist.clear();
}
sendlist.push_back(*i);
i++;
}
}
/*
Handle environment
*/
{
// 0ms
//JMutexAutoLock lock(m_env_mutex); //bulk comment-out
// Control local player (0ms)
LocalPlayer *player = m_env.getLocalPlayer();
assert(player != NULL);
player->applyControl(dtime);
//TimeTaker envtimer("env step", m_device);
// Step environment
m_env.step(dtime);
/*
Get events
*/
for(;;)
{
ClientEnvEvent event = m_env.getClientEvent();
if(event.type == CEE_NONE)
{
break;
}
else if(event.type == CEE_PLAYER_DAMAGE)
{
if(m_ignore_damage_timer <= 0)
{
u8 damage = event.player_damage.amount;
sendDamage(damage);
// Add to ClientEvent queue
ClientEvent event;
event.type = CE_PLAYER_DAMAGE;
event.player_damage.amount = damage;
m_client_event_queue.push_back(event);
}
}
}
}
/*
Print some info
*/
{
float &counter = m_avg_rtt_timer;
counter += dtime;
if(counter >= 10)
{
counter = 0.0;
//JMutexAutoLock lock(m_con_mutex); //bulk comment-out
// connectedAndInitialized() is true, peer exists.
float avg_rtt = m_con.GetPeerAvgRTT(PEER_ID_SERVER);
infostream<<"Client: avg_rtt="<<avg_rtt<<std::endl;
}
}
/*
Send player position to server
*/
{
float &counter = m_playerpos_send_timer;
counter += dtime;
if(counter >= 0.2)
{
counter = 0.0;
sendPlayerPos();
}
}
/*
Replace updated meshes
*/
{
//JMutexAutoLock lock(m_env_mutex); //bulk comment-out
//TimeTaker timer("** Processing mesh update result queue");
// 0ms
/*infostream<<"Mesh update result queue size is "
<<m_mesh_update_thread.m_queue_out.size()
<<std::endl;*/
while(m_mesh_update_thread.m_queue_out.size() > 0)
{
MeshUpdateResult r = m_mesh_update_thread.m_queue_out.pop_front();
MapBlock *block = m_env.getMap().getBlockNoCreateNoEx(r.p);
if(block)
{
block->replaceMesh(r.mesh);
}
if(r.ack_block_to_server)
{
/*infostream<<"Client: ACK block ("<<r.p.X<<","<<r.p.Y
<<","<<r.p.Z<<")"<<std::endl;*/
/*
Acknowledge block
*/
/*
[0] u16 command
[2] u8 count
[3] v3s16 pos_0
[3+6] v3s16 pos_1
...
*/
u32 replysize = 2+1+6;
SharedBuffer<u8> reply(replysize);
writeU16(&reply[0], TOSERVER_GOTBLOCKS);
reply[2] = 1;
writeV3S16(&reply[3], r.p);
// Send as reliable
m_con.Send(PEER_ID_SERVER, 1, reply, true);
}
}
}
}