void VcfMaterializer::_loadLevels(int rID) { currentLevels.clear(); std::stringstream ssTop, ssBottom; ssTop << sequenceName(faiIndex, rID) << "/TOP"; unsigned idx = 0; if (!getIdByName(idx, methFaiIndex, ssTop.str().c_str())) throw MasonIOException("Could not find top levels in methylation FASTA."); readSequence(currentLevels.forward, methFaiIndex, idx); ssBottom << sequenceName(faiIndex, rID) << "/BOT"; if (!getIdByName(idx, methFaiIndex, ssBottom.str().c_str())) throw MasonIOException("Could not find bottom levels in methylation FASTA."); readSequence(currentLevels.reverse, methFaiIndex, idx); }
// Append the transcript names for the given record. void _appendTranscriptNames(seqan::String<unsigned> & tIDs, // transcript ids to write out seqan::StringSet<seqan::CharString> & contigNames, seqan::NameStoreCache<seqan::StringSet<seqan::CharString> > & cache, MyGffRecord const & record) { clear(tIDs); seqan::CharString groupNames; for (unsigned i = 0; i < length(record.tagNames); ++i) if (record.tagNames[i] == options.gffGroupBy) groupNames = record.tagValues[i]; if (empty(groupNames)) return; // Record has no group names. // Write out the ids of the transcripts that the record belongs to as indices in contigNames. unsigned idx = 0; seqan::StringSet<seqan::CharString> ss; strSplit(ss, groupNames, seqan::EqualsChar<','>()); for (unsigned i = 0; i < length(ss); ++i) { if (empty(ss[i])) continue; if (!getIdByName(contigNames, ss[i], idx, cache)) { appendValue(tIDs, length(contigNames)); appendName(contigNames, ss[i], cache); } else { appendValue(tIDs, idx); } } }
MonsterType* Monsters::getMonsterType(const std::string& name) { uint32_t mId = getIdByName(name); if(mId != 0) return getMonsterType(mId); return NULL; }
MonsterType* Monsters::getMonsterType(const std::string& name) { uint32_t mId = getIdByName(name); if (mId == 0) { return nullptr; } return getMonsterType(mId); }
void ProjectSplicedRoi::_updateRanges(seqan::GffRecord const & record, seqan::Segment<seqan::CharString, seqan::InfixSegment> const & name) { if (verbosity >= 3) std::cerr << "Updating " << name << "\t" << record.beginPos << "\t" << record.endPos << "\n"; unsigned idx = 0; if (getIdByName(groupNames, name, idx, groupNamesCache)) { ranges[idx].i1 = std::min(ranges[idx].i1, (int)record.beginPos); ranges[idx].i2 = std::max(ranges[idx].i2, (int)record.endPos); } else { idx = length(groupNames); appendName(groupNames, name, groupNamesCache); appendValue(ranges, TIntPair(record.beginPos, record.endPos)); } }
void _readFirstRecord(MyGffRecord & record) { record.rID = record.INVALID_IDX; // uninitialized bool found = false; while (!found && !atEnd(gffFileIn)) { readRecord(record, gffFileIn); // Translate ref to idx from VCF. unsigned idx = 0; if (!getIdByName(idx, vcfMat.faiIndex, record.ref)) throw MasonIOException("Reference name from GFF/GTF not in VCF!"); record.rID = idx; if (empty(options.gffType) || (options.gffType == record.type)) { found = true; break; } } if (!found) record.rID = seqan::maxValue<int>(); }
int main(int argc, char const ** argv) { double startTime = 0; // Parse command line. FxFaidxOptions options; seqan::ArgumentParser::ParseResult res = parseArgs(options, argc, argv); if (res != seqan::ArgumentParser::PARSE_OK) return res == seqan::ArgumentParser::PARSE_ERROR; // 1 on errors, 0 otherwise // --------------------------------------------------------------------------- // Index I/O // --------------------------------------------------------------------------- // Load index, create if necessary. startTime = sysTime(); seqan::FaiIndex faiIndex; if (load(faiIndex, toCString(options.inFastaPath), toCString(options.inFaiPath)) != 0) { if (options.verbosity >= 2) std::cerr << "Building Index " << options.inFaiPath << " ..."; if (buildIndex(toCString(options.inFastaPath), toCString(options.inFaiPath), seqan::Fai()) != 0) { std::cerr << "Could not build FAI index at " << options.inFaiPath << " for FASTA file " << options.inFastaPath << "\n"; return 1; } if (load(faiIndex, toCString(options.inFastaPath), toCString(options.inFaiPath)) != 0) { std::cerr << "Could not load FAI index we just build.\n"; return 1; } } if (options.verbosity >= 3) std::cerr << "Took " << (startTime - sysTime()) << " s\n"; // --------------------------------------------------------------------------- // Parse and Fetch Regions. // --------------------------------------------------------------------------- if (empty(options.regions)) return 0; // Parse out regions. seqan::String<Region> regions; for (unsigned i = 0; i < length(options.regions); ++i) { Region region; if (!parseRegion(region, options.regions[i])) { std::cerr << "Could not parse region " << options.regions[i] << "\n"; return 1; } unsigned seqId; if (!getIdByName(faiIndex, region.seqName, seqId)) { std::cerr << "Unknown sequence for region " << options.regions[i] << "\n"; return 1; } region.seqId = seqId; if (region.seqId < 0 || (unsigned)region.seqId >= length(faiIndex.indexEntryStore)) { std::cerr << "Invalid region " << options.regions[i] << "\n"; return 1; } appendValue(regions, region); } // Open output file. std::ostream * outPtr = &std::cout; std::ofstream outF; if (!empty(options.outFastaPath)) { outF.open(toCString(options.outFastaPath), std::ios::binary | std::ios::out); if (!outF.good()) { std::cerr << "Could not open output file " << options.outFastaPath << "\n"; return 1; } } // Retrieve output infixes and write to result. for (unsigned i = 0; i < length(regions); ++i) { Region const & region = regions[i]; seqan::CharString id = options.regions[i]; seqan::CharString seq; unsigned beginPos = 0; if (region.beginPos > 0) beginPos = region.beginPos; unsigned endPos = sequenceLength(faiIndex, (unsigned)region.seqId); if (region.endPos > 0 && (unsigned)region.endPos < endPos) endPos = region.endPos; if (beginPos > endPos) endPos = beginPos; getSequenceInfix(seq, faiIndex, region.seqId, beginPos, endPos); if (writeRecord(*outPtr, id, seq, seqan::Fasta()) != 0) { std::cerr << "Could not write infix for region " << options.regions[i] << " to output.\n"; return 1; } } return 0; }
bool Monsters::loadMonster(const std::string& file, const std::string& monsterName, bool reloading/* = false*/) { if(getIdByName(monsterName) && !reloading) { std::clog << "[Warning - Monsters::loadMonster] Duplicate registered monster with name: " << monsterName << std::endl; return true; } bool monsterLoad, new_mType = true; MonsterType* mType = NULL; if(reloading) { uint32_t id = getIdByName(monsterName); if(id != 0) { mType = getMonsterType(id); if(mType != NULL) { new_mType = false; mType->reset(); } } } if(new_mType) mType = new MonsterType(); xmlDocPtr doc = xmlParseFile(file.c_str()); if(!doc) { std::clog << "[Warning - Monsters::loadMonster] Cannot load monster (" << monsterName << ") file (" << file << ")." << std::endl; std::clog << getLastXMLError() << std::endl; return false; } monsterLoad = true; xmlNodePtr root = xmlDocGetRootElement(doc); if(xmlStrcmp(root->name,(const xmlChar*)"monster")) { std::clog << "[Error - Monsters::loadMonster] Malformed monster (" << monsterName << ") file (" << file << ")." << std::endl; xmlFreeDoc(doc); return false; } int32_t intValue; std::string strValue; if(readXMLString(root, "name", strValue)) mType->name = strValue; else monsterLoad = false; if(readXMLString(root, "nameDescription", strValue)) mType->nameDescription = strValue; else { mType->nameDescription = "a " + mType->name; toLowerCaseString(mType->nameDescription); } if(readXMLString(root, "race", strValue)) { std::string tmpStrValue = asLowerCaseString(strValue); if(tmpStrValue == "venom") mType->race = RACE_VENOM; else if(tmpStrValue == "blood") mType->race = RACE_BLOOD; else if(tmpStrValue == "undead") mType->race = RACE_UNDEAD; else if(tmpStrValue == "fire") mType->race = RACE_FIRE; else if(tmpStrValue == "energy") mType->race = RACE_ENERGY; else { int32_t race = atoi(strValue.c_str()); if(race < RACE_VENOM || race > RACE_ENERGY) { SHOW_XML_WARNING("Unknown race type " << strValue); } else mType->race = (RaceType_t)race; } } if(readXMLInteger(root, "experience", intValue)) mType->experience = intValue; if(readXMLInteger(root, "speed", intValue)) mType->baseSpeed = intValue; if(readXMLInteger(root, "manacost", intValue)) mType->manaCost = intValue; if(readXMLString(root, "skull", strValue)) mType->skull = getSkulls(strValue); if(readXMLString(root, "shield", strValue)) mType->partyShield = getShields(strValue); if(readXMLString(root, "emblem", strValue)) mType->guildEmblem = getEmblems(strValue); for(xmlNodePtr p = root->children; p; p = p->next) { if(p->type != XML_ELEMENT_NODE) continue; if(!xmlStrcmp(p->name, (const xmlChar*)"health")) { if(!readXMLInteger(p, "max", intValue)) { SHOW_XML_ERROR("Missing health.max"); monsterLoad = false; break; } mType->healthMax = intValue; if(!readXMLInteger(p, "now", intValue)) mType->health = mType->healthMax; else mType->health = intValue; } else if(!xmlStrcmp(p->name, (const xmlChar*)"flags")) { for(xmlNodePtr tmpNode = p->children; tmpNode; tmpNode = tmpNode->next) { if(!xmlStrcmp(tmpNode->name, (const xmlChar*)"flag")) { if(readXMLString(tmpNode, "summonable", strValue)) mType->isSummonable = booleanString(strValue); if(readXMLString(tmpNode, "attackable", strValue)) mType->isAttackable = booleanString(strValue); if(readXMLString(tmpNode, "hostile", strValue)) mType->isHostile = booleanString(strValue); if(readXMLString(tmpNode, "illusionable", strValue)) mType->isIllusionable = booleanString(strValue); if(readXMLString(tmpNode, "convinceable", strValue)) mType->isConvinceable = booleanString(strValue); if(readXMLString(tmpNode, "pushable", strValue)) mType->pushable = booleanString(strValue); if(readXMLString(tmpNode, "canpushitems", strValue)) mType->canPushItems = booleanString(strValue); if(readXMLString(tmpNode, "canpushcreatures", strValue)) mType->canPushCreatures = booleanString(strValue); if(readXMLString(tmpNode, "hidename", strValue)) mType->hideName = booleanString(strValue); if(readXMLString(tmpNode, "hidehealth", strValue)) mType->hideHealth = booleanString(strValue); if(readXMLInteger(tmpNode, "lootmessage", intValue)) mType->lootMessage = (LootMessage_t)intValue; if(readXMLInteger(tmpNode, "staticattack", intValue)) { if(intValue < 0 || intValue > 100) { SHOW_XML_WARNING("staticattack lower than 0 or greater than 100"); intValue = 0; } mType->staticAttackChance = intValue; } if(readXMLInteger(tmpNode, "lightlevel", intValue)) mType->lightLevel = intValue; if(readXMLInteger(tmpNode, "lightcolor", intValue)) mType->lightColor = intValue; if(readXMLInteger(tmpNode, "targetdistance", intValue)) { if(intValue > Map::maxViewportX) SHOW_XML_WARNING("targetdistance greater than maxViewportX"); mType->targetDistance = std::max(1, intValue); } if(readXMLInteger(tmpNode, "runonhealth", intValue)) mType->runAwayHealth = intValue; if(readXMLString(tmpNode, "lureable", strValue)) mType->isLureable = booleanString(strValue); if(readXMLString(tmpNode, "walkable", strValue)) mType->isWalkable = booleanString(strValue); if(readXMLString(tmpNode, "skull", strValue)) mType->skull = getSkulls(strValue); if(readXMLString(tmpNode, "shield", strValue)) mType->partyShield = getShields(strValue); if(readXMLString(tmpNode, "emblem", strValue)) mType->guildEmblem = getEmblems(strValue); } } //if a monster can push creatures, it should not be pushable if(mType->canPushCreatures && mType->pushable) mType->pushable = false; } else if(!xmlStrcmp(p->name, (const xmlChar*)"targetchange")) { if(readXMLInteger(p, "speed", intValue) || readXMLInteger(p, "interval", intValue)) mType->changeTargetSpeed = std::max(1, intValue); else SHOW_XML_WARNING("Missing targetchange.speed"); if(readXMLInteger(p, "chance", intValue)) mType->changeTargetChance = intValue; else SHOW_XML_WARNING("Missing targetchange.chance"); } else if(!xmlStrcmp(p->name, (const xmlChar*)"strategy")) { if(readXMLInteger(p, "attack", intValue)) {} //mType->attackStrength = intValue; if(readXMLInteger(p, "defense", intValue)) {} //mType->defenseStrength = intValue; } else if(!xmlStrcmp(p->name, (const xmlChar*)"look")) { if(readXMLInteger(p, "type", intValue)) { mType->outfit.lookType = intValue; if(readXMLInteger(p, "head", intValue)) mType->outfit.lookHead = intValue; if(readXMLInteger(p, "body", intValue)) mType->outfit.lookBody = intValue; if(readXMLInteger(p, "legs", intValue)) mType->outfit.lookLegs = intValue; if(readXMLInteger(p, "feet", intValue)) mType->outfit.lookFeet = intValue; if(readXMLInteger(p, "addons", intValue)) mType->outfit.lookAddons = intValue; } else if(readXMLInteger(p, "typeex", intValue)) mType->outfit.lookTypeEx = intValue; else SHOW_XML_WARNING("Missing look type/typeex"); if(readXMLInteger(p, "corpse", intValue)) mType->lookCorpse = intValue; if(readXMLInteger(p, "corpseUniqueId", intValue) || readXMLInteger(p, "corpseUid", intValue)) mType->corpseUnique = intValue; if(readXMLInteger(p, "corpseActionId", intValue) || readXMLInteger(p, "corpseAid", intValue)) mType->corpseAction = intValue; } else if(!xmlStrcmp(p->name, (const xmlChar*)"attacks")) { for(xmlNodePtr tmpNode = p->children; tmpNode; tmpNode = tmpNode->next) { if(!xmlStrcmp(tmpNode->name, (const xmlChar*)"attack")) { spellBlock_t sb; if(deserializeSpell(tmpNode, sb, monsterName)) mType->spellAttackList.push_back(sb); else SHOW_XML_WARNING("Cant load spell"); } } } else if(!xmlStrcmp(p->name, (const xmlChar*)"defenses")) { if(readXMLInteger(p, "defense", intValue)) mType->defense = intValue; if(readXMLInteger(p, "armor", intValue)) mType->armor = intValue; for(xmlNodePtr tmpNode = p->children; tmpNode; tmpNode = tmpNode->next) { if(!xmlStrcmp(tmpNode->name, (const xmlChar*)"defense")) { spellBlock_t sb; if(deserializeSpell(tmpNode, sb, monsterName)) mType->spellDefenseList.push_back(sb); else SHOW_XML_WARNING("Cant load spell"); } } } else if(!xmlStrcmp(p->name, (const xmlChar*)"immunities")) { for(xmlNodePtr tmpNode = p->children; tmpNode; tmpNode = tmpNode->next) { if(!xmlStrcmp(tmpNode->name, (const xmlChar*)"immunity")) { if(readXMLString(tmpNode, "name", strValue)) { std::string tmpStrValue = asLowerCaseString(strValue); if(tmpStrValue == "physical") { mType->damageImmunities |= COMBAT_PHYSICALDAMAGE; mType->conditionImmunities |= CONDITION_PHYSICAL; } else if(tmpStrValue == "energy") { mType->damageImmunities |= COMBAT_ENERGYDAMAGE; mType->conditionImmunities |= CONDITION_ENERGY; } else if(tmpStrValue == "fire") { mType->damageImmunities |= COMBAT_FIREDAMAGE; mType->conditionImmunities |= CONDITION_FIRE; } else if(tmpStrValue == "poison" || tmpStrValue == "earth") { mType->damageImmunities |= COMBAT_EARTHDAMAGE; mType->conditionImmunities |= CONDITION_POISON; } else if(tmpStrValue == "ice") { mType->damageImmunities |= COMBAT_ICEDAMAGE; mType->conditionImmunities |= CONDITION_FREEZING; } else if(tmpStrValue == "holy") { mType->damageImmunities |= COMBAT_HOLYDAMAGE; mType->conditionImmunities |= CONDITION_DAZZLED; } else if(tmpStrValue == "death") { mType->damageImmunities |= COMBAT_DEATHDAMAGE; mType->conditionImmunities |= CONDITION_CURSED; } else if(tmpStrValue == "drown") { mType->damageImmunities |= COMBAT_DROWNDAMAGE; mType->conditionImmunities |= CONDITION_DROWN; } else if(tmpStrValue == "lifedrain") mType->damageImmunities |= COMBAT_LIFEDRAIN; else if(tmpStrValue == "manadrain") mType->damageImmunities |= COMBAT_MANADRAIN; else if(tmpStrValue == "paralyze") mType->conditionImmunities |= CONDITION_PARALYZE; else if(tmpStrValue == "outfit") mType->conditionImmunities |= CONDITION_OUTFIT; else if(tmpStrValue == "drunk") mType->conditionImmunities |= CONDITION_DRUNK; else if(tmpStrValue == "invisible") mType->conditionImmunities |= CONDITION_INVISIBLE; else SHOW_XML_WARNING("Unknown immunity name " << strValue); } else if(readXMLString(tmpNode, "physical", strValue) && booleanString(strValue)) { mType->damageImmunities |= COMBAT_PHYSICALDAMAGE; //mType->conditionImmunities |= CONDITION_PHYSICAL; } else if(readXMLString(tmpNode, "energy", strValue) && booleanString(strValue)) { mType->damageImmunities |= COMBAT_ENERGYDAMAGE; mType->conditionImmunities |= CONDITION_ENERGY; } else if(readXMLString(tmpNode, "fire", strValue) && booleanString(strValue)) { mType->damageImmunities |= COMBAT_FIREDAMAGE; mType->conditionImmunities |= CONDITION_FIRE; } else if((readXMLString(tmpNode, "poison", strValue) || readXMLString(tmpNode, "earth", strValue)) && booleanString(strValue)) { mType->damageImmunities |= COMBAT_EARTHDAMAGE; mType->conditionImmunities |= CONDITION_POISON; } else if(readXMLString(tmpNode, "drown", strValue) && booleanString(strValue)) { mType->damageImmunities |= COMBAT_DROWNDAMAGE; mType->conditionImmunities |= CONDITION_DROWN; } else if(readXMLString(tmpNode, "ice", strValue) && booleanString(strValue)) { mType->damageImmunities |= COMBAT_ICEDAMAGE; mType->conditionImmunities |= CONDITION_FREEZING; } else if(readXMLString(tmpNode, "holy", strValue) && booleanString(strValue)) { mType->damageImmunities |= COMBAT_HOLYDAMAGE; mType->conditionImmunities |= CONDITION_DAZZLED; } else if(readXMLString(tmpNode, "death", strValue) && booleanString(strValue)) { mType->damageImmunities |= COMBAT_DEATHDAMAGE; mType->conditionImmunities |= CONDITION_CURSED; } else if(readXMLString(tmpNode, "lifedrain", strValue) && booleanString(strValue)) mType->damageImmunities |= COMBAT_LIFEDRAIN; else if(readXMLString(tmpNode, "manadrain", strValue) && booleanString(strValue)) mType->damageImmunities |= COMBAT_LIFEDRAIN; else if(readXMLString(tmpNode, "paralyze", strValue) && booleanString(strValue)) mType->conditionImmunities |= CONDITION_PARALYZE; else if(readXMLString(tmpNode, "outfit", strValue) && booleanString(strValue)) mType->conditionImmunities |= CONDITION_OUTFIT; else if(readXMLString(tmpNode, "drunk", strValue) && booleanString(strValue)) mType->conditionImmunities |= CONDITION_DRUNK; else if(readXMLString(tmpNode, "invisible", strValue) && booleanString(strValue)) mType->conditionImmunities |= CONDITION_INVISIBLE; } } } else if(!xmlStrcmp(p->name, (const xmlChar*)"voices")) { if(readXMLInteger(p, "speed", intValue) || readXMLInteger(p, "interval", intValue)) mType->yellSpeedTicks = intValue; else SHOW_XML_WARNING("Missing voices.speed"); if(readXMLInteger(p, "chance", intValue)) mType->yellChance = intValue; else SHOW_XML_WARNING("Missing voices.chance"); for(xmlNodePtr tmpNode = p->children; tmpNode; tmpNode = tmpNode->next) { if(!xmlStrcmp(tmpNode->name, (const xmlChar*)"voice")) { voiceBlock_t vb; vb.text = ""; vb.yellText = false; if(readXMLString(tmpNode, "sentence", strValue)) vb.text = strValue; else SHOW_XML_WARNING("Missing voice.sentence"); if(readXMLString(tmpNode, "yell", strValue)) vb.yellText = booleanString(strValue); mType->voiceVector.push_back(vb); } } } else if(!xmlStrcmp(p->name, (const xmlChar*)"loot")) { for(xmlNodePtr tmpNode = p->children; tmpNode; tmpNode = tmpNode->next) { if(tmpNode->type != XML_ELEMENT_NODE) continue; LootBlock rootBlock; if(loadLoot(tmpNode, rootBlock)) mType->lootItems.push_back(rootBlock); else SHOW_XML_WARNING("Cant load loot"); } } else if(!xmlStrcmp(p->name, (const xmlChar*)"elements")) { for(xmlNodePtr tmpNode = p->children; tmpNode; tmpNode = tmpNode->next) { if(!xmlStrcmp(tmpNode->name, (const xmlChar*)"element")) { if(readXMLInteger(tmpNode, "firePercent", intValue)) mType->elementMap[COMBAT_FIREDAMAGE] = intValue; else if(readXMLInteger(tmpNode, "energyPercent", intValue)) mType->elementMap[COMBAT_ENERGYDAMAGE] = intValue; else if(readXMLInteger(tmpNode, "icePercent", intValue)) mType->elementMap[COMBAT_ICEDAMAGE] = intValue; else if(readXMLInteger(tmpNode, "poisonPercent", intValue) || readXMLInteger(tmpNode, "earthPercent", intValue)) mType->elementMap[COMBAT_EARTHDAMAGE] = intValue; else if(readXMLInteger(tmpNode, "holyPercent", intValue)) mType->elementMap[COMBAT_HOLYDAMAGE] = intValue; else if(readXMLInteger(tmpNode, "deathPercent", intValue)) mType->elementMap[COMBAT_DEATHDAMAGE] = intValue; else if(readXMLInteger(tmpNode, "drownPercent", intValue)) mType->elementMap[COMBAT_DROWNDAMAGE] = intValue; else if(readXMLInteger(tmpNode, "physicalPercent", intValue)) mType->elementMap[COMBAT_PHYSICALDAMAGE] = intValue; else if(readXMLInteger(tmpNode, "lifeDrainPercent", intValue)) mType->elementMap[COMBAT_LIFEDRAIN] = intValue; else if(readXMLInteger(tmpNode, "manaDrainPercent", intValue)) mType->elementMap[COMBAT_MANADRAIN] = intValue; else if(readXMLInteger(tmpNode, "healingPercent", intValue)) mType->elementMap[COMBAT_HEALING] = intValue; else if(readXMLInteger(tmpNode, "undefinedPercent", intValue)) mType->elementMap[COMBAT_UNDEFINEDDAMAGE] = intValue; } } } else if(!xmlStrcmp(p->name, (const xmlChar*)"summons")) { if(readXMLInteger(p, "maxSummons", intValue) || readXMLInteger(p, "max", intValue)) mType->maxSummons = intValue; for(xmlNodePtr tmpNode = p->children; tmpNode; tmpNode = tmpNode->next) { if(!xmlStrcmp(tmpNode->name, (const xmlChar*)"summon")) { uint32_t chance = 100, interval = 1000, amount = 1; if(readXMLInteger(tmpNode, "speed", intValue) || readXMLInteger(tmpNode, "interval", intValue)) interval = intValue; if(readXMLInteger(tmpNode, "chance", intValue)) chance = intValue; if(readXMLInteger(tmpNode, "amount", intValue) || readXMLInteger(tmpNode, "max", intValue)) amount = intValue; if(readXMLString(tmpNode, "name", strValue)) { summonBlock_t sb; sb.name = strValue; sb.interval = interval; sb.chance = chance; sb.amount = amount; mType->summonList.push_back(sb); } else SHOW_XML_WARNING("Missing summon.name"); } } } else if(!xmlStrcmp(p->name, (const xmlChar*)"script")) { for(xmlNodePtr tmpNode = p->children; tmpNode; tmpNode = tmpNode->next) { if(!xmlStrcmp(tmpNode->name, (const xmlChar*)"event")) { if(readXMLString(tmpNode, "name", strValue)) mType->scriptList.push_back(strValue); else SHOW_XML_WARNING("Missing name for script event"); } } } else SHOW_XML_WARNING("Unknown attribute type - " << p->name); } xmlFreeDoc(doc); if(!monsterLoad) { if(new_mType) delete mType; return false; } static uint32_t id = 0; if(new_mType) { monsterNames[asLowerCaseString(monsterName)] = ++id; monsters[id] = mType; } return true; }
int main(int argc, char const ** argv) { if (argc != 7) { std::cerr << "USAGE: " << argv[0] << " IN.bam IN.bam.bai REF BEGIN END COUNT\n"; return 1; } // Open BGZF Stream for reading. seqan::Stream<seqan::Bgzf> inStream; if (!open(inStream, argv[1], "r")) { std::cerr << "ERROR: Could not open " << argv[1] << " for reading.\n"; return 1; } // Read BAI index. seqan::BamIndex<seqan::Bai> baiIndex; if (read(baiIndex, argv[2]) != 0) { std::cerr << "ERROR: Could not read BAI index file " << argv[2] << "\n"; return 1; } // Setup name store, cache, and BAM I/O context. typedef seqan::StringSet<seqan::CharString> TNameStore; typedef seqan::NameStoreCache<TNameStore> TNameStoreCache; typedef seqan::BamIOContext<TNameStore> TBamIOContext; TNameStore nameStore; TNameStoreCache nameStoreCache(nameStore); TBamIOContext context(nameStore, nameStoreCache); // Read header. seqan::BamHeader header; if (readRecord(header, context, inStream, seqan::Bam()) != 0) { std::cerr << "ERROR: Could not read header from BAM file " << argv[1] << "\n"; return 1; } // Translate from reference name to rId. int rId = 0; if (!getIdByName(nameStore, argv[3], rId, nameStoreCache)) { std::cerr << "ERROR: Reference sequence named " << argv[3] << " not known.\n"; return 1; } // Translate BEGIN and END arguments to number, 1-based to 0-based. int beginPos = 0, endPos = 0; if (!seqan::lexicalCast2(beginPos, argv[4]) || beginPos <= 0) { std::cerr << "ERROR: Begin position " << argv[4] << " is invalid.\n"; return 1; } beginPos -= 1; // 1-based to 0-based. if (!seqan::lexicalCast2(endPos, argv[5]) || endPos <= 0) { std::cerr << "ERROR: End position " << argv[5] << " is invalid.\n"; return 1; } endPos -= 1; // 1-based to 0-based. // Translate number of elements to print to number. int num = 0; if (!seqan::lexicalCast2(num, argv[6])) { std::cerr << "ERROR: Count " << argv[6] << " is invalid.\n"; return 1; } // Jump the BGZF stream to this position. bool hasAlignments = false; if (!jumpToRegion(inStream, hasAlignments, context, rId, beginPos, endPos, baiIndex)) { std::cerr << "ERROR: Could not jump to " << argv[3] << ":" << argv[4] << "\n"; return 1; } if (!hasAlignments) return 0; // No alignments here. // Seek linearly to the selected position. seqan::BamAlignmentRecord record; int numPrinted = 0; while (!atEnd(inStream) && numPrinted < num) { if (readRecord(record, context, inStream, seqan::Bam()) != 0) { std::cerr << "ERROR: Could not read record from BAM file.\n"; return 1; } // If we are on the next reference or at the end already then we stop. if (record.rId == -1 || record.rId > rId || record.pos >= endPos) break; // If we are left of the selected position then we skip this record. if (record.pos < beginPos) continue; // Otherwise, we print it to the user. numPrinted += 1; if (write2(std::cout, record, context, seqan::Sam()) != 0) { std::cerr << "ERROR: Could not write record to stdout.\n"; return 1; } } return 0; }
int main(int argc, char const ** argv) { double startTime = 0; // ----------------------------------------------------------------------- // Parse command line. // ----------------------------------------------------------------------- FxSamCoverageOptions options; seqan::ArgumentParser::ParseResult res = parseArgs(options, argc, argv); if (res != seqan::ArgumentParser::PARSE_OK) return res == seqan::ArgumentParser::PARSE_ERROR; // 1 on errors, 0 otherwise // ----------------------------------------------------------------------- // Show options. // ----------------------------------------------------------------------- if (options.verbosity >= 1) { std::cerr << "____OPTIONS___________________________________________________________________\n" << "\n" << "VERBOSITY " << options.verbosity << "\n" << "GENOME " << options.inGenomePath << "\n" << "SAM " << options.inSamPath << "\n" << "OUT " << options.outPath << "\n" << "WINDOW SIZE " << options.windowSize << "\n"; } // ----------------------------------------------------------------------- // Load Genome FAI Index // ----------------------------------------------------------------------- std::cerr << "\n" << "___PREPRATION_____________________________________________________________________\n" << "\n" << "Indexing GENOME file " << options.inGenomePath << " ..."; seqan::FaiIndex faiIndex; if (build(faiIndex, toCString(options.inGenomePath)) != 0) { std::cerr << "Could not build FAI index.\n"; return 1; } std::cerr << " OK\n"; // Prepare bins. seqan::String<seqan::String<BinData> > bins; resize(bins, numSeqs(faiIndex)); // ----------------------------------------------------------------------- // Compute C+G content // ----------------------------------------------------------------------- std::cerr << "\n" << "___C+G CONTENT COMPUTATION________________________________________________________\n" << "\n"; for (unsigned i = 0; i < numSeqs(faiIndex); ++i) { std::cerr << "[" << sequenceName(faiIndex, i) << "] ..."; unsigned numBins = (sequenceLength(faiIndex, i) + options.windowSize - 1) / options.windowSize; resize(bins[i], numBins); seqan::Dna5String contigSeq; if (readSequence(contigSeq, faiIndex, i) != 0) { std::cerr << "\nERROR: Could not read sequence " << sequenceName(faiIndex, i) << " from file!\n"; return 1; } for (unsigned bin = 0; bin < numBins; ++bin) { unsigned cgCounter = 0; unsigned binSize = 0; bins[i][bin].length = options.windowSize; if ((bin + 1) * options.windowSize > length(contigSeq)) bins[i][bin].length = length(contigSeq) - bin * options.windowSize; for (unsigned pos = bin * options.windowSize; pos < length(contigSeq) && pos < (bin + 1) * options.windowSize; ++pos, ++binSize) cgCounter += (contigSeq[pos] == 'C' || contigSeq[pos] == 'G'); bins[i][bin].cgContent = 1.0 * cgCounter / binSize; } std::cerr << "DONE\n"; } // ----------------------------------------------------------------------- // Compute Coverage // ----------------------------------------------------------------------- std::cerr << "\n" << "___COVERAGE COMPUATATION________________________________________________________\n" << "\n" << "Computing Coverage..."; seqan::BamStream bamStream(toCString(options.inSamPath)); if (!isGood(bamStream)) { std::cerr << "Could not open " << options.inSamPath << "!\n"; return 1; } seqan::BamAlignmentRecord record; while (!atEnd(bamStream)) { if (readRecord(record, bamStream) != 0) { std::cerr << "ERROR: Could not read record from BAM file!\n"; return 1; } if (hasFlagUnmapped(record) || hasFlagSecondary(record) || record.rId == seqan::BamAlignmentRecord::INVALID_REFID) continue; // Skip these records. int contigId = 0; seqan::CharString const & contigName = nameStore(bamStream.bamIOContext)[record.rId]; if (!getIdByName(faiIndex, contigName, contigId)) { std::cerr << "ERROR: Alignment to unknown contig " << contigId << "!\n"; return 1; } unsigned binNo = record.pos / options.windowSize; bins[contigId][binNo].coverage += 1; } std::cerr << "DONE\n"; // ----------------------------------------------------------------------- // Write Output // ----------------------------------------------------------------------- std::ostream * out = &std::cout; std::ofstream outFile; if (options.outPath != "-") { outFile.open(toCString(options.outPath), std::ios::binary | std::ios::out); if (!outFile.good()) { std::cerr << "ERROR: Could not open output file " << options.outPath << "!\n"; return 1; } out = &outFile; } (*out) << "#BIN\tREF_NAME\tREF_BIN\tBIN_BEGIN\tBIN_LENGTH\tCOVERAGE\tCG_CONTENT\n"; for (unsigned i = 0, globalBin = 0; i < length(bins); ++i) { for (unsigned refBin = 0; refBin < length(bins[i]); ++refBin, ++globalBin) { (*out) << globalBin << '\t' << sequenceName(faiIndex, i) << '\t' << refBin << '\t' << refBin * options.windowSize << '\t' << bins[i][refBin].length << '\t' << bins[i][refBin].coverage << '\t' << bins[i][refBin].cgContent << '\n'; } } if (options.verbosity >= 2) std::cerr << "Took " << (sysTime() - startTime) << " s\n"; return 0; }
bool Monsters::loadMonster(const std::string& file, const std::string& monster_name, bool reloading /*= false*/) { MonsterType* mType = nullptr; bool new_mType = true; if (reloading) { uint32_t id = getIdByName(monster_name); if (id != 0) { mType = getMonsterType(id); if (mType != nullptr) { new_mType = false; mType->reset(); } } } if (new_mType) { mType = new MonsterType(); } pugi::xml_document doc; pugi::xml_parse_result result = doc.load_file(file.c_str()); if (!result) { if (new_mType) { delete mType; } std::cout << "[Error - Monsters::loadMonster] Failed to load " << file << ": " << result.description() << std::endl; return false; } pugi::xml_node monsterNode = doc.child("monster"); if (!monsterNode) { if (new_mType) { delete mType; } std::cout << "[Error - Monsters::loadMonster] Missing monster node in: " << file << std::endl; return false; } pugi::xml_attribute attr; if (!(attr = monsterNode.attribute("name"))) { if (new_mType) { delete mType; } std::cout << "[Error - Monsters::loadMonster] Missing name in: " << file << std::endl; return false; } mType->name = attr.as_string(); if ((attr = monsterNode.attribute("nameDescription"))) { mType->nameDescription = attr.as_string(); } else { mType->nameDescription = "a " + mType->name; toLowerCaseString(mType->nameDescription); } if ((attr = monsterNode.attribute("race"))) { std::string tmpStrValue = asLowerCaseString(attr.as_string()); uint16_t tmpInt = pugi::cast<uint16_t>(attr.value()); if (tmpStrValue == "venom" || tmpInt == 1) { mType->race = RACE_VENOM; } else if (tmpStrValue == "blood" || tmpInt == 2) { mType->race = RACE_BLOOD; } else if (tmpStrValue == "undead" || tmpInt == 3) { mType->race = RACE_UNDEAD; } else if (tmpStrValue == "fire" || tmpInt == 4) { mType->race = RACE_FIRE; } else if (tmpStrValue == "energy" || tmpInt == 5) { mType->race = RACE_ENERGY; } else { std::cout << "[Warning - Monsters::loadMonster] Unknown race type " << attr.as_string() << ". " << file << std::endl; } } if ((attr = monsterNode.attribute("experience"))) { mType->experience = pugi::cast<uint64_t>(attr.value()); } if ((attr = monsterNode.attribute("speed"))) { mType->baseSpeed = pugi::cast<int32_t>(attr.value()); } if ((attr = monsterNode.attribute("manacost"))) { mType->manaCost = pugi::cast<uint32_t>(attr.value()); } if ((attr = monsterNode.attribute("script"))) { monsterScriptList[mType] = attr.as_string(); } pugi::xml_node node; if ((node = monsterNode.child("health"))) { if ((attr = node.attribute("now"))) { mType->health = pugi::cast<int32_t>(attr.value()); } else { std::cout << "[Error - Monsters::loadMonster] Missing health now. " << file << std::endl; } if ((attr = node.attribute("max"))) { mType->healthMax = pugi::cast<int32_t>(attr.value()); } else { std::cout << "[Error - Monsters::loadMonster] Missing health max. " << file << std::endl; } } if ((node = monsterNode.child("flags"))) { for (pugi::xml_node flagNode = node.first_child(); flagNode; flagNode = flagNode.next_sibling()) { attr = flagNode.first_attribute(); const char* attrName = attr.name(); if (strcasecmp(attrName, "summonable") == 0) { mType->isSummonable = attr.as_bool(); } else if (strcasecmp(attrName, "attackable") == 0) { mType->isAttackable = attr.as_bool(); } else if (strcasecmp(attrName, "hostile") == 0) { mType->isHostile = attr.as_bool(); } else if (strcasecmp(attrName, "illusionable") == 0) { mType->isIllusionable = attr.as_bool(); } else if (strcasecmp(attrName, "convinceable") == 0) { mType->isConvinceable = attr.as_bool(); } else if (strcasecmp(attrName, "pushable") == 0) { mType->pushable = attr.as_bool(); } else if (strcasecmp(attrName, "canpushitems") == 0) { mType->canPushItems = attr.as_bool(); } else if (strcasecmp(attrName, "canpushcreatures") == 0) { mType->canPushCreatures = attr.as_bool(); } else if (strcasecmp(attrName, "staticattack") == 0) { uint32_t staticAttack = pugi::cast<uint32_t>(attr.value()); if (staticAttack > 100) { std::cout << "[Warning - Monsters::loadMonster] staticattack greater than 100. " << file << std::endl; staticAttack = 100; } mType->staticAttackChance = staticAttack; } else if (strcasecmp(attrName, "lightlevel") == 0) { mType->lightLevel = pugi::cast<int32_t>(attr.value()); } else if (strcasecmp(attrName, "lightcolor") == 0) { mType->lightColor = pugi::cast<int32_t>(attr.value()); } else if (strcasecmp(attrName, "targetdistance") == 0) { mType->targetDistance = std::max<int32_t>(1, pugi::cast<int32_t>(attr.value())); } else if (strcasecmp(attrName, "runonhealth") == 0) { mType->runAwayHealth = pugi::cast<int32_t>(attr.value()); } else if (strcasecmp(attrName, "hidehealth") == 0) { mType->hiddenHealth = attr.as_bool(); } else { std::cout << "[Warning - Monsters::loadMonster] Unknown flag attribute: " << attrName << ". " << file << std::endl; } } //if a monster can push creatures, // it should not be pushable if (mType->canPushCreatures && mType->pushable) { mType->pushable = false; } } if ((node = monsterNode.child("targetchange"))) { if ((attr = node.attribute("speed")) || (attr = node.attribute("interval"))) { mType->changeTargetSpeed = std::max<int32_t>(1, pugi::cast<int32_t>(attr.value())); } else { std::cout << "[Warning - Monsters::loadMonster] Missing targetchange speed. " << file << std::endl; } if ((attr = node.attribute("chance"))) { mType->changeTargetChance = pugi::cast<int32_t>(attr.value()); } else { std::cout << "[Warning - Monsters::loadMonster] Missing targetchange chance. " << file << std::endl; } } if ((node = monsterNode.child("look"))) { if ((attr = node.attribute("type"))) { mType->outfit.lookType = pugi::cast<uint16_t>(attr.value()); if ((attr = node.attribute("head"))) { mType->outfit.lookHead = pugi::cast<uint16_t>(attr.value()); } if ((attr = node.attribute("body"))) { mType->outfit.lookBody = pugi::cast<uint16_t>(attr.value()); } if ((attr = node.attribute("legs"))) { mType->outfit.lookLegs = pugi::cast<uint16_t>(attr.value()); } if ((attr = node.attribute("feet"))) { mType->outfit.lookFeet = pugi::cast<uint16_t>(attr.value()); } if ((attr = node.attribute("addons"))) { mType->outfit.lookAddons = pugi::cast<uint16_t>(attr.value()); } } else if ((attr = node.attribute("typeex"))) { mType->outfit.lookTypeEx = pugi::cast<uint16_t>(attr.value()); } else { std::cout << "[Warning - Monsters::loadMonster] Missing look type/typeex. " << file << std::endl; } if ((attr = node.attribute("mount"))) { mType->outfit.lookMount = pugi::cast<uint16_t>(attr.value()); } if ((attr = node.attribute("corpse"))) { mType->lookcorpse = pugi::cast<uint16_t>(attr.value()); } } if ((node = monsterNode.child("attacks"))) { for (pugi::xml_node attackNode = node.first_child(); attackNode; attackNode = attackNode.next_sibling()) { spellBlock_t sb; if (deserializeSpell(attackNode, sb, monster_name)) { mType->spellAttackList.push_back(sb); } else { std::cout << "[Warning - Monsters::loadMonster] Cant load spell. " << file << std::endl; } } } if ((node = monsterNode.child("defenses"))) { if ((attr = node.attribute("defense"))) { mType->defense = pugi::cast<int32_t>(attr.value()); } if ((attr = node.attribute("armor"))) { mType->armor = pugi::cast<int32_t>(attr.value()); } for (pugi::xml_node defenseNode = node.first_child(); defenseNode; defenseNode = defenseNode.next_sibling()) { spellBlock_t sb; if (deserializeSpell(defenseNode, sb, monster_name)) { mType->spellDefenseList.push_back(sb); } else { std::cout << "[Warning - Monsters::loadMonster] Cant load spell. " << file << std::endl; } } } if ((node = monsterNode.child("immunities"))) { for (pugi::xml_node immunityNode = node.first_child(); immunityNode; immunityNode = immunityNode.next_sibling()) { if ((attr = immunityNode.attribute("name"))) { std::string tmpStrValue = asLowerCaseString(attr.as_string()); if (tmpStrValue == "physical") { mType->damageImmunities |= COMBAT_PHYSICALDAMAGE; mType->conditionImmunities |= CONDITION_BLEEDING; } else if (tmpStrValue == "energy") { mType->damageImmunities |= COMBAT_ENERGYDAMAGE; mType->conditionImmunities |= CONDITION_ENERGY; } else if (tmpStrValue == "fire") { mType->damageImmunities |= COMBAT_FIREDAMAGE; mType->conditionImmunities |= CONDITION_FIRE; } else if (tmpStrValue == "poison" || tmpStrValue == "earth") { mType->damageImmunities |= COMBAT_EARTHDAMAGE; mType->conditionImmunities |= CONDITION_POISON; } else if (tmpStrValue == "drown") { mType->damageImmunities |= COMBAT_DROWNDAMAGE; mType->conditionImmunities |= CONDITION_DROWN; } else if (tmpStrValue == "ice") { mType->damageImmunities |= COMBAT_ICEDAMAGE; mType->conditionImmunities |= CONDITION_FREEZING; } else if (tmpStrValue == "holy") { mType->damageImmunities |= COMBAT_HOLYDAMAGE; mType->conditionImmunities |= CONDITION_DAZZLED; } else if (tmpStrValue == "death") { mType->damageImmunities |= COMBAT_DEATHDAMAGE; mType->conditionImmunities |= CONDITION_CURSED; } else if (tmpStrValue == "lifedrain") { mType->damageImmunities |= COMBAT_LIFEDRAIN; } else if (tmpStrValue == "manadrain") { mType->damageImmunities |= COMBAT_MANADRAIN; } else if (tmpStrValue == "paralyze") { mType->conditionImmunities |= CONDITION_PARALYZE; } else if (tmpStrValue == "outfit") { mType->conditionImmunities |= CONDITION_OUTFIT; } else if (tmpStrValue == "drunk") { mType->conditionImmunities |= CONDITION_DRUNK; } else if (tmpStrValue == "invisible" || tmpStrValue == "invisibility") { mType->conditionImmunities |= CONDITION_INVISIBLE; } else if (tmpStrValue == "bleed") { mType->conditionImmunities |= CONDITION_BLEEDING; } else { std::cout << "[Warning - Monsters::loadMonster] Unknown immunity name " << attr.as_string() << ". " << file << std::endl; } } else if ((attr = immunityNode.attribute("physical"))) { if (attr.as_bool()) { mType->damageImmunities |= COMBAT_PHYSICALDAMAGE; mType->conditionImmunities |= CONDITION_BLEEDING; } } else if ((attr = immunityNode.attribute("energy"))) { if (attr.as_bool()) { mType->damageImmunities |= COMBAT_ENERGYDAMAGE; mType->conditionImmunities |= CONDITION_ENERGY; } } else if ((attr = immunityNode.attribute("fire"))) { if (attr.as_bool()) { mType->damageImmunities |= COMBAT_FIREDAMAGE; mType->conditionImmunities |= CONDITION_FIRE; } } else if ((attr = immunityNode.attribute("poison")) || (attr = immunityNode.attribute("earth"))) { if (attr.as_bool()) { mType->damageImmunities |= COMBAT_EARTHDAMAGE; mType->conditionImmunities |= CONDITION_POISON; } } else if ((attr = immunityNode.attribute("drown"))) { if (attr.as_bool()) { mType->damageImmunities |= COMBAT_DROWNDAMAGE; mType->conditionImmunities |= CONDITION_DROWN; } } else if ((attr = immunityNode.attribute("ice"))) { if (attr.as_bool()) { mType->damageImmunities |= COMBAT_ICEDAMAGE; mType->conditionImmunities |= CONDITION_FREEZING; } } else if ((attr = immunityNode.attribute("holy"))) { if (attr.as_bool()) { mType->damageImmunities |= COMBAT_HOLYDAMAGE; mType->conditionImmunities |= CONDITION_DAZZLED; } } else if ((attr = immunityNode.attribute("death"))) { if (attr.as_bool()) { mType->damageImmunities |= COMBAT_DEATHDAMAGE; mType->conditionImmunities |= CONDITION_CURSED; } } else if ((attr = immunityNode.attribute("lifedrain"))) { if (attr.as_bool()) { mType->damageImmunities |= COMBAT_LIFEDRAIN; } } else if ((attr = immunityNode.attribute("manadrain"))) { if (attr.as_bool()) { mType->damageImmunities |= COMBAT_MANADRAIN; } } else if ((attr = immunityNode.attribute("paralyze"))) { if (attr.as_bool()) { mType->conditionImmunities |= CONDITION_PARALYZE; } } else if ((attr = immunityNode.attribute("outfit"))) { if (attr.as_bool()) { mType->conditionImmunities |= CONDITION_OUTFIT; } } else if ((attr = immunityNode.attribute("bleed"))) { if (attr.as_bool()) { mType->conditionImmunities |= CONDITION_BLEEDING; } } else if ((attr = immunityNode.attribute("drunk"))) { if (attr.as_bool()) { mType->conditionImmunities |= CONDITION_DRUNK; } } else if ((attr = immunityNode.attribute("invisible")) || (attr = immunityNode.attribute("invisibility"))) { if (attr.as_bool()) { mType->conditionImmunities |= CONDITION_INVISIBLE; } } else { std::cout << "[Warning - Monsters::loadMonster] Unknown immunity. " << file << std::endl; } } } if ((node = monsterNode.child("voices"))) { if ((attr = node.attribute("speed")) || (attr = node.attribute("interval"))) { mType->yellSpeedTicks = pugi::cast<uint32_t>(attr.value()); } else { std::cout << "[Warning - Monsters::loadMonster] Missing voices speed. " << file << std::endl; } if ((attr = node.attribute("chance"))) { mType->yellChance = pugi::cast<uint32_t>(attr.value()); } else { std::cout << "[Warning - Monsters::loadMonster] Missing voices chance. " << file << std::endl; } for (pugi::xml_node voiceNode = node.first_child(); voiceNode; voiceNode = voiceNode.next_sibling()) { voiceBlock_t vb; if ((attr = voiceNode.attribute("sentence"))) { vb.text = attr.as_string(); } else { std::cout << "[Warning - Monsters::loadMonster] Missing voice sentence. " << file << std::endl; } if ((attr = voiceNode.attribute("yell"))) { vb.yellText = attr.as_bool(); } else { vb.yellText = false; } mType->voiceVector.push_back(vb); } } if ((node = monsterNode.child("loot"))) { for (pugi::xml_node lootNode = node.first_child(); lootNode; lootNode = lootNode.next_sibling()) { LootBlock lootBlock; if (loadLootItem(lootNode, lootBlock)) { mType->lootItems.push_back(lootBlock); } else { std::cout << "[Warning - Monsters::loadMonster] Cant load loot. " << file << std::endl; } } } if ((node = monsterNode.child("elements"))) { for (pugi::xml_node elementNode = node.first_child(); elementNode; elementNode = elementNode.next_sibling()) { if ((attr = elementNode.attribute("physicalPercent"))) { mType->elementMap[COMBAT_PHYSICALDAMAGE] = pugi::cast<int32_t>(attr.value()); } else if ((attr = elementNode.attribute("icePercent"))) { mType->elementMap[COMBAT_ICEDAMAGE] = pugi::cast<int32_t>(attr.value()); } else if ((attr = elementNode.attribute("poisonPercent")) || (attr = elementNode.attribute("earthPercent"))) { mType->elementMap[COMBAT_EARTHDAMAGE] = pugi::cast<int32_t>(attr.value()); } else if ((attr = elementNode.attribute("firePercent"))) { mType->elementMap[COMBAT_FIREDAMAGE] = pugi::cast<int32_t>(attr.value()); } else if ((attr = elementNode.attribute("energyPercent"))) { mType->elementMap[COMBAT_ENERGYDAMAGE] = pugi::cast<int32_t>(attr.value()); } else if ((attr = elementNode.attribute("holyPercent"))) { mType->elementMap[COMBAT_HOLYDAMAGE] = pugi::cast<int32_t>(attr.value()); } else if ((attr = elementNode.attribute("deathPercent"))) { mType->elementMap[COMBAT_DEATHDAMAGE] = pugi::cast<int32_t>(attr.value()); } else if ((attr = elementNode.attribute("drownPercent"))) { mType->elementMap[COMBAT_DROWNDAMAGE] = pugi::cast<int32_t>(attr.value()); } else if ((attr = elementNode.attribute("lifedrainPercent"))) { mType->elementMap[COMBAT_LIFEDRAIN] = pugi::cast<int32_t>(attr.value()); } else if ((attr = elementNode.attribute("manadrainPercent"))) { mType->elementMap[COMBAT_MANADRAIN] = pugi::cast<int32_t>(attr.value()); } else { std::cout << "[Warning - Monsters::loadMonster] Unknown element percent. " << file << std::endl; } } } if ((node = monsterNode.child("summons"))) { if ((attr = node.attribute("maxSummons"))) { mType->maxSummons = std::min<uint32_t>(pugi::cast<uint32_t>(attr.value()), 100); } else { std::cout << "[Warning - Monsters::loadMonster] Missing summons maxSummons. " << file << std::endl; } for (pugi::xml_node summonNode = node.first_child(); summonNode; summonNode = summonNode.next_sibling()) { int32_t chance = 100; int32_t speed = 1000; if ((attr = summonNode.attribute("speed")) || (attr = summonNode.attribute("interval"))) { speed = pugi::cast<int32_t>(attr.value()); } if ((attr = summonNode.attribute("chance"))) { chance = pugi::cast<int32_t>(attr.value()); } if ((attr = summonNode.attribute("name"))) { summonBlock_t sb; sb.name = attr.as_string(); sb.speed = speed; sb.chance = chance; mType->summonList.push_back(sb); } else { std::cout << "[Warning - Monsters::loadMonster] Missing summon name. " << file << std::endl; } } } if ((node = monsterNode.child("script"))) { for (pugi::xml_node eventNode = node.first_child(); eventNode; eventNode = eventNode.next_sibling()) { if ((attr = eventNode.attribute("name"))) { mType->scriptList.push_back(attr.as_string()); } else { std::cout << "[Warning - Monsters::loadMonster] Missing name for script event. " << file << std::endl; } } } static uint32_t id = 0; if (new_mType) { std::string lowername = monster_name; toLowerCaseString(lowername); monsterNames[lowername] = ++id; monsters[id] = mType; } return true; }
void VcfMaterializer::_appendToVariants(Variants & variants, seqan::VcfRecord const & vcfRecord) { // Compute maximal length of alternative. unsigned altLength = 0; seqan::StringSet<seqan::CharString> alts; strSplit(alts, vcfRecord.alt, seqan::EqualsChar<','>()); for (unsigned i = 0; i < length(alts); ++i) altLength = std::max(altLength, (unsigned)length(alts[i])); if (contains(vcfRecord.info, "SVTYPE")) // Structural Variant { StructuralVariantRecord svRecord; svRecord.rId = vcfRecord.rID; svRecord.pos = vcfRecord.beginPos + 1; // given with shift of -1 svRecord.haplotype = 0; SEQAN_ASSERT_EQ(length(alts), 1u); if (contains(vcfRecord.info, "SVTYPE=INS")) // Insertion { svRecord.kind = StructuralVariantRecord::INDEL; svRecord.size = getSVLen(vcfRecord.info); svRecord.seq = suffix(vcfRecord.alt, 1); } else if (contains(vcfRecord.info, "SVTYPE=DEL")) // Deletion { svRecord.kind = StructuralVariantRecord::INDEL; svRecord.size = getSVLen(vcfRecord.info); } else if (contains(vcfRecord.info, "SVTYPE=INV")) // Inversion { svRecord.kind = StructuralVariantRecord::INVERSION; svRecord.size = getSVLen(vcfRecord.info); } else if (contains(vcfRecord.info, "SVTYPE=DUP")) // Duplication { svRecord.kind = StructuralVariantRecord::DUPLICATION; svRecord.size = getSVLen(vcfRecord.info); std::pair<seqan::CharString, int> pos = getTargetPos(vcfRecord.info); unsigned idx = 0; if (!getIdByName(idx, contigNamesCache(context(vcfFileIn)), pos.first)) SEQAN_FAIL("Unknown sequence %s", toCString(pos.first)); svRecord.targetRId = idx; svRecord.targetPos = pos.second - 1; } else if (contains(vcfRecord.info, "SVTYPE=BND")) // Breakend (Must be Translocation) { SEQAN_FAIL("Unexpected 'SVTYPE=BND' at this place!"); } else { SEQAN_FAIL("ERROR: Unknown SVTYPE!\n"); } // Split the target variants. SEQAN_ASSERT_NOT(empty(vcfRecord.genotypeInfos)); seqan::DirectionIterator<seqan::CharString const, seqan::Input>::Type inputIter = directionIterator(vcfRecord.genotypeInfos[0], seqan::Input()); seqan::CharString buffer; svRecord.haplotype = 0; for (; !atEnd(inputIter); ++inputIter) if ((*inputIter == '|' || *inputIter == '/')) { if (!empty(buffer)) { unsigned idx = std::min(seqan::lexicalCast<unsigned>(buffer), 1u); if (idx != 0u) // if not == ref appendValue(variants.svRecords, svRecord); } svRecord.haplotype++; clear(buffer); } else { appendValue(buffer, *inputIter); } if (!empty(buffer)) { unsigned idx = std::min(seqan::lexicalCast<unsigned>(buffer), 1u); if (idx != 0u) // if not == ref appendValue(variants.svRecords, svRecord); } } else if (length(vcfRecord.ref) == 1u && altLength == 1u) // SNP { SnpRecord snpRecord; snpRecord.rId = vcfRecord.rID; snpRecord.pos = vcfRecord.beginPos; // Split the alternatives. seqan::StringSet<seqan::CharString> alternatives; strSplit(alternatives, vcfRecord.alt, seqan::EqualsChar<','>()); // Split the target variants. SEQAN_ASSERT_NOT(empty(vcfRecord.genotypeInfos)); seqan::DirectionIterator<seqan::CharString const, seqan::Input>::Type inputIter = directionIterator(vcfRecord.genotypeInfos[0], seqan::Input()); seqan::CharString buffer; snpRecord.haplotype = 0; for (; !atEnd(inputIter); ++inputIter) if ((*inputIter == '|' || *inputIter == '/')) { if (!empty(buffer)) { unsigned idx = std::min(seqan::lexicalCast<unsigned>(buffer), (unsigned)length(alternatives)); if (idx != 0u) // if not == ref { SEQAN_ASSERT_NOT(empty(alternatives[idx - 1])); snpRecord.to = alternatives[idx - 1][0]; appendValue(variants.snps, snpRecord); } } snpRecord.haplotype++; clear(buffer); } else { appendValue(buffer, *inputIter); } if (!empty(buffer)) { unsigned idx = std::min(seqan::lexicalCast<unsigned>(buffer), (unsigned)length(alternatives)); if (idx != 0u) // if not == ref { SEQAN_ASSERT_NOT(empty(alternatives[idx - 1])); snpRecord.to = alternatives[idx - 1][0]; appendValue(variants.snps, snpRecord); } } } else // Small Indel { SmallIndelRecord smallIndel; smallIndel.rId = vcfRecord.rID; smallIndel.pos = vcfRecord.beginPos + 1; SEQAN_ASSERT_NOT(contains(vcfRecord.alt, ",")); // only one alternative SEQAN_ASSERT((length(vcfRecord.alt) == 1u) != (length(vcfRecord.ref) == 1u)); // XOR smallIndel.haplotype = 0; if (length(vcfRecord.ref) == 1u) // insertion { smallIndel.seq = suffix(vcfRecord.alt, 1); smallIndel.size = length(smallIndel.seq); } else // deletion { smallIndel.size = -(int)(length(vcfRecord.ref) - 1); } // Split the target variants. SEQAN_ASSERT_NOT(empty(vcfRecord.genotypeInfos)); seqan::DirectionIterator<seqan::CharString const, seqan::Input>::Type inputIter = directionIterator(vcfRecord.genotypeInfos[0], seqan::Input()); seqan::CharString buffer; smallIndel.haplotype = 0; for (; !atEnd(inputIter); ++inputIter) if ((*inputIter == '|' || *inputIter == '/')) { if (!empty(buffer)) { unsigned idx = std::min(seqan::lexicalCast<unsigned>(buffer), 1u); if (idx != 0u) // if not == ref appendValue(variants.smallIndels, smallIndel); } smallIndel.haplotype++; clear(buffer); } else { appendValue(buffer, *inputIter); } if (!empty(buffer)) { unsigned idx = std::min(seqan::lexicalCast<unsigned>(buffer), 1u); if (idx != 0u) // if not == ref appendValue(variants.smallIndels, smallIndel); } } }
int run() { // Intialization std::cerr << "__INITIALIZATION_____________________________________________________________\n" << "\n"; std::cerr << "Opening files..."; try { vcfMat.init(); if (!open(seqFileOut, toCString(options.outputFileName))) throw MasonIOException("Could not open output file."); if (!open(gffFileIn, toCString(options.inputGffFile))) throw MasonIOException("Could not open GFF/GTF file."); } catch (MasonIOException e) { std::cerr << "\nERROR: " << e.what() << "\n"; return 1; } std::cerr << " OK\n"; // Perform genome simulation. std::cerr << "\n__COMPUTING TRANSCRIPTS______________________________________________________\n" << "\n"; // Read first GFF record. MyGffRecord record; _readFirstRecord(record); if (record.rID == seqan::maxValue<int>()) return 0; // at end, could not read any, done // Transcript names. typedef seqan::StringSet<seqan::CharString> TNameStore; typedef seqan::NameStoreCache<TNameStore> TNameStoreCache; TNameStore transcriptNames; TNameStoreCache transcriptNamesCache(transcriptNames); // The splicing instructions for the current contig. std::vector<SplicingInstruction> splicingInstructions; // Materialized sequence. seqan::Dna5String seq; // Tanscript ids, used as a buffer below. seqan::String<unsigned> transcriptIDs; // Read GFF/GTF file contig by contig (must be sorted by reference name). For each contig, we all recors, // create simulation instructions and then build the transcripts for each haplotype. while (record.rID != seqan::maxValue<int>()) // sentinel, at end { seqan::CharString refName = record.ref; std::cerr << "Splicing for " << refName << " ..."; // Read GFF records for this contig. MyGffRecord firstGffRecord = record; while (record.rID == firstGffRecord.rID) { if (empty(options.gffType) || (record.type == options.gffType)) { // Make transcript names known to the record. _appendTranscriptNames(transcriptIDs, transcriptNames, transcriptNamesCache, record); // Add the splicing instructions for this record to the list for this contig. for (unsigned i = 0; i < length(transcriptIDs); ++i) splicingInstructions.push_back(SplicingInstruction(transcriptIDs[i], record.beginPos, record.endPos, record.strand)); } if (atEnd(gffFileIn)) { record.rID = seqan::maxValue<int>(); break; } readRecord(record, gffFileIn); // Translate ref to idx from VCF. unsigned idx = 0; if (!getIdByName(idx, vcfMat.faiIndex, record.ref)) throw MasonIOException("Reference name from GFF/GTF not in VCF!"); record.rID = idx; } // --------------------------------------------------------------- // Process the splicing instructions. // --------------------------------------------------------------- // First, sort them. std::sort(splicingInstructions.begin(), splicingInstructions.end()); // Materialize all haplotypes of this contig int rID = 0, hID = 0; // reference and haplotype id // Get index of the gff record's reference in the VCF file. unsigned idx = 0; if (!getIdByName(idx, vcfMat.faiIndex, refName)) { std::stringstream ss; ss << "Reference from GFF file " << refName << " unknown in FASTA/FAI file."; throw MasonIOException(ss.str()); } rID = idx; vcfMat.currRID = rID - 1; std::vector<SmallVarInfo> varInfos; // small variants for counting in read alignments std::vector<std::pair<int, int> > breakpoints; // unused/ignored while (vcfMat.materializeNext(seq, varInfos, breakpoints, rID, hID)) { std::cerr << " (allele " << (hID + 1) << ")"; if (rID != (int)idx) break; // no more haplotypes for this reference _performSplicing(splicingInstructions, seq, transcriptNames, hID, vcfMat); } std::cerr << " DONE.\n"; // --------------------------------------------------------------- // Handle contig switching. // --------------------------------------------------------------- // Check that the input GFF file is clustered (weaker than sorted) by reference name. if (record.rID < firstGffRecord.rID) throw MasonIOException("GFF file not sorted or clustered by reference."); // Reset transcript names and cache. clear(transcriptNames); refresh(transcriptNamesCache); // Flush splicing instructions. splicingInstructions.clear(); } std::cerr << "\nDone splicing FASTA.\n"; return 0; }