ICOImageDecoder::IconDirectoryEntry ICOImageDecoder::readDirectoryEntry() { // Read icon data. // The casts to uint8_t in the next few lines are because that's the on-disk // type of the width and height values. Storing them in ints (instead of // matching uint8_ts) is so we can record dimensions of size 256 (which is // what a zero byte really means). int width = static_cast<uint8_t>(m_data->data()[m_decodedOffset]); if (!width) width = 256; int height = static_cast<uint8_t>(m_data->data()[m_decodedOffset + 1]); if (!height) height = 256; IconDirectoryEntry entry; entry.m_size = IntSize(width, height); if (m_fileType == CURSOR) { entry.m_bitCount = 0; entry.m_hotSpot = IntPoint(readUint16(4), readUint16(6)); } else { entry.m_bitCount = readUint16(6); entry.m_hotSpot = IntPoint(); } entry.m_imageOffset = readUint32(12); // Some icons don't have a bit depth, only a color count. Convert the // color count to the minimum necessary bit depth. It doesn't matter if // this isn't quite what the bitmap info header says later, as we only use // this value to determine which icon entry is best. if (!entry.m_bitCount) { int colorCount = static_cast<uint8_t>(m_data->data()[m_decodedOffset + 2]); if (!colorCount) colorCount = 256; // Vague in the spec, needed by real-world icons. for (--colorCount; colorCount; colorCount >>= 1) ++entry.m_bitCount; }
ICOImageDecoder::IconDirectoryEntry ICOImageDecoder::readDirectoryEntry() { // Read icon data. // The following calls to readUint8() return a uint8_t, which is appropriate // because that's the on-disk type of the width and height values. Storing // them in ints (instead of matching uint8_ts) is so we can record dimensions // of size 256 (which is what a zero byte really means). int width = readUint8(0); if (!width) width = 256; int height = readUint8(1); if (!height) height = 256; IconDirectoryEntry entry; entry.m_size = IntSize(width, height); if (m_fileType == CURSOR) { entry.m_bitCount = 0; entry.m_hotSpot = IntPoint(readUint16(4), readUint16(6)); } else { entry.m_bitCount = readUint16(6); entry.m_hotSpot = IntPoint(); } entry.m_byteSize = readUint32(8); entry.m_imageOffset = readUint32(12); // Some icons don't have a bit depth, only a color count. Convert the // color count to the minimum necessary bit depth. It doesn't matter if // this isn't quite what the bitmap info header says later, as we only use // this value to determine which icon entry is best. if (!entry.m_bitCount) { int colorCount = readUint8(2); if (!colorCount) colorCount = 256; // Vague in the spec, needed by real-world icons. for (--colorCount; colorCount; colorCount >>= 1) ++entry.m_bitCount; }
bool ICOImageDecoder::processDirectory() { // Read directory. ASSERT(!m_decodedOffset); if (m_data->size() < sizeOfDirectory) return false; const uint16_t fileType = readUint16(2); const uint16_t idCount = readUint16(4); m_decodedOffset = sizeOfDirectory; // See if this is an icon filetype we understand, and make sure we have at // least one entry in the directory. enum { ICON = 1, CURSOR = 2, }; if (((fileType != ICON) && (fileType != CURSOR)) || (!idCount)) return setFailed(); // Enlarge member vectors to hold all the entries. m_dirEntries.resize(idCount); m_bmpReaders.resize(idCount); m_pngDecoders.resize(idCount); return true; }
void TRelMsg::decodeOpts(char * buf, int bufSize) { int pos=0; SPtr<TOpt> ptr; while (pos<bufSize) { if (pos+4>bufSize) { Log(Error) << "Message " << MsgType << " truncated. There are " << (bufSize-pos) << " bytes left to parse. Bytes ignored." << LogEnd; break; } unsigned short code = readUint16(buf+pos); pos += sizeof(uint16_t); unsigned short length = readUint16(buf+pos); pos += sizeof(uint16_t); if (pos+length>bufSize) { Log(Error) << "Invalid option (type=" << code << ", len=" << length << " received (msgtype=" << MsgType << "). Message dropped." << LogEnd; IsDone = true; return; } if (!allowOptInMsg(this->MsgType,code)) { Log(Warning) << "Option " << code << " not allowed in message type="<< MsgType <<". Ignoring." << LogEnd; pos+=length; continue; } if (!allowOptInOpt(this->MsgType,0,code)) { Log(Warning) <<"Option " << code << " can't be present in message (type=" << MsgType <<") directly. Ignoring." << LogEnd; pos+=length; continue; } ptr = 0; switch (code) { case OPTION_RELAY_MSG: ptr = new TRelOptRelayMsg(buf+pos,length,this); break; case OPTION_INTERFACE_ID: ptr = new TRelOptInterfaceID(buf+pos,length,this); break; case OPTION_CLIENTID: ptr = new TOptDUID(code, buf+pos, length, this); break; default: ptr = new TRelOptGeneric(code, buf+pos, length, this); break; } if ( (ptr) && (ptr->isValid()) ) Options.push_back( ptr ); else Log(Warning) << "Option " << code << " is invalid. Option ignored." << LogEnd; pos+=length; } }
static int processSNI( INOUT SSL_HANDSHAKE_INFO *handshakeInfo, INOUT STREAM *stream, IN_LENGTH_SHORT_Z const int extLength, const BOOLEAN isServer ) { BYTE nameBuffer[ MAX_DNS_SIZE + 8 ]; int listLen, nameLen, status; assert( isWritePtr( handshakeInfo, sizeof( SSL_HANDSHAKE_INFO ) ) ); assert( isWritePtr( stream, sizeof( STREAM ) ) ); REQUIRES( extLength >= 0 && extLength < MAX_INTLENGTH_SHORT ); /* If we're the client then the server should have sent us an empty extension */ if( !isServer ) return( ( extLength != 0 ) ? CRYPT_ERROR_BADDATA : CRYPT_OK ); /* Remember that we've seen the server-name extension so that we can send a zero-length reply to the client */ handshakeInfo->needSNIResponse = TRUE; /* Read the extension wrapper */ status = listLen = readUint16( stream ); if( cryptStatusError( status ) ) return( status ); if( listLen != extLength - UINT16_SIZE || \ listLen < 1 + UINT16_SIZE || \ listLen >= MAX_INTLENGTH_SHORT ) return( CRYPT_ERROR_BADDATA ); /* Read the name type and length */ if( sgetc( stream ) != 0 ) /* Name type 0 = hostname */ return( CRYPT_ERROR_BADDATA ); status = nameLen = readUint16( stream ); if( cryptStatusError( status ) ) return( status ); if( nameLen != listLen - ( 1 + UINT16_SIZE ) || \ nameLen < MIN_DNS_SIZE || nameLen > MAX_DNS_SIZE ) return( CRYPT_ERROR_BADDATA ); /* Read the SNI and hash it */ status = sread( stream, nameBuffer, nameLen ); if( cryptStatusError( status ) ) return( status ); hashData( handshakeInfo->hashedSNI, KEYID_SIZE, nameBuffer, nameLen ); handshakeInfo->hashedSNIpresent = TRUE; return( CRYPT_OK ); }
char* State_Payload_read(struct Packet* p, char* buffer, int ascii) { if (!ascii) { buffer = readUint32(&(p->seq), buffer); buffer = readUint16((uint16_t*)&(p->state.leftEncoder), buffer); buffer = readUint16((uint16_t*)&(p->state.rightEncoder), buffer); } else { long int a, b, c = 0; sscanf(buffer, "%ld %ld %ld", &a, &b, &c); p->seq = (uint32_t) a; p->state.leftEncoder = (uint16_t) b; p->state.rightEncoder = (uint16_t) c; } return buffer; }
void Script_v2::o2_playMult(FuncParams ¶ms) { uint16 multData = readUint16(); startFunc(params); print("%d, %d", multData >> 1, multData & 0x01); endFunc(); }
static bool checkExifHeader(jpeg_saved_marker_ptr marker, bool& isBigEndian, unsigned& ifdOffset) { // For exif data, the APP1 block is followed by 'E', 'x', 'i', 'f', '\0', // then a fill byte, and then a tiff file that contains the metadata. // A tiff file starts with 'I', 'I' (intel / little endian byte order) or // 'M', 'M' (motorola / big endian byte order), followed by (uint16_t)42, // followed by an uint32_t with the offset to the tag block, relative to the // tiff file start. const unsigned exifHeaderSize = 14; if (!(marker->marker == exifMarker && marker->data_length >= exifHeaderSize && marker->data[0] == 'E' && marker->data[1] == 'x' && marker->data[2] == 'i' && marker->data[3] == 'f' && marker->data[4] == '\0' // data[5] is a fill byte && ((marker->data[6] == 'I' && marker->data[7] == 'I') || (marker->data[6] == 'M' && marker->data[7] == 'M')))) return false; isBigEndian = marker->data[6] == 'M'; if (readUint16(marker->data + 8, isBigEndian) != 42) return false; ifdOffset = readUint32(marker->data + 10, isBigEndian); return true; }
bool ICOImageDecoder::processDirectory() { // Read directory. ASSERT(!m_decodedOffset); if (m_data->size() < sizeOfDirectory) return false; const uint16_t fileType = readUint16(2); m_dirEntriesCount = readUint16(4); m_decodedOffset = sizeOfDirectory; // See if this is an icon filetype we understand, and make sure we have at // least one entry in the directory. if (((fileType != ICON) && (fileType != CURSOR)) || (!m_dirEntriesCount)) return setFailed(); m_fileType = static_cast<FileType>(fileType); return true; }
TClntOptIAPrefix::TClntOptIAPrefix( char * buf, int bufSize, TMsg* parent) :TOptIAPrefix(buf, bufSize, parent) { SPtr<TOpt> opt = 0; int pos=0; int MsgType = 0; if (parent) MsgType = parent->getType(); while(pos<bufSize) { if (pos+4>bufSize) { Log(Error) << "Message " << MsgType << " truncated. There are " << (bufSize-pos) << " bytes left to parse. Bytes ignored." << LogEnd; break; } unsigned short code = readUint16(buf+pos); pos += sizeof(uint16_t); unsigned short length = readUint16(buf+pos); pos+= sizeof(uint16_t); if (pos+length>bufSize) { Log(Error) << "Invalid option (type=" << code << ", len=" << length << " received (msgtype=" << MsgType << "). Message dropped." << LogEnd; return; } if (allowOptInOpt(parent->getType(),OPTION_IAPREFIX,code)) { switch (code) { case OPTION_STATUS_CODE: opt = new TClntOptStatusCode(buf+pos,length, this->Parent); break; default: Log(Warning) <<"Option opttype=" << code<< "not supported " <<" in field of message (type="<< parent->getType() <<") in this version of client."<<LogEnd; break; } if((opt)&&(opt->isValid())) SubOptions.append(opt); } pos += length; } }
void Script_v2::o2_loadMapObjects(FuncParams ¶ms) { int16 id; startFunc(params); print("%s, ", readVarIndex().c_str()); id = (int16) readUint16(); print("%d", id); if (id != -1) { int16 count = (int16) readUint16(); print(", %d", count); for (int i = 0; i < count; i++) print(", %d", (int16) readUint16()); } endFunc(); }
/* * edpCommandReqParse * 按照EDP命令请求协议,解析数据 */ int edpCommandReqParse(edp_pkt* pkt, char *id, char *cmd, int32 *rmlen, int32 *id_len, int32 *cmd_len) { readUint8(pkt); /* 包类型 */ *rmlen = readRemainlen(pkt); /* 剩余长度 */ *id_len = readUint16(pkt); /* ID长度 */ readStr(pkt, id, *id_len); /* 命令ID */ *cmd_len = readUint32(pkt); /* 命令长度 */ readStr(pkt, cmd, *cmd_len); /* 命令内容 */ }
void Script_v2::o2_goblinFunc(FuncParams ¶ms) { FuncParams gobParams; int16 cmd; cmd = (int16) readUint16(); skip(2); if (cmd != 101) goblinOpcode(cmd, gobParams); }
static ImageOrientation readImageOrientation(jpeg_decompress_struct* info) { // The JPEG decoder looks at EXIF metadata. // FIXME: Possibly implement XMP and IPTC support. const unsigned orientationTag = 0x112; const unsigned shortType = 3; for (jpeg_saved_marker_ptr marker = info->marker_list; marker; marker = marker->next) { bool isBigEndian; unsigned ifdOffset; if (!checkExifHeader(marker, isBigEndian, ifdOffset)) continue; const unsigned offsetToTiffData = 6; // Account for 'Exif\0<fill byte>' header. if (marker->data_length < offsetToTiffData || ifdOffset >= marker->data_length - offsetToTiffData) continue; ifdOffset += offsetToTiffData; // The jpeg exif container format contains a tiff block for metadata. // A tiff image file directory (ifd) consists of a uint16_t describing // the number of ifd entries, followed by that many entries. // When touching this code, it's useful to look at the tiff spec: // http://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf JOCTET* ifd = marker->data + ifdOffset; JOCTET* end = marker->data + marker->data_length; if (end - ifd < 2) continue; unsigned tagCount = readUint16(ifd, isBigEndian); ifd += 2; // Skip over the uint16 that was just read. // Every ifd entry is 2 bytes of tag, 2 bytes of contents datatype, // 4 bytes of number-of-elements, and 4 bytes of either offset to the // tag data, or if the data is small enough, the inlined data itself. const int ifdEntrySize = 12; for (unsigned i = 0; i < tagCount && end - ifd >= ifdEntrySize; ++i, ifd += ifdEntrySize) { unsigned tag = readUint16(ifd, isBigEndian); unsigned type = readUint16(ifd + 2, isBigEndian); unsigned count = readUint32(ifd + 4, isBigEndian); if (tag == orientationTag && type == shortType && count == 1) return ImageOrientation::fromEXIFValue(readUint16(ifd + 8, isBigEndian)); } } return ImageOrientation(); }
void Game::loadOthers() { #ifdef NSPIRE FILE* exe = openFile("/documents/liero/data/others.dat.tns"); #else FILE* exe = openFile(joinPath(lieroDataRoot, "others.dat")); #endif for(int i = 0; i < 2; ++i) for(int j = 0; j < 2; ++j) bonusRandTimer[j][i] = readUint16(exe); for(int i = 0; i < 2; ++i) for(int j = 0; j < 7; ++j) aiParams.k[i][j] = readUint16(exe); for(int i = 0; i < 2; ++i) bonusSObjects[i] = readUint8(exe) - 1; }
void Script_v6::o6_loadCursor(FuncParams ¶ms) { int16 id = (int16) readUint16(); startFunc(params); print("%d, ", id); if (id == -1) { print("%s, ", peekString()); skip(9); print("%d, ", readUint16()); print("%d", (int8) readUint8()); } else if (id == -2) { print("%d, ", readUint16()); print("%d, ", readUint16()); print("%d", (int8) readUint8()); } else { print("%d", (int8) readUint8()); } endFunc(); }
/* * edpPushDataParse * 按照EDP透传数据格式,解析数据 */ int edpPushDataParse(edp_pkt* pkt, char *srcId, char *data) { uint32 remain_len; uint16 id_len; readUint8(pkt); /* 包类型 */ remain_len = readRemainlen(pkt); /* 剩余长度 */ id_len = readUint16(pkt); /* 源ID长度 */ readStr(pkt, srcId, id_len); /* 源ID */ readStr(pkt, data, remain_len - 2 - id_len); /* 数据内容 */ }
void Script_v6::o6_createSprite(FuncParams ¶ms) { uint32 pos; pos = getPos(); skip(1); startFunc(params); if (peekUint8() == 0) { seek(pos); print("%d, ", readUint16()); print("%d, ", readUint16()); print("%d, ", readUint16()); } else { seek(pos); print("%s, ", readExpr().c_str()); print("%s, ", readExpr().c_str()); print("%s, ", readExpr().c_str()); } print("%d", readUint16()); endFunc(); }
TOptVendorSpecInfo::TOptVendorSpecInfo(int type, char * buf, int n, TMsg* parent) :TOpt(type, parent) { int optionCode = 0, optionLen = 0; if (n<4) { Log(Error) << "Unable to parse truncated vendor-spec info option." << LogEnd; this->Vendor = 0; Valid = false; return; } this->Vendor = readUint32(buf); // enterprise number buf += sizeof(uint32_t); n -= sizeof(uint32_t); while (n>=4) { optionCode = readUint16(buf); buf += sizeof(uint16_t); n -= sizeof(uint16_t); optionLen = readUint16(buf); buf += sizeof(uint16_t); n -= sizeof(uint16_t); if (optionLen>n) { Log(Warning) << "Malformed vendor-spec info option. Suboption " << optionCode << " truncated." << LogEnd; Valid = false; return; } SPtr<TOpt> opt = new TOptGeneric(optionCode, buf, optionLen, parent); addOption(opt); buf += optionLen; n -= optionLen; } if (n) { Log(Warning) << "Extra " << n << " bytes, after parsing suboption " << optionCode << " in vendor-spec info option." << LogEnd; Valid = false; return; } Valid = true; }
void Script_v6::o6_assign(FuncParams ¶ms) { uint8 type = peekUint8(); uint16 var_0, var_4; std::string varIndex = readVarIndex(&var_0, &var_4); if (var_0 != 0) { std::string varIndex2; uint16 var_6; uint32 savedPos = getPos(); varIndex2 = readVarIndex(&var_6, 0); printIndent(); print("memcpy(%s, %s, %d);\n", varIndex.c_str(), varIndex2.c_str(), var_6 * 4); seek(savedPos); skipExpr(99); return; } if (peekUint8() == 98) { skip(1); uint8 loopCount = readUint8(); uint32 off = 0; for (uint16 i = 0; i < loopCount; i++) { uint8 c = readUint8(); uint16 n = readUint16(); printIndent(); print("memset(%s + %d, %d, %d);\n", varIndex.c_str(), off, c, n); off += n; } } else if (peekUint8() == 99) { skip(1); uint8 loopCount = readUint8(); for (uint16 i = 0; i < loopCount; i++) { std::string expr = readExpr(); printIndent(); print("%s[%d] = %s;\n", varIndex.c_str(), (type == 24) ? (i * 2) : i, expr.c_str()); } } else { std::string expr = readExpr(); printIndent(); print("%s = %s;\n", varIndex.c_str(), expr.c_str()); } }
int readUint24( INOUT STREAM *stream ) { int status; assert( isWritePtr( stream, sizeof( STREAM ) ) ); status = sgetc( stream ); if( cryptStatusError( status ) ) return( status ); if( status != 0 ) return( sSetError( stream, CRYPT_ERROR_BADDATA ) ); return( readUint16( stream ) ); }
void Tmx2MapData::readMapData(char * urlmapdata) { unsigned long fileLen = 0; unsigned char *fileData = NULL; fileData = CCFileUtils::sharedFileUtils()->getFileData(urlmapdata, "rb", (ssize_t*)(&fileLen)); unsigned char* data = fileData; unsigned long pos = 0; CC_SAFE_DELETE(maskArray); searchPath->UnLoadScene(); pos += readUint16(data, width,false); pos += readUint16(data, height,false); pos += readUint16(data, xLen,false); pos += readUint16(data, yLen,false); pos += readUint16(data, cellWidth,false); pos += readUint16(data, cellHeight,false); uint16 temp; pos += readUint16(data, temp,false); pos += readUint16(data, temp,false); int vecsize=0; pos += readInt(data,vecsize,false); searchPath->InitializationMap(xLen, yLen); maskArray =new std::vector<unsigned char>(); for (int i=0;i<vecsize;i++) { unsigned char uc; readUChar(data,uc); maskArray->push_back(uc); if ((*maskArray)[i]==(unsigned char)1) { searchPath->SetBlock(i/yLen, i%yLen, false); } } pos += readInt(data,vecsize,false); aphaVec =new std::vector<unsigned char>(); for (int i=0;i<vecsize;i++) { unsigned char uc; readUChar(data,uc); aphaVec->push_back(uc); if (uc==(unsigned char) 0) { int x=i/yLen; int y=i%yLen; int i=0; } } CC_SAFE_DELETE(fileData); }
TSrvOptIAAddress::TSrvOptIAAddress( char * buf, int bufsize, TMsg* parent) :TOptIAAddress(buf,bufsize, parent) { int pos=0; while(pos<bufsize) { uint16_t code = readUint16(buf+pos); pos += sizeof(uint16_t); uint16_t length = readUint16(buf+pos); pos += sizeof(uint16_t); if ((code>0)&&(code<=24)) { if(allowOptInOpt(parent->getType(),OPTION_IAADDR,code)) { SPtr<TOpt> opt; opt.reset(); switch (code) { case OPTION_STATUS_CODE: opt.reset(new TOptStatusCode(buf+pos, length, Parent)); break; default: Log(Warning) << "Option " << code << " not supported " <<" in message (type="<< parent->getType() <<")." << LogEnd; break; } if (opt && opt->isValid()) SubOptions.append(opt); } else { Log(Warning) << "Illegal option received, opttype=" << code << " in field options of IA_NA option" << LogEnd; } } else { Log(Warning) <<"Unknown option in option IAADDR( optType=" << code << "). Option ignored." << LogEnd; }; pos += length; } }
void Script_v2::o2_handleGoblins(FuncParams ¶ms) { startFunc(params); print("var32_%d, ", readUint16() * 4); print("var32_%d, ", readUint16() * 4); print("var32_%d, ", readUint16() * 4); print("var32_%d, ", readUint16() * 4); print("var32_%d, ", readUint16() * 4); print("var32_%d", readUint16() * 4); endFunc(); }
/* Skip over an SSHv1 private key formatted bignum */ static void skipBigNum( const unsigned char *&cp, // IN/OUT unsigned &len) // IN/OUT { if(len < 2) { cp += len; len = 0; return; } uint16 numBits = readUint16(cp, len); unsigned numBytes = (numBits + 7) / 8; if(numBytes > len) { cp += len; len = 0; return; } cp += numBytes; len -= numBytes; }
void CPacketProcessor::packetReceived(ENetEvent & event) { if (event.packet->dataLength > 0) { //First byte is the packet type switch (*(event.packet->data)) { case PacketTypes::ENTITY_UPDATE: { double timeStamp = 0; memcpy(&timeStamp, event.packet->data + 1, sizeof(double)); //Current position in data unsigned int index = 9; //Process all entity updates bool reachedEnd = false; while (!reachedEnd) { //Check to see if there is enough data for entity ID and payload length if (event.packet->dataLength - index >= 6) { uint32_t entityID = readUint32((event.packet->data + index)); index += 4; uint16_t payloadSize = readUint16((event.packet->data + index)); index += 2; IEntity* entity = gSys->pEntitySystem->getEntity(entityID); if (entity == nullptr) { gSys->log("Entity does not exist"); return; } entity->parsePacket((event.packet->data + index), payloadSize, timeStamp); index += payloadSize; } else { reachedEnd = true; } } } break; case PacketTypes::ENTITY_CREATE: { unsigned int index = 1; uint32_t id = readUint32(event.packet->data + index); //Player is already created if (id == gSys->pPlayer->getID()) return; index += sizeof(id); IEntity* entity; switch (*(event.packet->data + index)) { case EntityTypes::PLAYER: entity = new CPlayer(id); break; case EntityTypes::ZOMBIE: entity = new CZombie(id); break; } uint16_t payloadSize = readUint16(event.packet->data + index); index += sizeof(payloadSize); //TODO TIMESTAMP CREATE PACKETS entity->parsePacket(event.packet->data + index, payloadSize, 0); } break; case PacketTypes::ENTITY_DELETE: { if(IEntity* pEntity = gSys->pEntitySystem->getEntity(readUint32(event.packet->data + 1))) { gSys->pEntitySystem->deleteEntity(pEntity); } } break; case PacketTypes::PLAYER_SHOOT: { uint32_t playerID = readUint32(event.packet->data + 1); if (CPlayer* pPlayer = static_cast<CPlayer*>(gSys->pEntitySystem->getEntity(readUint32(event.packet->data + 1)))) { pPlayer->fire(readFloat(event.packet->data + 5)); } } break; case PacketTypes::PLAYER_HIT: { uint32_t playerID = readUint32(event.packet->data + 1); float angle = readFloat(event.packet->data + 5); if (IEntity* pEnt = gSys->pEntitySystem->getEntity(readUint32(event.packet->data + 1))) { pEnt->hit(angle); } if (CPlayer* pPlayer = static_cast<CPlayer*>(gSys->pEntitySystem->getEntity(readUint32(event.packet->data + 1)))) { CSprite* bloodSprite = gSys->pSpriteRenderer->addSprite(0.5f, 0.2f, 0, 1, 1, 0, "data/blood_splatter.png", false); bloodSprite->m_pos = pPlayer->m_pos.getLerp(gSys->pGame->gameTime - 0.1) + glm::vec2(cos(angle), sin(angle)) * 0.4f; bloodSprite->m_rotPointOffset = glm::vec2(0, 0.1f); bloodSprite->m_rotation = angle; } } break; case PacketTypes::REQUEST_TIME: { double serverTime = 0; memcpy(&serverTime, event.packet->data + 1, sizeof(double)); //Add half of round-trip //serverTime += (glfwGetTime() - gSys->lastTimeRequest) / 2; gSys->pGame->serverTimeDelta = serverTime - glfwGetTime(); } break; default: fprintf(stderr, "Unknown packet type: %u", *(event.packet->data)); break; } } }
ZQuestFile* ZQuestFileReader::read() { atUint32 magic, version, compressedLen, uncompressedLen; ZQuestFile::Game game = ZQuestFile::NoGame; std::string gameString; atUint16 BOM; atUint32 checksum = 0; magic = readUint32(); if ((magic & 0x00FFFFFF) != (ZQuestFile::Magic & 0x00FFFFFF)) { atError("Not a valid ZQuest file"); return nullptr; } version = readUint32(); if (version > ZQuestFile::Version) { atError("Unsupported ZQuest version"); return nullptr; } compressedLen = readUint32(); uncompressedLen = readUint32(); if (version >= ZQUEST_VERSION_CHECK(2, 0, 0)) { gameString = std::string((const char*)readBytes(0x0A).get(), 0x0A); for (size_t i = 0; i < ZQuestFile::gameStringList().size(); i++) { if (!ZQuestFile::gameStringList().at(i).substr(0, 0x0A).compare(gameString)) { gameString = ZQuestFile::gameStringList().at(i); game = (ZQuestFile::Game)i; break; } } BOM = readUint16(); checksum = readUint32(); } else { game = (ZQuestFile::Game)readUint32(); BOM = readUint16(); seek(0x0A); } std::unique_ptr<atUint8[]> data = readUBytes(compressedLen); // compressedLen is always the total file size if (version >= ZQUEST_VERSION_CHECK(2, 0, 0)) { if (checksum != athena::Checksums::crc32(data.get(), compressedLen)) { atError("Checksum mismatch, data corrupt"); return nullptr; } } else { std::clog << "ZQuest version 0x" << std::uppercase << std::setw(8) << std::setfill('0') << std::hex << athena::utility::swapU32(version); std::clog << " has no checksum field" << std::endl; } if (compressedLen != uncompressedLen) { atUint8* dst = new atUint8[uncompressedLen]; atUint32 dstLen = io::Compression::decompressZlib(data.get(), compressedLen, dst, uncompressedLen); if (dstLen != uncompressedLen) { delete[] dst; atError("Error decompressing data"); return nullptr; } data.reset(dst); } return new ZQuestFile(game, BOM == 0xFEFF ? Endian::BigEndian : Endian::LittleEndian, std::move(data), uncompressedLen, gameString); }
bool BMPImageReader::readInfoHeader() { // Pre-initialize some fields that not all headers set. m_infoHeader.biCompression = RGB; m_infoHeader.biClrUsed = 0; if (m_isOS21x) { m_infoHeader.biWidth = readUint16(4); m_infoHeader.biHeight = readUint16(6); ASSERT(m_andMaskState == None); // ICO is a Windows format, not OS/2! m_infoHeader.biBitCount = readUint16(10); return true; } m_infoHeader.biWidth = readUint32(4); m_infoHeader.biHeight = readUint32(8); if (m_andMaskState != None) m_infoHeader.biHeight /= 2; m_infoHeader.biBitCount = readUint16(14); // Read compression type, if present. if (m_infoHeader.biSize >= 20) { uint32_t biCompression = readUint32(16); // Detect OS/2 2.x-specific compression types. if ((biCompression == 3) && (m_infoHeader.biBitCount == 1)) { m_infoHeader.biCompression = HUFFMAN1D; m_isOS22x = true; } else if ((biCompression == 4) && (m_infoHeader.biBitCount == 24)) { m_infoHeader.biCompression = RLE24; m_isOS22x = true; } else if (biCompression > 5) return setFailed(); // Some type we don't understand. else m_infoHeader.biCompression = static_cast<CompressionType>(biCompression); } // Read colors used, if present. if (m_infoHeader.biSize >= 36) m_infoHeader.biClrUsed = readUint32(32); // Windows V4+ can safely read the four bitmasks from 40-56 bytes in, so do // that here. If the bit depth is less than 16, these values will be // ignored by the image data decoders. If the bit depth is at least 16 but // the compression format isn't BITFIELDS, these values will be ignored and // overwritten* in processBitmasks(). // NOTE: We allow alpha here. Microsoft doesn't really document this well, // but some BMPs appear to use it. // // For non-Windows V4+, m_bitMasks[] et. al will be initialized later // during processBitmasks(). // // *Except the alpha channel. Bizarrely, some RGB bitmaps expect decoders // to pay attention to the alpha mask here, so there's a special case in // processBitmasks() that doesn't always overwrite that value. if (isWindowsV4Plus()) { m_bitMasks[0] = readUint32(40); m_bitMasks[1] = readUint32(44); m_bitMasks[2] = readUint32(48); m_bitMasks[3] = readUint32(52); } // Detect top-down BMPs. if (m_infoHeader.biHeight < 0) { m_isTopDown = true; m_infoHeader.biHeight = -m_infoHeader.biHeight; } return true; }
void Script_v2::o2_playInfogrames(FuncParams ¶ms) { startFunc(params); print("var8_%d", readUint16() * 4); endFunc(); }
void Script_v2::o2_loadMult(FuncParams ¶ms) { uint16 id; bool hasImds; id = readUint16(); if (id & 0x8000) { id &= 0x7FFF; skip(1); } startFunc(params); print("%d", id); endFunc(); if (!_extTable) error("EXT file needed"); uint32 size; byte *extData = _extTable->getItem(id - 30000, size); byte *data = extData; int32 count1, count2; count1 = ((int8) data[0]) + 1; hasImds = ((count1 & 0x80) != 0); count1 &= 0x7F; count2 = ((int8) data[1]) + 1; data += 2; // Statics for (int i = 0; i < count1; i++, data += 14) { int16 sSize; readExpr(); sSize = (int16) readUint16(); skip(sSize * 2); sSize = (int16) readUint16(); skip(2 + sSize * 8); } // Anims for (int i = 0; i < count2; i++, data += 14) { readExpr(); int16 sSize = (int16) readUint16(); skip(2 + sSize * 8); } // FPS data += 2; // StaticKeys count1 = (int16) READ_LE_UINT16(data); data += 2 + count1 * 4; // AnimKeys for (int i = 0; i < 4; i++) { count1 = (int16) READ_LE_UINT16(data); data += 2 + count1 * 10; } // fadePal data += 5 * 16 * 3; // palFadeKeys count1 = (int16) READ_LE_UINT16(data); data += 2 + count1 * 7; // palKeys count1 = (int16) READ_LE_UINT16(data); data += 2 + count1 * 80; // textKeys count1 = (int16) READ_LE_UINT16(data); data += 2 + count1 * (4 + (hasImds ? 0 : 24)); // soundKeys count1 = (int16) READ_LE_UINT16(data); data += 2; for (int i = 0; i < count1; i++, data += (12 + (hasImds ? 0 : 24))) { int16 cmd = (int16) READ_LE_UINT16(data + 2); if ((cmd == 1) || (cmd == 4)) skip(2); else if (cmd == 3) skip(4); } // ImdKeys if (hasImds) { int16 sSize = (int16) readUint16(); skip(sSize * 2); if (getVerScript() >= 51) { sSize = (int16) readUint16(); if (sSize > 0) skip(sSize * 14); } } delete[] extData; }