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);
}
