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