/*
=======================================================================================================================================
WriteFuzzyWeight
=======================================================================================================================================
*/
qboolean WriteFuzzyWeight(FILE *fp, fuzzyseperator_t *fs) {
if (fs->type == WT_BALANCE) {
if (fprintf(fp, " return balance(") < 0) {
return qfalse;
}
if (!WriteFloat(fp, fs->weight)) {
return qfalse;
}
if (fprintf(fp, ",") < 0) {
return qfalse;
}
if (!WriteFloat(fp, fs->minweight)) {
return qfalse;
}
if (fprintf(fp, ",") < 0) {
return qfalse;
}
if (!WriteFloat(fp, fs->maxweight)) {
return qfalse;
}
if (fprintf(fp, ");\n") < 0) {
return qfalse;
}
} else {
if (fprintf(fp, " return ") < 0) {
return qfalse;
}
if (!WriteFloat(fp, fs->weight)) {
return qfalse;
}
if (fprintf(fp, ";\n") < 0) {
return qfalse;
}
}
return qtrue;
}
size_t PlayerPositionAndLook::serialize(Buffer& _dst, size_t _offset)
{
_pm_checkInit();
if(_offset == 0) _dst.clear();
_offset = WriteInt8(_dst, _offset, _pf_packetId);
_offset = WriteDouble(_dst, _offset, _pf_x);
_offset = WriteDouble(_dst, _offset, _pf_y);
_offset = WriteDouble(_dst, _offset, _pf_stance);
_offset = WriteDouble(_dst, _offset, _pf_z);
_offset = WriteFloat(_dst, _offset, _pf_yaw);
_offset = WriteFloat(_dst, _offset, _pf_pitch);
_offset = WriteBool(_dst, _offset, _pf_onGround);
return _offset;
}
void CFileDataIO::WriteTag(const CTag& tag)
{
try
{
WriteUInt8(tag.GetType());
if (!tag.GetName().IsEmpty()) {
WriteString(tag.GetName(),utf8strNone);
} else {
WriteUInt16(1);
WriteUInt8(tag.GetNameID());
}
switch (tag.GetType())
{
case TAGTYPE_HASH16:
// Do NOT use this to transfer any tags for at least half a year!!
WriteHash(CMD4Hash(tag.GetHash()));
break;
case TAGTYPE_STRING:
WriteString(tag.GetStr(), utf8strRaw); // Always UTF8
break;
case TAGTYPE_UINT64:
WriteUInt64(tag.GetInt());
break;
case TAGTYPE_UINT32:
WriteUInt32(tag.GetInt());
break;
case TAGTYPE_FLOAT32:
WriteFloat(tag.GetFloat());
break;
case TAGTYPE_BSOB:
WriteBsob(tag.GetBsob(), tag.GetBsobSize());
break;
case TAGTYPE_UINT16:
WriteUInt16(tag.GetInt());
break;
case TAGTYPE_UINT8:
WriteUInt8(tag.GetInt());
break;
case TAGTYPE_BLOB:
// NOTE: This will break backward compatibility with met files for eMule versions prior to 0.44a
// and any aMule prior to SVN 26/02/2005
WriteUInt32(tag.GetBlobSize());
Write(tag.GetBlob(), tag.GetBlobSize());
break;
default:
//TODO: Support more tag types
// With the if above, this should NEVER happen.
AddLogLineNS(CFormat(wxT("CFileDataIO::WriteTag: Unknown tag: type=0x%02X")) % tag.GetType());
wxFAIL;
break;
}
} catch (...) {
AddLogLineNS(wxT("Exception in CDataIO:WriteTag"));
throw;
}
}
void Serializer::InitForWriting()
{
ASSERT(mode==SERIALIZE_NONE);
mode=SERIALIZE_WRITE;
ver=1.0f;
WriteFloat(ver); //shrugs
}
void NifStream( Key<Quaternion> const & key, ostream& file, const NifInfo & info, KeyType type ) {
WriteFloat( key.time, file );
//If key type is not 1, 2, or 3, throw an exception
if ( type < 1 || type > 3 ) {
type = LINEAR_KEY;
//throw runtime_error("Invalid key type.");
}
//Read data based on the type of key
NifStream( key.data, file, info );
if ( type == TBC_KEY ) {
//Uses TBC interpolation
WriteFloat( key.tension, file);
WriteFloat( key.bias, file);
WriteFloat( key.continuity, file);
}
}
void cProtocol125::SendHealth(void)
{
cCSLock Lock(m_CSPacket);
WriteByte (PACKET_UPDATE_HEALTH);
WriteShort((short)m_Client->GetPlayer()->GetHealth());
WriteShort(m_Client->GetPlayer()->GetFoodLevel());
WriteFloat((float)m_Client->GetPlayer()->GetFoodSaturationLevel());
Flush();
}
/*
================
idSaveGame::WriteRefSound
================
*/
void idSaveGame::WriteRefSound( const refSound_t &refSound ) {
if( refSound.referenceSound ) {
WriteInt( refSound.referenceSound->Index() );
} else {
WriteInt( 0 );
}
WriteVec3( refSound.origin );
WriteInt( refSound.listenerId );
WriteSoundShader( refSound.shader );
WriteFloat( refSound.diversity );
WriteBool( refSound.waitfortrigger );
WriteFloat( refSound.parms.minDistance );
WriteFloat( refSound.parms.maxDistance );
WriteFloat( refSound.parms.volume );
WriteFloat( refSound.parms.shakes );
WriteInt( refSound.parms.soundShaderFlags );
WriteInt( refSound.parms.soundClass );
}
void cProtocol125::SendExperience(void)
{
cCSLock Lock(m_CSPacket);
cPlayer * Player = m_Client->GetPlayer();
WriteByte (PACKET_EXPERIENCE);
WriteFloat (Player->GetXpPercentage());
WriteShort (Player->GetXpLevel());
WriteShort (Player->GetCurrentXp());
Flush();
}
void writeTeleopForwards()
{
TFileHandle hFileHandle;
TFileIOResult nIoResult;
float teleopForwards=readCompass();
short nFileSize=sizeof(teleopForwards);
OpenWrite(hFileHandle, nIoResult, TELEOPFORWARDSDAT, nFileSize);
WriteFloat(hFileHandle, nIoResult, teleopForwards);
Close(hFileHandle, nIoResult);
}
size_t Explosion::serialize(Buffer& _dst, size_t _offset)
{
_pm_checkInit();
if(_offset == 0) _dst.clear();
_offset = WriteInt8(_dst, _offset, _pf_packetId);
_offset = WriteDouble(_dst, _offset, _pf_x);
_offset = WriteDouble(_dst, _offset, _pf_y);
_offset = WriteDouble(_dst, _offset, _pf_z);
_offset = WriteFloat(_dst, _offset, _pf_radius);
_offset = WriteInt32(_dst, _offset, _pf_recordCount);
_offset = WriteByteArray(_dst, _offset, _pf_records);
_offset = WriteFloat(_dst, _offset, _pf_playerMotionX);
_offset = WriteFloat(_dst, _offset, _pf_playerMotionY);
_offset = WriteFloat(_dst, _offset, _pf_playerMotionZ);
return _offset;
}
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
qboolean WriteFuzzyWeight(FILE *fp, fuzzyseperator_t *fs)
{
if (fs->type == WT_BALANCE)
{
if (fprintf(fp, " return balance(") < 0) return qfalse;
if (!WriteFloat(fp, fs->weight)) return qfalse;
if (fprintf(fp, ",") < 0) return qfalse;
if (!WriteFloat(fp, fs->minweight)) return qfalse;
if (fprintf(fp, ",") < 0) return qfalse;
if (!WriteFloat(fp, fs->maxweight)) return qfalse;
if (fprintf(fp, ");\n") < 0) return qfalse;
} //end if
else
{
if (fprintf(fp, " return ") < 0) return qfalse;
if (!WriteFloat(fp, fs->weight)) return qfalse;
if (fprintf(fp, ";\n") < 0) return qfalse;
} //end else
return qtrue;
} //end of the function WriteFuzzyWeight
void Write1DMatrix( idFile *f, int x, float *m ) {
int i;
f->WriteFloatString( "( " );
for ( i = 0; i < x; i++ ) {
WriteFloat( f, m[i] );
}
f->WriteFloatString( ") " );
}
void cProtocol125::SendExplosion(double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion)
{
cCSLock Lock(m_CSPacket);
WriteByte(PACKET_EXPLOSION);
WriteDouble (a_BlockX);
WriteDouble (a_BlockY);
WriteDouble (a_BlockZ);
WriteFloat (a_Radius);
WriteInt (a_BlocksAffected.size());
for (cVector3iArray::const_iterator itr = a_BlocksAffected.begin(); itr != a_BlocksAffected.end(); ++itr)
{
WriteByte ((Byte)(itr->x - a_BlockX));
WriteByte ((Byte)(itr->y - a_BlockY));
WriteByte ((Byte)(itr->z - a_BlockZ));
}
WriteFloat ((float)a_PlayerMotion.x);
WriteFloat ((float)a_PlayerMotion.y);
WriteFloat ((float)a_PlayerMotion.z);
Flush();
}
/*
===================
idSaveGame::WriteContactInfo
===================
*/
void idSaveGame::WriteContactInfo( const contactInfo_t &contactInfo ) {
WriteInt( (int)contactInfo.type );
WriteVec3( contactInfo.point );
WriteVec3( contactInfo.normal );
WriteFloat( contactInfo.dist );
WriteInt( contactInfo.contents );
WriteMaterial( contactInfo.material );
WriteInt( contactInfo.modelFeature );
WriteInt( contactInfo.trmFeature );
WriteInt( contactInfo.entityNum );
WriteInt( contactInfo.id );
}
void cProtocol132::SendSoundEffect(const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch)
{
cCSLock Lock(m_CSPacket);
WriteByte (PACKET_SOUND_EFFECT);
WriteString (a_SoundName);
WriteInt (a_SrcX);
WriteInt (a_SrcY);
WriteInt (a_SrcZ);
WriteFloat (a_Volume);
WriteChar ((char)(a_Pitch * 63.0f));
Flush();
}
void cProtocol125::SendPlayerMoveLook(void)
{
cCSLock Lock(m_CSPacket);
/*
LOGD("Sending PlayerMoveLook: {%0.2f, %0.2f, %0.2f}, stance %0.2f, OnGround: %d",
m_Player->GetPosX(), m_Player->GetPosY(), m_Player->GetPosZ(), m_Player->GetStance(), m_Player->IsOnGround() ? 1 : 0
);
*/
WriteByte (PACKET_PLAYER_MOVE_LOOK);
cPlayer * Player = m_Client->GetPlayer();
WriteDouble(Player->GetPosX());
WriteDouble(Player->GetStance() + 0.03); // Add a small amount so that the player doesn't start inside a block
WriteDouble(Player->GetPosY() + 0.03); // Add a small amount so that the player doesn't start inside a block
WriteDouble(Player->GetPosZ());
WriteFloat ((float)(Player->GetYaw()));
WriteFloat ((float)(Player->GetPitch()));
WriteBool (Player->IsOnGround());
Flush();
}
void Serializer::WriteRepeatedMessageField(google::protobuf::Message const& value, google::protobuf::FieldDescriptor const* field)
{
google::protobuf::Reflection const* reflection = value.GetReflection();
for (int32 i = 0; i < reflection->FieldSize(value, field); ++i)
{
switch (field->cpp_type())
{
case google::protobuf::FieldDescriptor::CPPTYPE_INT32:
WriteInt32(reflection->GetRepeatedInt32(value, field, i));
break;
case google::protobuf::FieldDescriptor::CPPTYPE_INT64:
WriteInt64(reflection->GetRepeatedInt64(value, field, i));
break;
case google::protobuf::FieldDescriptor::CPPTYPE_UINT32:
WriteUInt32(reflection->GetRepeatedUInt32(value, field, i));
break;
case google::protobuf::FieldDescriptor::CPPTYPE_UINT64:
WriteUInt64(reflection->GetRepeatedUInt64(value, field, i));
break;
case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE:
WriteDouble(reflection->GetRepeatedDouble(value, field, i));
break;
case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT:
WriteFloat(reflection->GetRepeatedFloat(value, field, i));
break;
case google::protobuf::FieldDescriptor::CPPTYPE_BOOL:
WriteBool(reflection->GetRepeatedBool(value, field, i));
break;
case google::protobuf::FieldDescriptor::CPPTYPE_ENUM:
WriteEnum(reflection->GetRepeatedEnum(value, field, i));
break;
case google::protobuf::FieldDescriptor::CPPTYPE_STRING:
{
std::string strValue = reflection->GetRepeatedString(value, field, i);
if (field->type() == google::protobuf::FieldDescriptor::TYPE_STRING)
WriteString(strValue);
else
{
_writer.StartArray();
for (std::size_t j = 0; j < strValue.length(); ++j)
WriteUInt32(uint32(strValue[j]));
_writer.EndArray();
}
break;
}
case google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE:
WriteMessage(reflection->GetRepeatedMessage(value, field, i));
break;
default:
break;
}
}
}
void cProtocol132::SendSoundEffect(const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch)
{
cCSLock Lock(m_CSPacket);
WriteByte (PACKET_SOUND_EFFECT);
WriteString (a_SoundName);
WriteInt ((int)(a_X * 8.0));
WriteInt ((int)(a_Y * 8.0));
WriteInt ((int)(a_Z * 8.0));
WriteFloat (a_Volume);
WriteChar ((char)(a_Pitch * 63.0f));
Flush();
}
/*
================
idSaveGame::WriteRenderView
================
*/
void idSaveGame::WriteRenderView( const renderView_t &view ) {
int i;
WriteInt( view.viewID );
WriteInt( view.x );
WriteInt( view.y );
WriteInt( view.width );
WriteInt( view.height );
WriteFloat( view.fov_x );
WriteFloat( view.fov_y );
WriteVec3( view.vieworg );
WriteMat3( view.viewaxis );
WriteBool( view.cramZNear );
WriteInt( view.time );
for( i = 0; i < MAX_GLOBAL_SHADER_PARMS; i++ ) {
WriteFloat( view.shaderParms[ i ] );
}
}
int WriteActionResponseHeader(LinkSocket *link, LinkArgs *linkArgs){
if (Debug(LINK))
printf("WriteActionResponseHeader: writing ACTION Response header %s\n",
GESTURE_RESPONSE_HEADER);
WriteChars(link, GESTURE_RESPONSE_HEADER, lGESTURE_RESPONSE_HEADER);
if (Debug(LINK))
printf("WriteActionResponseHeader: writing version %f\n", VERSION);
WriteFloat(link, VERSION); /*writing version 0.2*/
if (WriteLinkArgs(link, linkArgs) == -1)
return -1; /* Memory allocation error */
return OK;
}
/*
=================
WriteFaceFile_r
=================
*/
void WriteFaceFile_r (node_t *node)
{
int i, s;
portal_t *p;
winding_t *w;
// decision node
if (node->planenum != PLANENUM_LEAF) {
WriteFaceFile_r (node->children[0]);
WriteFaceFile_r (node->children[1]);
return;
}
if (node->opaque) {
return;
}
for (p = node->portals ; p ; p=p->next[s])
{
w = p->winding;
s = (p->nodes[1] == node);
if (w)
{
if (PortalPassable(p))
continue;
if(p->nodes[0]->cluster == p->nodes[1]->cluster)
continue;
// write out to the file
if (p->nodes[0] == node)
{
fprintf (pf,"%i %i ",w->numpoints, p->nodes[0]->cluster);
for (i=0 ; i<w->numpoints ; i++)
{
fprintf (pf,"(");
WriteFloat (pf, w->p[i][0]);
WriteFloat (pf, w->p[i][1]);
WriteFloat (pf, w->p[i][2]);
fprintf (pf,") ");
}
fprintf (pf,"\n");
}
else
{
fprintf (pf,"%i %i ",w->numpoints, p->nodes[1]->cluster);
for (i = w->numpoints-1; i >= 0; i--)
{
fprintf (pf,"(");
WriteFloat (pf, w->p[i][0]);
WriteFloat (pf, w->p[i][1]);
WriteFloat (pf, w->p[i][2]);
fprintf (pf,") ");
}
fprintf (pf,"\n");
}
}
}
}
//----Writes the initial data----//
void writeLocal()
{
CloseAllHandles(nIoResult);
OpenWrite(hFileHandle,nIoResult,sFileName1,nFileSize);
char x;
for(x = 0; x<numNeuralUnits; x++)
{
WriteFloat(hFileHandle, nIoResult, localTemp.localArray[x]);
}
WriteByte(hFileHandle, nIoResult, poseWorld.maxActivatedCell.x);
WriteByte(hFileHandle, nIoResult, poseWorld.maxActivatedCell.y);
WriteByte(hFileHandle, nIoResult, poseWorld.maxActivatedCell.theta);
Close(hFileHandle,nIoResult);
}
static void
generate_nd(const int nPoints, const int nHashSize, const int fHeader, bearoffcontext * pbc, FILE * output)
{
int n = Combination(nPoints + 15, nPoints);
int i, j;
char sz[41];
float ar[4];
int fTTY = isatty(STDERR_FILENO);
xhash h;
/* initialise xhash */
if (XhashCreate(&h, nHashSize / (4 * sizeof(float)))) {
fprintf(stderr, "Error creating cache\n");
return;
}
XhashStatus(&h);
if (fHeader) {
sprintf(sz, "gnubg-OS-%02d-15-1-0-1xxxxxxxxxxxxxxxxxxx\n", nPoints);
fputs(sz, output);
}
for (i = 0; i < n; ++i) {
if (i)
NDBearoff(i, nPoints, ar, &h, pbc);
else
ar[0] = ar[1] = ar[2] = ar[3] = 0.0f;
for (j = 0; j < 4; ++j)
WriteFloat(ar[j], output);
XhashAdd(&h, i, ar, 16);
if (!(i % 100) && fTTY)
fprintf(stderr, "1:%d/%d \r", i, n);
}
putc('\n', stderr);
XhashStatus(&h);
XhashDestroy(&h);
}
/*
================
idSaveGame::WriteRenderLight
================
*/
void idSaveGame::WriteRenderLight( const renderLight_t &renderLight ) {
int i;
WriteMat3( renderLight.axis );
WriteVec3( renderLight.origin );
WriteInt( renderLight.suppressLightInViewID );
WriteInt( renderLight.allowLightInViewID );
WriteBool( renderLight.noShadows );
WriteBool( renderLight.pointLight );
WriteBool( renderLight.parallel );
WriteVec3( renderLight.lightRadius );
WriteVec3( renderLight.lightCenter );
WriteVec3( renderLight.target );
WriteVec3( renderLight.right );
WriteVec3( renderLight.up );
WriteVec3( renderLight.start );
WriteVec3( renderLight.end );
WriteBool( renderLight.ambient ); // sikk - Ambient Light Flag
// ---> sikk - Ambient Light Color
WriteVec3( renderLight.ambColor_X_Neg );
WriteVec3( renderLight.ambColor_X_Pos );
WriteVec3( renderLight.ambColor_Y_Neg );
WriteVec3( renderLight.ambColor_Y_Pos );
WriteVec3( renderLight.ambColor_Z_Neg );
WriteVec3( renderLight.ambColor_Z_Pos );
// <--- sikk - Ambient Light Color
WriteVec3( renderLight.ambRotation ); // sikk - Ambient Light Rotation
// only idLight has a prelightModel and it's always based on the entityname, so we'll restore it there
// WriteModel( renderLight.prelightModel );
WriteInt( renderLight.lightId );
WriteMaterial( renderLight.shader );
for( i = 0; i < MAX_ENTITY_SHADER_PARMS; i++ ) {
WriteFloat( renderLight.shaderParms[ i ] );
}
if ( renderLight.referenceSound != NULL ) {
WriteInt( renderLight.referenceSound->Index() );
} else {
WriteInt( 0 );
}
}
int WriteMapResponseHeader(LinkSocket *link, LinkArgs *linkArgs){
if (Debug(LINK))
printf("WriteMapResponseHeader: writing MAP Response header %s\n",
GRAPHICS_RESPONSE_HEADER);
WriteChars(link, GRAPHICS_RESPONSE_HEADER, lGRAPHICS_RESPONSE_HEADER);
if (Debug(LINK))
printf("WriteMapResponseHeader: writing version %f\n", VERSION);
WriteFloat(link, VERSION); /*writing version 0.2*/
if (WriteLinkArgs(link, linkArgs) == -1)
return -1; /* Memory allocation error */
if (Debug(LINK))
printf("WriteMapResponseHeader: All done writing header...\n");
return OK;
}
void debug_stream_test_cb (puObject* obj)
{
SStream* s = new SStream;
strncpy (s->filename, "teststream.txt",(PATH_MAX-1));
strncpy (s->mode, "w",3);
OpenStream (s);
WriteComment ("Comment...testing testing testing", s);
WriteComment ("", s);
WriteTag ('bgno', "---- object ----", s);
WriteTag ('bgno', "---- nested Object ----", s);
WriteTag ('int_', "---- int ----", s);
int i = 500;
WriteInt (&i, s);
WriteTag ('uint', "---- unsigned int ----", s);
unsigned int ui = 12345678;
WriteUInt (&ui, s);
float f = 12345.67f;
WriteTag ('flot', "---- float ----", s);
WriteFloat (&f, s);
double d = 987654.3210;
WriteTag ('dubl', "---- double ----", s);
WriteDouble (&d, s);
WriteTag ('stng', "---- string ----", s);
WriteString ("This a string", s);
SVector v;
v.x = 1.0;
v.y = 2.0;
v.z = 3.0;
WriteTag ('vect', "--- vector ----", s);
WriteVector (&v, s);
SPosition pos;
pos.lat = 1000.0;
pos.lon = 2000.0;
pos.alt = 3000.0;
WriteTag ('posn', "---- position ----", s);
WritePosition (&pos, s);
SMessage mesg;
WriteTag ('mesg', "---- message ----", s);
WriteMessage (&mesg, s);
WriteTag ('endo', s);
WriteTag ('endo', s);
CloseStream (s);
delete s;
}
void cProtocol150::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount)
{
cCSLock Lock(m_CSPacket);
WriteByte(PACKET_PARTICLE_EFFECT);
WriteString(a_ParticleName);
WriteFloat(a_SrcX);
WriteFloat(a_SrcY);
WriteFloat(a_SrcZ);
WriteFloat(a_OffsetX);
WriteFloat(a_OffsetY);
WriteFloat(a_OffsetZ);
WriteFloat(a_ParticleData);
WriteInt(a_ParticleAmmount);
Flush();
}
size_t Particle::serialize(Buffer& _dst, size_t _offset)
{
_pm_checkInit();
if(_offset == 0) _dst.clear();
_offset = WriteInt8(_dst, _offset, _pf_packetId);
_offset = WriteString16(_dst, _offset, _pf_particleName);
_offset = WriteFloat(_dst, _offset, _pf_x);
_offset = WriteFloat(_dst, _offset, _pf_y);
_offset = WriteFloat(_dst, _offset, _pf_z);
_offset = WriteFloat(_dst, _offset, _pf_offsetX);
_offset = WriteFloat(_dst, _offset, _pf_offsetY);
_offset = WriteFloat(_dst, _offset, _pf_offsetZ);
_offset = WriteFloat(_dst, _offset, _pf_particleSpeed);
_offset = WriteInt32(_dst, _offset, _pf_numOfParticles);
return _offset;
}
/*
===================
idRestoreGame::WriteTraceModel
===================
*/
void idSaveGame::WriteTraceModel(const idTraceModel &trace)
{
int j, k;
WriteInt((int &)trace.type);
WriteInt(trace.numVerts);
for (j = 0; j < MAX_TRACEMODEL_VERTS; j++) {
WriteVec3(trace.verts[j]);
}
WriteInt(trace.numEdges);
for (j = 0; j < (MAX_TRACEMODEL_EDGES+1); j++) {
WriteInt(trace.edges[j].v[0]);
WriteInt(trace.edges[j].v[1]);
WriteVec3(trace.edges[j].normal);
}
WriteInt(trace.numPolys);
for (j = 0; j < MAX_TRACEMODEL_POLYS; j++) {
WriteVec3(trace.polys[j].normal);
WriteFloat(trace.polys[j].dist);
WriteBounds(trace.polys[j].bounds);
WriteInt(trace.polys[j].numEdges);
for (k = 0; k < MAX_TRACEMODEL_POLYEDGES; k++) {
WriteInt(trace.polys[j].edges[k]);
}
}
WriteVec3(trace.offset);
WriteBounds(trace.bounds);
WriteBool(trace.isConvex);
// padding win32 native structs
char tmp[3];
memset(tmp, 0, sizeof(tmp));
file->Write(tmp, 3);
}
void cProtocol125::WriteEntityMetadata(const cEntity & a_Entity)
{
if (a_Entity.IsMinecart())
{
WriteByte(0x51);
// No idea how Mojang makes their carts shakey shakey, so here is a complicated one-liner expression that does something similar
WriteInt( (((a_Entity.GetMaxHealth() / 2) - (a_Entity.GetHealth() - (a_Entity.GetMaxHealth() / 2))) * ((const cMinecart &)a_Entity).LastDamage()) * 4 );
WriteByte(0x52);
WriteInt(1); // Shaking direction, doesn't seem to affect anything
WriteByte(0x73);
WriteFloat((float)(((const cMinecart &)a_Entity).LastDamage() + 10)); // Damage taken / shake effect multiplyer
if (((cMinecart &)a_Entity).GetPayload() == cMinecart::mpFurnace)
{
WriteByte(0x10);
WriteByte(((const cMinecartWithFurnace &)a_Entity).IsFueled() ? 1 : 0); // Fueled?
}
}
else if ((a_Entity.IsProjectile() && ((cProjectileEntity &)a_Entity).GetProjectileKind() == cProjectileEntity::pkArrow))
{
WriteByte(0x10);
WriteByte(((const cArrowEntity &)a_Entity).IsCritical() ? 1 : 0); // Critical hitting arrow?
}
}
