bool IOAudioPort::initWithAttributes(UInt32 portType, const char *portName, UInt32 subType, OSDictionary *properties) { if (!init(properties)) { return false; } if (portType == 0) { return false; } audioDevice = 0; isRegistered = false; setType(portType); if (portName != 0) { setName(portName); } if (subType != 0) { setSubType(subType); } audioControls = OSSet::withCapacity(1); if (!audioControls) { return false; } return true; }
void CItemArmor::SetAugmentMod(uint16 type, uint8 value) { // TODO: если augmenttype совпадает с modtype, то мы може установить значение сразу, // либо придется использовать дополнительную логику if (type != 0) { setSubType(ITEM_AUGMENTED); } //addModifier(new CModifier(type,value)); }
void CItemArmor::SetAugmentMod(uint16 type, uint8 value) { // TODO: if augmenttype coincides with modtype, then we can set right, // or have to use additional logic if (type != 0) { setSubType(ITEM_AUGMENTED); } //addModifier(new CModifier(type,value)); }
bool Item::unserialize(xmlNodePtr nodeItem) { int intValue; std::string strValue; if(readXMLInteger(nodeItem, "id", intValue)){ id = intValue; } else{ return false; } if(readXMLInteger(nodeItem, "count", intValue)){ setSubType(intValue); } if(readXMLString(nodeItem, "special_description", strValue)){ setSpecialDescription(strValue); } if(readXMLString(nodeItem, "text", strValue)){ setText(strValue); } if(readXMLInteger(nodeItem, "written_date", intValue)){ setWrittenDate(intValue); } if(readXMLString(nodeItem, "writer", strValue)){ setWriter(strValue); } if(readXMLInteger(nodeItem, "actionId", intValue)){ setActionId(intValue); } if(readXMLInteger(nodeItem, "uniqueId", intValue)){ setUniqueId(intValue); } if(readXMLInteger(nodeItem, "duration", intValue)){ setDuration(intValue); } if(readXMLInteger(nodeItem, "decayState", intValue)){ ItemDecayState_t decayState = (ItemDecayState_t)intValue; if(decayState != DECAYING_FALSE){ setDecaying(DECAYING_PENDING); } } return true; }
int EquipmentData::upgrade(bool cost_gold) { if (baseEq.get() && baseEq->m_next.get()) { baseEq = baseEq->m_next; baseid = baseEq->baseid; quality = baseEq->quality; up_quality = baseEq->up_quality; value = baseEq->baseValue; value2 = baseEq->baseValue2; if (!cost_gold) qLevel = equipmentUpgrade::getInstance()->convertUpgradeLevel(quality, type, qLevel); addValue = 0; addValue2 = 0; for (int l = 1; l <= qLevel; ++l) { int add2 = 0; int add = equipmentUpgrade::getInstance()->getUpgradeValue(up_quality, type, l, add2); addValue += add; addValue2 += add2; } price = 50*quality*(qLevel+1)*(qLevel+20); if (getGeneral().get()) { getGeneral()->updateEquipmentEffect(); } m_changed = true; setSubType(baseid); Save(); if (quality > 1 && NULL != getChar()) { //制造装备,请好友祝贺 - 蓝色品质及以上 Singleton<relationMgr>::Instance().postCongradulation(getChar()->m_id, CONGRATULATION_MAKE_EQUIP, baseid, 0); } #ifdef QQ_PLAT //首次制作装备分享 Singleton<inviteMgr>::Instance().update_event(getChar()->m_id, SHARE_EVENT_FIRST_MAKE_EQUIPTMENT, 0); #endif } }
void CompileAddArrayItem::compile(const shared_ptr<LinkedTokenList>& tokenList, shared_ptr<Token>& begin, shared_ptr<Token>& end, shared_ptr<LinkedActionList>& listActionNodes, shared_ptr<ActionNode>& actionBefore) { shared_ptr<Token> current = begin; int level = begin->getLevel(); bool pastIndex = false; vector<string> arrayIndexes; list<TokenExpectation> expected = list<TokenExpectation>(); if (!fromArray) { expected.push_back(TokenExpectation(level, IToken::IDENTIFIER)); expected.push_back(TokenExpectation(level, IToken::ARRAY_OPEN)); expected.push_back(TokenExpectation(level + 1, IToken::NUMBER)); expected.push_back(TokenExpectation(level, IToken::ARRAY_CLOSE)); expected.push_back(TokenExpectation(level, IToken::EQUALS)); expected.push_back(TokenExpectation(level, IToken::ANY)); } else { expected.push_back(TokenExpectation(level, IToken::ANY)); } shared_ptr<Token> temp = begin; for (TokenExpectation expectation : expected) { while (current->getType() == IToken::NEWLINE) { if (current->getNext() != nullptr) { current = current->getNext(); } else { break; } } if (current == nullptr) { auto error = make_shared<Error>("set an item not completed", ".md", -1, -1, ErrorType::ERROR); ErrorHandler::getInstance()->addError(error); begin = end; break; } string sBuffer; if (expectation.getLevel() == level) { if (expectation.getTokenType() != IToken::ANY && current->getType() != expectation.getTokenType()) { auto error = make_shared<Error>("", ".md", current->getLineNumber(), current->getPosition(), ErrorType::ERROR); ErrorHandler::getInstance()->addError(error, expectation.getTokenType(), current->getType()); begin = end; break; } if (expectation.getTokenType() == IToken::ANY) { CompileCondition compiledBodyPart; shared_ptr<Token> seperator = current; do { seperator = seperator->getNext(); } while (seperator->getType() != IToken::NEWLINE && seperator->getType() != IToken::ARRAY_CLOSE); if (fromArray) { auto tempToken = make_shared<Token>(current); for (auto it : itemPositionInMultiArray) { auto constTempToken = make_shared<Token>(current); constTempToken->setSubType(IToken::TYPE_NUMBER); shared_ptr<DirectFunctionCall> directFunctionCall = make_shared<DirectFunctionCall>(constTempToken); directFunctionCall->setArraySize(2); directFunctionCall->setAt(0, SET_CONST_TO_RT); directFunctionCall->setAt(1, to_string(it).c_str()); listActionNodes->insertBefore(actionBefore, directFunctionCall); directFunctionCall = make_shared<DirectFunctionCall>(tempToken); directFunctionCall->setArraySize(2); directFunctionCall->setAt(0, SET_GET_FROM_RT); directFunctionCall->setAt(1, getNextLocalVariableName(sBuffer).c_str()); listActionNodes->insertBefore(actionBefore, directFunctionCall); arrayIndexes.push_back(getCurrentLocalVariableName()); } } auto eBefore = actionBefore; auto tempToken = make_shared<Token>(current); compiledBodyPart.compile(tokenList, current, seperator, listActionNodes, eBefore); shared_ptr<DirectFunctionCall> directFunctionCall = make_shared<DirectFunctionCall>(tempToken); directFunctionCall->setArraySize(2); directFunctionCall->setAt(0, SET_GET_FROM_RT); directFunctionCall->setAt(1, getNextLocalVariableName(sBuffer).c_str()); listActionNodes->insertBefore(actionBefore, directFunctionCall); string tempArguments[2]; string current = getCurrentLocalVariableName(); int Size = 0; Size = 3+(arrayIndexes.size()); vector<string> saArguments(Size); shared_ptr<FunctionCall> pFunction = make_shared<FunctionCall>(tempToken); //HIER ARRAY INDEXES ERIN GOOIEN!!!! saArguments[0] = "$AddItemToArrayAt"; saArguments[1] = currentArray; int count = 2; for(auto it : arrayIndexes) { saArguments[count] = it; count++; } saArguments[count] = current; pFunction->setArraySize(saArguments.size()); for (size_t n = 0; n < saArguments.size(); n++) { pFunction->setAt(n, saArguments[n].c_str()); } listActionNodes->insertBefore(actionBefore, pFunction); } else if (current->getType() == IToken::IDENTIFIER) { currentArray = getNextLocalVariableName(sBuffer).c_str(); auto tempToken = make_shared<Token>(current); shared_ptr<DirectFunctionCall> directFunctionCall = make_shared<DirectFunctionCall>(tempToken); directFunctionCall->setArraySize(2); directFunctionCall->setAt(0, SET_ID_TO_RT); directFunctionCall->setAt(1, current->getText().c_str()); listActionNodes->insertBefore(actionBefore, directFunctionCall); tempToken= make_shared<Token>(current); directFunctionCall = make_shared<DirectFunctionCall>(tempToken); directFunctionCall->setArraySize(2); directFunctionCall->setAt(0, SET_GET_FROM_RT); directFunctionCall->setAt(1, currentArray.c_str()); listActionNodes->insertBefore(actionBefore, directFunctionCall); } if (current->getType() != IToken::NEWLINE) { current = current->getNext(); } } else if (expectation.getLevel() >= level) { if (current->getType() == IToken::ARRAY_CLOSE) { auto error = make_shared<Error>("", ".md", current->getLineNumber(), current->getPosition(), ErrorType::ERROR); ErrorHandler::getInstance()->addError(error, expectation.getTokenType(), IToken::NONE); begin = end; break; } shared_ptr<Token> arrayClose = current; while (arrayClose->getType() != IToken::ARRAY_OPEN) { arrayClose = arrayClose->getPrevious(); } arrayClose = arrayClose->getPartner(); vector<shared_ptr<LinkedTokenList>> paramList; shared_ptr<LinkedTokenList> param = make_shared<LinkedTokenList>(); stack<IToken> stack; do { if (current->getType() == IToken::ARRAY_OPEN || current->getType() == IToken::FUNCTION_DECLARE_OPEN) { stack.push(current->getType()); } else if ((current->getType() == IToken::ARRAY_CLOSE || current->getType() == IToken::FUNCTION_DECLARE_CLOSE) && stack.size() > 0) { stack.pop(); } if (stack.size() >= 0) { if (stack.size() == 0 && current->getType() == IToken::AND_PARA) { if (param->getLast() != nullptr) { createNewLineToken(param, paramList); } else { auto error = make_shared<Error>("no assignment is array", ".md", current->getLineNumber(),current->getPosition(), ErrorType::ERROR); ErrorHandler::getInstance()->addError(error); } param = make_shared<LinkedTokenList>(); } else { param->add(make_shared<Token>(current)); } } current = current->getNext(); if (stack.size() == 0 && current->getType() == IToken::ARRAY_CLOSE) { if (param->getLast() != nullptr) { createNewLineToken(param, paramList); } else { auto error = make_shared<Error>("no assignment is array", ".md", current->getLineNumber(),current->getPosition(), ErrorType::ERROR); ErrorHandler::getInstance()->addError(error); } param = make_shared<LinkedTokenList>(); break; } } while (current != arrayClose); if (paramList.size() > 1) { isMultiDimensional = true; pastIndex = true; } shared_ptr<Compiler> compiledBodyPart; for (auto params : paramList) { if (params->getSize() >2) { compiledBodyPart = make_shared<CompilePlusMinus>(); } else { compiledBodyPart = make_shared<CompileSingleStatement>(); } auto tempToken = make_shared<Token>(current); auto eFirst = params->getFirst(); auto eLast = params->getLast(); auto eBefore = actionBefore; compiledBodyPart->compile(tokenList, eFirst, eLast, listActionNodes, eBefore); shared_ptr<DirectFunctionCall> directFunctionCall = make_shared<DirectFunctionCall>(tempToken); directFunctionCall->setArraySize(2); directFunctionCall->setAt(0, SET_GET_FROM_RT); directFunctionCall->setAt(1, getNextLocalVariableName(sBuffer).c_str()); listActionNodes->insertBefore(actionBefore, directFunctionCall); arrayIndexes.push_back(getCurrentLocalVariableName()); } } } if (current != nullptr) { begin = current; } }
Attr_ReadValue Item::readAttr(AttrTypes_t attr, PropStream& propStream) { switch (attr) { case ATTR_COUNT: { uint8_t _count = 0; if (!propStream.GET_UCHAR(_count)) { return ATTR_READ_ERROR; } setSubType(_count); break; } case ATTR_ACTION_ID: { uint16_t _actionid = 0; if (!propStream.GET_USHORT(_actionid)) { return ATTR_READ_ERROR; } setActionId(_actionid); break; } case ATTR_UNIQUE_ID: { uint16_t _uniqueid; if (!propStream.GET_USHORT(_uniqueid)) { return ATTR_READ_ERROR; } setUniqueId(_uniqueid); break; } case ATTR_TEXT: { std::string _text; if (!propStream.GET_STRING(_text)) { return ATTR_READ_ERROR; } setText(_text); break; } case ATTR_WRITTENDATE: { uint32_t _writtenDate; if (!propStream.GET_ULONG(_writtenDate)) { return ATTR_READ_ERROR; } setDate(_writtenDate); break; } case ATTR_WRITTENBY: { std::string _writer; if (!propStream.GET_STRING(_writer)) { return ATTR_READ_ERROR; } setWriter(_writer); break; } case ATTR_DESC: { std::string _text; if (!propStream.GET_STRING(_text)) { return ATTR_READ_ERROR; } setSpecialDescription(_text); break; } case ATTR_RUNE_CHARGES: { uint8_t _charges = 1; if (!propStream.GET_UCHAR(_charges)) { return ATTR_READ_ERROR; } setSubType(_charges); break; } case ATTR_CHARGES: { uint16_t _charges = 1; if (!propStream.GET_USHORT(_charges)) { return ATTR_READ_ERROR; } setSubType(_charges); break; } case ATTR_DURATION: { uint32_t duration = 0; if (!propStream.GET_ULONG(duration)) { return ATTR_READ_ERROR; } if (((int32_t)duration) < 0) { duration = 0; } setDuration(duration); break; } case ATTR_DECAYING_STATE: { uint8_t state = 0; if (!propStream.GET_UCHAR(state)) { return ATTR_READ_ERROR; } if (state != DECAYING_FALSE) { setDecaying(DECAYING_PENDING); } break; } //these should be handled through derived classes //If these are called then something has changed in the items.xml since the map was saved //just read the values //Depot class case ATTR_DEPOT_ID: { uint16_t _depotId; if (!propStream.GET_USHORT(_depotId)) { return ATTR_READ_ERROR; } return ATTR_READ_CONTINUE; } //Door class case ATTR_HOUSEDOORID: { uint8_t _doorId; if (!propStream.GET_UCHAR(_doorId)) { return ATTR_READ_ERROR; } return ATTR_READ_CONTINUE; } //Bed class case ATTR_SLEEPERGUID: { uint32_t _guid; if (!propStream.GET_ULONG(_guid)) { return ATTR_READ_ERROR; } return ATTR_READ_CONTINUE; } case ATTR_SLEEPSTART: { uint32_t sleep_start; if (!propStream.GET_ULONG(sleep_start)) { return ATTR_READ_ERROR; } return ATTR_READ_CONTINUE; } //Teleport class case ATTR_TELE_DEST: { TeleportDest* tele_dest; if (!propStream.GET_STRUCT(tele_dest)) { return ATTR_READ_ERROR; } return ATTR_READ_CONTINUE; } //Container class case ATTR_CONTAINER_ITEMS: { uint32_t count; if (!propStream.GET_ULONG(count)) { return ATTR_READ_ERROR; } return ATTR_READ_ERROR; } default: return ATTR_READ_ERROR; } return ATTR_READ_CONTINUE; }
SubRouteRequestPacket::SubRouteRequestPacket(const DriverPref* driverPref, const SubRouteVector* origs, const OrigDestInfoList* dests, const OrigDestInfoList* allDests, bool routeToOneDest, uint32 cutOff, int levelDelta, const DisturbanceVector* disturbances, bool calcCostSums, bool dontSendSubRoutes, const DisturbanceVector* infoModuleDists ) { mc2dbg4 << "SubRouteRequestPacket::SubRouteRequestPacket" << endl; setPriority(DEFAULT_PACKET_PRIO); // Calculate size of request // Origins and destinations // Do something about the listtype if ( driverPref->getVehicleRestriction() != ItemTypes::pedestrian ) { setListType(SubRouteListTypes::LOWER_LEVEL); } else { // Pedestrian setListType(SubRouteListTypes::LOWER_LEVEL_WALK); // Lower level walk } uint32 reqSize = SUBROUTE_REQUEST_HEADER_SIZE; // The number of subroutes int nbrSubRoutes = origs->getSize() + // Add the destinations for HIGHER_LEVEL too ((getListType() == SubRouteListTypes::HIGHER_LEVEL) ? dests->size() : 0); // Origin. Will probably be removed if ( origs != NULL && getListType() == SubRouteListTypes::HIGHER_LEVEL ) reqSize += origs->size() * ORIG_DEST_SIZE; // Destinations if ( dests != NULL ) reqSize += dests->size() * ORIG_DEST_SIZE; // Subroutes. for(uint32 i=0; i < origs->size() ; i++ ) { reqSize += SUB_ROUTE_SIZE + SUB_ROUTE_CONNECTION_SIZE * 1; } // Compensate for disturbances // Length reqSize += 4; if ( disturbances != NULL ) { reqSize += DISTURBANCE_SIZE*disturbances->size(); } reqSize += 4; if ( infoModuleDists != NULL ) { reqSize += 8 * infoModuleDists->size(); } if ( reqSize > getBufSize() ) { mc2dbg2 << "SubRouteRequestPacket - buffer too small reallocing" << endl; byte* temp = MAKE_UINT32_ALIGNED_BYTE_BUFFER( reqSize * 2); memcpy(temp, this->buffer, SUBROUTE_REQUEST_HEADER_SIZE); delete [] this->buffer; this->buffer = temp; this->bufSize = reqSize * 2; } // First request? Won't exactly work all the time... bool original = origs->front()->getPrevSubRouteID() == MAX_UINT32; if ( levelDelta == 1 ) { // Higher level routing - do some tricks setMapID( FIRST_OVERVIEWMAP_ID ); setListType(SubRouteListTypes::HIGHER_LEVEL); } //setOriginIP(leaderIP); //setOriginPort(leaderPort); setSubType(Packet::PACKETTYPE_SUBROUTEREQUEST); // Get mapid from one of the origins setMapID(origs->front()->getNextMapID() ); // Setting the extra vehicle to avoid toll roads. uint32 extraVehicle = 0; if ( driverPref->avoidTollRoads() ) { extraVehicle |= ItemTypes::avoidTollRoad; } if ( driverPref->avoidHighways() ) { extraVehicle |= ItemTypes::avoidHighway; } setVehicleRestrictions( driverPref->getVehicleRestriction() | extraVehicle ); setRoutingCosts(driverPref->getRoutingCosts()); setUseTurnCost(driverPref->useUturn()); setTime(driverPref->getTime()); setMinWaitTime(driverPref->getMinWaitTime()); // Some flags. setRouteToAll(! routeToOneDest ); setDontSendSubRoutes( dontSendSubRoutes ); setCalcCostSums( calcCostSums ); setRouteID(0); // Don't know what it should be. Seems to be the same // as the request id, but for the RouteReader. setCutOff(cutOff); setIsOriginalRequest(original); // Add the origins that belongs to this mapID and only the first time. setNbrOrigins(0); int pos = SUBROUTE_REQUEST_HEADER_SIZE; if ( original ) { for(uint32 i=0; i < origs->getSize(); i++) { const SubRoute* curSubRoute = origs->getSubRouteAt(i); // Destinations are origins in next route. const OrigDestInfo* orig = curSubRoute->getDestInfo(); addOrigin(*orig, pos); // addOrigin(curSubRoute->getNextMapID(), // curSubRoute->getDestNodeID(), // curSubRoute->getDestOffset(), // MAX_UINT32, // MAX_UINT32, // pos); } } // Add all destinations ( not allDests, they aren't used yet) setNbrDestinations(0); OrigDestInfoList::const_iterator it; it = dests->begin(); while ( it != dests->end() ) { addDestination(*it, pos); it++; } setNbrSubRoutes( nbrSubRoutes ); for (uint32 i = 0; i < origs->getSize(); i++) { SubRoute* subRoute = (*origs)[i]; if (subRoute != NULL) { addSubRoute(subRoute, pos); } } if ( getListType() == SubRouteListTypes::HIGHER_LEVEL ) { OrigDestInfoList::const_iterator it(dests->begin()); for(uint32 i=0; i < dests->size() ; ++i ) { SubRoute subRoute(*it, *it); ++it; // Add backward subroute for each destination. // The routemodule uses them as destinations later. addSubRoute(&subRoute, pos, false); } } addDisturbances(pos, disturbances); // Add info module disturbances using the more compact format. addInfoModDisturbances( pos, infoModuleDists ); setLength(pos); if ( true || pos > (int)reqSize || (reqSize - pos) > 65536 ) { mc2dbg2 << "SubRouteRequestPacket - calcSize = " << reqSize << "real size = " << pos << endl; } } // Constructor
Attr_ReadValue Item::readAttr(AttrTypes_t attr, PropStream& propStream) { switch(attr) { case ATTR_COUNT: { uint8_t _count; if(!propStream.getByte(_count)) return ATTR_READ_ERROR; setSubType((uint16_t)_count); break; } case ATTR_ACTION_ID: { uint16_t aid; if(!propStream.getShort(aid)) return ATTR_READ_ERROR; setAttribute("aid", aid); break; } case ATTR_UNIQUE_ID: { uint16_t uid; if(!propStream.getShort(uid)) return ATTR_READ_ERROR; setUniqueId(uid); break; } case ATTR_NAME: { std::string name; if(!propStream.getString(name)) return ATTR_READ_ERROR; setAttribute("name", name); break; } case ATTR_PLURALNAME: { std::string name; if(!propStream.getString(name)) return ATTR_READ_ERROR; setAttribute("pluralname", name); break; } case ATTR_ARTICLE: { std::string article; if(!propStream.getString(article)) return ATTR_READ_ERROR; setAttribute("article", article); break; } case ATTR_ATTACK: { int32_t attack; if(!propStream.getLong((uint32_t&)attack)) return ATTR_READ_ERROR; setAttribute("attack", attack); break; } case ATTR_EXTRAATTACK: { int32_t attack; if(!propStream.getLong((uint32_t&)attack)) return ATTR_READ_ERROR; setAttribute("extraattack", attack); break; } case ATTR_DEFENSE: { int32_t defense; if(!propStream.getLong((uint32_t&)defense)) return ATTR_READ_ERROR; setAttribute("defense", defense); break; } case ATTR_EXTRADEFENSE: { int32_t defense; if(!propStream.getLong((uint32_t&)defense)) return ATTR_READ_ERROR; setAttribute("extradefense", defense); break; } case ATTR_ARMOR: { int32_t armor; if(!propStream.getLong((uint32_t&)armor)) return ATTR_READ_ERROR; setAttribute("armor", armor); break; } case ATTR_ATTACKSPEED: { int32_t attackSpeed; if(!propStream.getLong((uint32_t&)attackSpeed)) return ATTR_READ_ERROR; setAttribute("attackspeed", attackSpeed); break; } case ATTR_HITCHANCE: { int32_t hitChance; if(!propStream.getLong((uint32_t&)hitChance)) return ATTR_READ_ERROR; setAttribute("hitchance", hitChance); break; } case ATTR_SCRIPTPROTECTED: { uint8_t protection; if(!propStream.getByte(protection)) return ATTR_READ_ERROR; setAttribute("scriptprotected", protection != 0); break; } case ATTR_DUALWIELD: { uint8_t wield; if(!propStream.getByte(wield)) return ATTR_READ_ERROR; setAttribute("dualwield", wield != 0); break; } case ATTR_TEXT: { std::string text; if(!propStream.getString(text)) return ATTR_READ_ERROR; setAttribute("text", text); break; } case ATTR_WRITTENDATE: { int32_t date; if(!propStream.getLong((uint32_t&)date)) return ATTR_READ_ERROR; setAttribute("date", date); break; } case ATTR_WRITTENBY: { std::string writer; if(!propStream.getString(writer)) return ATTR_READ_ERROR; setAttribute("writer", writer); break; } case ATTR_DESC: { std::string text; if(!propStream.getString(text)) return ATTR_READ_ERROR; setAttribute("description", text); break; } case ATTR_RUNE_CHARGES: { uint8_t charges; if(!propStream.getByte(charges)) return ATTR_READ_ERROR; setSubType((uint16_t)charges); break; } case ATTR_CHARGES: { uint16_t charges; if(!propStream.getShort(charges)) return ATTR_READ_ERROR; setSubType(charges); break; } case ATTR_DURATION: { int32_t duration; if(!propStream.getLong((uint32_t&)duration)) return ATTR_READ_ERROR; setAttribute("duration", duration); break; } case ATTR_DECAYING_STATE: { uint8_t state; if(!propStream.getByte(state)) return ATTR_READ_ERROR; if((ItemDecayState_t)state != DECAYING_FALSE) setAttribute("decaying", (int32_t)DECAYING_PENDING); break; } //these should be handled through derived classes //if these are called then something has changed in the items.otb since the map was saved //just read the values //Depot class case ATTR_DEPOT_ID: { uint16_t depot; if(!propStream.getShort(depot)) return ATTR_READ_ERROR; break; } //Door class case ATTR_HOUSEDOORID: { uint8_t door; if(!propStream.getByte(door)) return ATTR_READ_ERROR; break; } //Teleport class case ATTR_TELE_DEST: { TeleportDest* dest; if(!propStream.getStruct(dest)) return ATTR_READ_ERROR; break; } //Bed class case ATTR_SLEEPERGUID: { uint32_t sleeper; if(!propStream.getLong(sleeper)) return ATTR_READ_ERROR; break; } case ATTR_SLEEPSTART: { uint32_t sleepStart; if(!propStream.getLong(sleepStart)) return ATTR_READ_ERROR; break; } //Container class case ATTR_CONTAINER_ITEMS: { uint32_t _count; propStream.getLong(_count); return ATTR_READ_ERROR; } //ItemAttributes class case ATTR_ATTRIBUTE_MAP: { bool unique = hasIntegerAttribute("uid"), ret = unserializeMap(propStream); if(!unique && hasIntegerAttribute("uid")) // unfortunately we have to do this ScriptEnviroment::addUniqueThing(this); // this attribute has a custom behavior as well if(getDecaying() != DECAYING_FALSE) setDecaying(DECAYING_PENDING); if(ret) break; } default: return ATTR_READ_ERROR; } return ATTR_READ_CONTINUE; }
QTextDragPrivate() { setSubType("plain"); }
int32_t BuildingType::init(FilePtr objFile, uint32_t fileSize) { int32_t result = 0; FitIniFile bldgFile; result = bldgFile.open(objFile, fileSize); if(result != NO_ERROR) return(result); //------------------------------------------------------------------- // Since this object type handles MC1's Building and TreeBuilding // object types, we need to check for both. Basically, "TreeBuilding" // stands for animated building. Ultimately, would be nice to get // rid of this misleading legacy object type... result = bldgFile.seekBlock("TreeData"); if(result != NO_ERROR) { result = bldgFile.seekBlock("BuildingData"); if(result != NO_ERROR) return(result); } uint32_t dmgLevel; result = bldgFile.readIdULong("DmgLevel", dmgLevel); if(result != NO_ERROR) return(result); damageLevel = (float)dmgLevel; result = bldgFile.readIdBoolean("CanRefit", canRefit); if(result != NO_ERROR) canRefit = false; if(canRefit) { result = bldgFile.readIdBoolean("MechBay", mechBay); if(result != NO_ERROR) mechBay = false; } result = bldgFile.readIdFloat("ExplosionRadius", explRad); if(result != NO_ERROR) explRad = 0.0; result = bldgFile.readIdFloat("ExplosionDamage", explDmg); if(result != NO_ERROR) explDmg = 0.0; result = bldgFile.readIdFloat("Tonnage", baseTonnage); if(result != NO_ERROR) baseTonnage = 20; result = bldgFile.readIdLong("BattleRating", startBR); if(result != NO_ERROR) startBR = 20; result = bldgFile.readIdLong("NumMarines", numMarines); if(result != NO_ERROR) numMarines = 0; float realExtent = 0.0; result = bldgFile.readIdFloat("ExtentRadius", realExtent); if(result != NO_ERROR) realExtent = -1.0; result = bldgFile.readIdULong("ActivityEffectID", activityEffectId); if(result != NO_ERROR) activityEffectId = 0xffffffff; //---------------------------- // Init sensor-related data... result = bldgFile.readIdLong("TeamID", teamId); if(result != NO_ERROR) teamId = -1; result = bldgFile.readIdFloat("SensorRange", sensorRange); if(result != NO_ERROR) sensorRange = -1.0; result = bldgFile.readIdLong("BuildingName", buildingTypeName); if(result != NO_ERROR) buildingTypeName = IDS_BLDOBJ_NAME; result = bldgFile.readIdLong("BuildingDescription", buildingDescriptionID); if(result != NO_ERROR) buildingDescriptionID = -1; result = bldgFile.readIdLong("BuildingDescription", buildingDescriptionID); if(result != NO_ERROR) buildingDescriptionID = -1; result = bldgFile.readIdLong("ResourcePoints", resourcePoints); if(result != NO_ERROR) resourcePoints = 0; result = bldgFile.readIdBoolean("ImpassableWhenDestroyed", marksImpassableWhenDestroyed); if(result != NO_ERROR) marksImpassableWhenDestroyed = true; result = bldgFile.readIdBoolean("Capturable", capturable); if(result != NO_ERROR) capturable = false; result = bldgFile.readIdBoolean("IsPowerSource", powerSource); if(result != NO_ERROR) powerSource = false; result = bldgFile.readIdFloat("LookoutTowerRange", lookoutTowerRange); if(result != NO_ERROR) lookoutTowerRange = 0.0f; result = bldgFile.readIdFloat("PerimeterAlarmRange", perimeterAlarmRange); if(result != NO_ERROR) perimeterAlarmRange = 0.0f; result = bldgFile.readIdFloat("PerimeterAlarmTimer", perimeterAlarmTimer); if(result != NO_ERROR) perimeterAlarmTimer = 0.0f; result = ObjectType::init(&bldgFile); extentRadius = realExtent; if(perimeterAlarmRange > 0.0f) extentRadius = perimeterAlarmRange; //-------------------------------------------------------------------------------- // HACK!!!!! Must fix this for localization purposes--should be in the object type // data (can't look in the string!) --gd int32_t objectNameID = buildingTypeName; if(objectNameID < IDS_MC2_STRING_START) objectNameID += IDS_MC2_STRING_START; if(objectNameID != -1) { char s[255]; cLoadString(objectNameID, s, 254); } for(size_t i = 0; i < 18; i++) { if(objTypeNum == WallType[i]) { setSubType(BUILDING_SUBTYPE_WALL); break; } } if(objTypeNum == BRIDGE_TYPE) setSubType(BUILDING_SUBTYPE_LANDBRIDGE); return(result); }