TDDOS::TDDOS()
{
MaxThreads = 10;
AttemptsPerSecond = 10;
FThreadsCount = 0;
FUserAgentsCount = 0;
FTerminated = false;
GetRandomString(UserAgents, FUserAgentsCount);
GetRandomString(Domains, FDomainsCount);
}
void adminSpawnRune(edict_t *self, int type, int index)
{
gitem_t *item;
edict_t *rune;
item = FindItem("Rune"); // get the item properties
rune = Drop_Item(self, item); // create the entity that holds those properties
V_ItemClear(&rune->vrxitem); // initialize the rune
rune->vrxitem.quantity = 1;
switch(type)
{
case ITEM_WEAPON: spawnNorm(rune, index, ITEM_WEAPON); return;
case ITEM_ABILITY: spawnNorm(rune, index, ITEM_ABILITY); return;
case ITEM_COMBO: spawnCombo(rune, index); return;
case ITEM_CLASSRUNE: spawnClassRune(rune, index); return;
//Try to spawn a unique (or a random one if it fails to find one at the index)
case ITEM_UNIQUE: if (!spawnUnique(rune, index)) spawnNorm(rune, index, 0); return;
}
//Randomize id
strcpy(rune->vrxitem.id, GetRandomString(16));
//Free the ent (if no rune was spawned)
G_FreeEdict(rune);
}
void MediaStreamTrack::Init(webrtc::MediaStreamTrackInterface & inner_track, bool remote) {
inner_track_ = rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>(&inner_track);
change_emitter_ = std::make_shared<decltype(change_emitter_)::element_type>();
inner_observer_ = std::make_shared<ChangeObserver>(*this);
inner_track_->RegisterObserver(inner_observer_.get());
id_ = GetRandomString(20);
enabled_ = inner_track_->enabled();
remote_ = remote;
ready_state_ = ComputeState(inner_track_->state());
}
CommandDrawHeightmap::CommandDrawHeightmap()
: Command(COMMAND_UNDO_REDO)
{
redoFilename = "";
LandscapeEditorHeightmap* editor = GetEditor();
if (editor)
{
Heightmap* heightmap;
editor->GetHeightmap(&heightmap);
undoFilename = SaveHeightmap(heightmap, "_" + GetRandomString(10));
}
}
void CommandDrawHeightmap::Execute()
{
LandscapeEditorHeightmap* editor = GetEditor();
if (editor == NULL)
{
SetState(STATE_INVALID);
return;
}
Heightmap* heightmap;
editor->GetHeightmap(&heightmap);
if (redoFilename == "")
{
redoFilename = SaveHeightmap(heightmap, "_" + GetRandomString(10));
}
else
{
heightmap->Load(redoFilename);
editor->UpdateHeightmap(heightmap);
}
}
/*!
* \brief SetPasswordDialog::on_buttonBox_accepted Handles submission of the dialog.
* Checks if the old password field matches the previously set password.
* Checks that the new password matches its confirmation.
* Salts and hashes the new password, then stores it in the settings.
*/
void SetPasswordDialog::on_buttonBox_accepted()
{
QSettings settings("settings.ini", QSettings::IniFormat);
//qDebug(settings.fileName().toLocal8Bit());
//Check if old password exists
if(settings.contains("password")){
//Check if old password matches
QString oldpw = settings.value("password", "").toString();
if(!passwordMatches(ui->lineEdit_oldPassword->text())){
return;
}
//old password correct
}
//Check if new password matches confirm password and set new password
if(QString::compare(ui->lineEdit_newPassword->text(), ui->lineEdit_confirmPassword->text()) == 0){
QString salt = GetRandomString();
QString pwHashed = QString(QCryptographicHash::hash(((ui->lineEdit_newPassword->text()+salt).toUtf8()),QCryptographicHash::Sha512).toHex());
settings.setValue("password", pwHashed);
settings.setValue("salt", salt);
}
}
void EncodeString( uchar *str )
{
uchar psw[80];
uchar code1[PRIMARY_CODE+1];
uchar code2[SECONDARY_CODE+1];
if ( !*str ) return;
srand(GetTickCount());
lstrcpy( (char*)psw, (char*)str );
GetRandomString( code1 , PRIMARY_CODE );
str[0] = 255;
str[1] = 0;
lstrcat( (char*)str, (char*)code1 );
XORstr( psw, code1, PRIMARY_CODE );
lstrcat( (char*)str, (char*)psw );
GetFixedCodeString( code2 , SECONDARY_CODE );
XORstr( str+1, code2, SECONDARY_CODE );
}
int main (int argc, char *argv[]) {
if(argc <= 1) {
cerr << "usage: " << endl << argv[0] << " <file.osm/.osm.bz2/.osm.pbf>" << endl;
exit(-1);
}
cout << "[extractor] extracting data from input file " << argv[1] << endl;
bool isPBF = false;
string outputFileName(argv[1]);
string restrictionsFileName(argv[1]);
string::size_type pos = outputFileName.find(".osm.bz2");
if(pos==string::npos) {
pos = outputFileName.find(".osm.pbf");
if(pos!=string::npos) {
isPBF = true;
}
}
if(pos!=string::npos) {
outputFileName.replace(pos, 8, ".osrm");
restrictionsFileName.replace(pos, 8, ".osrm.restrictions");
} else {
pos=outputFileName.find(".osm");
if(pos!=string::npos) {
outputFileName.replace(pos, 5, ".osrm");
restrictionsFileName.replace(pos, 5, ".osrm.restrictions");
} else {
outputFileName.append(".osrm");
restrictionsFileName.append(".osrm.restrictions");
}
}
string adressFileName(outputFileName);
unsigned amountOfRAM = 1;
unsigned installedRAM = GetPhysicalmemory();
if(installedRAM < 2048264) {
cout << "[Warning] Machine has less than 2GB RAM." << endl;
}
if(testDataFile("extractor.ini")) {
ExtractorConfiguration extractorConfig("extractor.ini");
unsigned memoryAmountFromFile = atoi(extractorConfig.GetParameter("Memory").c_str());
if( memoryAmountFromFile != 0 && memoryAmountFromFile <= installedRAM/(1024*1024*1024))
amountOfRAM = memoryAmountFromFile;
cout << "[extractor] using " << amountOfRAM << " GB of RAM for buffers" << endl;
}
STXXLContainers externalMemory;
unsigned usedNodeCounter = 0;
unsigned usedEdgeCounter = 0;
StringMap * stringMap = new StringMap();
Settings settings;
settings.speedProfile.names.insert(settings.speedProfile.names.begin(), names, names+14);
settings.speedProfile.speed.insert(settings.speedProfile.speed.begin(), speeds, speeds+14);
double time = get_timestamp();
stringMap->set_empty_key(GetRandomString());
stringMap->insert(make_pair("", 0));
extractCallBacks = new ExtractorCallbacks(&externalMemory, settings, stringMap);
BaseParser<_Node, _RawRestrictionContainer, _Way> * parser;
if(isPBF) {
parser = new PBFParser(argv[1]);
} else {
parser = new XMLParser(argv[1]);
}
parser->RegisterCallbacks(&nodeFunction, &restrictionFunction, &wayFunction, &adressFunction);
if(parser->Init()) {
parser->Parse();
} else {
cerr << "[error] parser not initialized!" << endl;
exit(-1);
}
delete parser;
try {
// INFO("raw no. of names: " << externalMemory.nameVector.size());
// INFO("raw no. of nodes: " << externalMemory.allNodes.size());
// INFO("no. of used nodes: " << externalMemory.usedNodeIDs.size());
// INFO("raw no. of edges: " << externalMemory.allEdges.size());
// INFO("raw no. of ways: " << externalMemory.wayStartEndVector.size());
// INFO("raw no. of addresses: " << externalMemory.adressVector.size());
// INFO("raw no. of restrictions: " << externalMemory.restrictionsVector.size());
cout << "[extractor] parsing finished after " << get_timestamp() - time << "seconds" << endl;
time = get_timestamp();
uint64_t memory_to_use = static_cast<uint64_t>(amountOfRAM) * 1024 * 1024 * 1024;
cout << "[extractor] Sorting used nodes ... " << flush;
stxxl::sort(externalMemory.usedNodeIDs.begin(), externalMemory.usedNodeIDs.end(), Cmp(), memory_to_use);
cout << "ok, after " << get_timestamp() - time << "s" << endl;
time = get_timestamp();
cout << "[extractor] Erasing duplicate nodes ... " << flush;
stxxl::vector<NodeID>::iterator NewEnd = unique ( externalMemory.usedNodeIDs.begin(),externalMemory.usedNodeIDs.end() ) ;
externalMemory.usedNodeIDs.resize ( NewEnd - externalMemory.usedNodeIDs.begin() );
cout << "ok, after " << get_timestamp() - time << "s" << endl;
time = get_timestamp();
cout << "[extractor] Sorting all nodes ... " << flush;
stxxl::sort(externalMemory.allNodes.begin(), externalMemory.allNodes.end(), CmpNodeByID(), memory_to_use);
cout << "ok, after " << get_timestamp() - time << "s" << endl;
time = get_timestamp();
cout << "[extractor] Sorting used ways ... " << flush;
stxxl::sort(externalMemory.wayStartEndVector.begin(), externalMemory.wayStartEndVector.end(), CmpWayStartAndEnd(), memory_to_use);
cout << "ok, after " << get_timestamp() - time << "s" << endl;
cout << "[extractor] Sorting restrctns. by from... " << flush;
stxxl::sort(externalMemory.restrictionsVector.begin(), externalMemory.restrictionsVector.end(), CmpRestrictionByFrom(), memory_to_use);
cout << "ok, after " << get_timestamp() - time << "s" << endl;
cout << "[extractor] Fixing restriction starts ... " << flush;
STXXLRestrictionsVector::iterator restrictionsIT = externalMemory.restrictionsVector.begin();
STXXLWayIDStartEndVector::iterator wayStartAndEndEdgeIT = externalMemory.wayStartEndVector.begin();
while(wayStartAndEndEdgeIT != externalMemory.wayStartEndVector.end() && restrictionsIT != externalMemory.restrictionsVector.end()) {
if(wayStartAndEndEdgeIT->wayID < restrictionsIT->fromWay){
wayStartAndEndEdgeIT++;
continue;
}
if(wayStartAndEndEdgeIT->wayID > restrictionsIT->fromWay) {
restrictionsIT++;
continue;
}
assert(wayStartAndEndEdgeIT->wayID == restrictionsIT->fromWay);
NodeID viaNode = restrictionsIT->restriction.viaNode;
if(wayStartAndEndEdgeIT->firstStart == viaNode) {
restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->firstTarget;
} else if(wayStartAndEndEdgeIT->firstTarget == viaNode) {
restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->firstStart;
} else if(wayStartAndEndEdgeIT->lastStart == viaNode) {
restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->lastTarget;
} else if(wayStartAndEndEdgeIT->lastTarget == viaNode) {
restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->lastStart;
}
restrictionsIT++;
}
cout << "ok, after " << get_timestamp() - time << "s" << endl;
time = get_timestamp();
cout << "[extractor] Sorting restrctns. by to ... " << flush;
stxxl::sort(externalMemory.restrictionsVector.begin(), externalMemory.restrictionsVector.end(), CmpRestrictionByTo(), memory_to_use);
cout << "ok, after " << get_timestamp() - time << "s" << endl;
time = get_timestamp();
unsigned usableRestrictionsCounter(0);
cout << "[extractor] Fixing restriction ends ... " << flush;
restrictionsIT = externalMemory.restrictionsVector.begin();
wayStartAndEndEdgeIT = externalMemory.wayStartEndVector.begin();
while(wayStartAndEndEdgeIT != externalMemory.wayStartEndVector.end() &&
restrictionsIT != externalMemory.restrictionsVector.end()) {
if(wayStartAndEndEdgeIT->wayID < restrictionsIT->toWay){
wayStartAndEndEdgeIT++;
continue;
}
if(wayStartAndEndEdgeIT->wayID > restrictionsIT->toWay) {
restrictionsIT++;
continue;
}
NodeID viaNode = restrictionsIT->restriction.viaNode;
if(wayStartAndEndEdgeIT->lastStart == viaNode) {
restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->lastTarget;
} else if(wayStartAndEndEdgeIT->lastTarget == viaNode) {
restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->lastStart;
} else if(wayStartAndEndEdgeIT->firstStart == viaNode) {
restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->firstTarget;
} else if(wayStartAndEndEdgeIT->firstTarget == viaNode) {
restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->firstStart;
}
if(UINT_MAX != restrictionsIT->restriction.fromNode && UINT_MAX != restrictionsIT->restriction.toNode) {
usableRestrictionsCounter++;
}
restrictionsIT++;
}
cout << "ok, after " << get_timestamp() - time << "s" << endl;
//serialize restrictions
ofstream restrictionsOutstream;
restrictionsOutstream.open(restrictionsFileName.c_str(), ios::binary);
restrictionsOutstream.write((char*)&usableRestrictionsCounter, sizeof(unsigned));
for(restrictionsIT = externalMemory.restrictionsVector.begin(); restrictionsIT != externalMemory.restrictionsVector.end(); restrictionsIT++) {
if(UINT_MAX != restrictionsIT->restriction.fromNode && UINT_MAX != restrictionsIT->restriction.toNode) {
restrictionsOutstream.write((char *)&(restrictionsIT->restriction), sizeof(_Restriction));
}
}
restrictionsOutstream.close();
ofstream fout;
fout.open(outputFileName.c_str(), ios::binary);
fout.write((char*)&usedNodeCounter, sizeof(unsigned));
time = get_timestamp();
cout << "[extractor] Confirming used nodes ... " << flush;
STXXLNodeVector::iterator nodesIT = externalMemory.allNodes.begin();
STXXLNodeIDVector::iterator usedNodeIDsIT = externalMemory.usedNodeIDs.begin();
while(usedNodeIDsIT != externalMemory.usedNodeIDs.end() && nodesIT != externalMemory.allNodes.end()) {
if(*usedNodeIDsIT < nodesIT->id){
usedNodeIDsIT++;
continue;
}
if(*usedNodeIDsIT > nodesIT->id) {
nodesIT++;
continue;
}
if(*usedNodeIDsIT == nodesIT->id) {
fout.write((char*)&(nodesIT->id), sizeof(unsigned));
fout.write((char*)&(nodesIT->lon), sizeof(int));
fout.write((char*)&(nodesIT->lat), sizeof(int));
usedNodeCounter++;
usedNodeIDsIT++;
nodesIT++;
}
}
cout << "ok, after " << get_timestamp() - time << "s" << endl;
time = get_timestamp();
cout << "[extractor] setting number of nodes ... " << flush;
ios::pos_type positionInFile = fout.tellp();
fout.seekp(ios::beg);
fout.write((char*)&usedNodeCounter, sizeof(unsigned));
fout.seekp(positionInFile);
cout << "ok" << endl;
time = get_timestamp();
// Sort edges by start.
cout << "[extractor] Sorting edges by start ... " << flush;
stxxl::sort(externalMemory.allEdges.begin(), externalMemory.allEdges.end(), CmpEdgeByStartID(), memory_to_use);
cout << "ok, after " << get_timestamp() - time << "s" << endl;
time = get_timestamp();
cout << "[extractor] Setting start coords ... " << flush;
fout.write((char*)&usedEdgeCounter, sizeof(unsigned));
// Traverse list of edges and nodes in parallel and set start coord
nodesIT = externalMemory.allNodes.begin();
STXXLEdgeVector::iterator edgeIT = externalMemory.allEdges.begin();
while(edgeIT != externalMemory.allEdges.end() && nodesIT != externalMemory.allNodes.end()) {
if(edgeIT->start < nodesIT->id){
edgeIT++;
continue;
}
if(edgeIT->start > nodesIT->id) {
nodesIT++;
continue;
}
if(edgeIT->start == nodesIT->id) {
edgeIT->startCoord.lat = nodesIT->lat;
edgeIT->startCoord.lon = nodesIT->lon;
edgeIT++;
}
}
cout << "ok, after " << get_timestamp() - time << "s" << endl;
time = get_timestamp();
// Sort Edges by target
cout << "[extractor] Sorting edges by target ... " << flush;
stxxl::sort(externalMemory.allEdges.begin(), externalMemory.allEdges.end(), CmpEdgeByTargetID(), memory_to_use);
cout << "ok, after " << get_timestamp() - time << "s" << endl;
time = get_timestamp();
cout << "[extractor] Setting target coords ... " << flush;
// Traverse list of edges and nodes in parallel and set target coord
nodesIT = externalMemory.allNodes.begin();
edgeIT = externalMemory.allEdges.begin();
while(edgeIT != externalMemory.allEdges.end() && nodesIT != externalMemory.allNodes.end()) {
if(edgeIT->target < nodesIT->id){
edgeIT++;
continue;
}
if(edgeIT->target > nodesIT->id) {
nodesIT++;
continue;
}
if(edgeIT->target == nodesIT->id) {
if(edgeIT->startCoord.lat != INT_MIN && edgeIT->startCoord.lon != INT_MIN) {
edgeIT->targetCoord.lat = nodesIT->lat;
edgeIT->targetCoord.lon = nodesIT->lon;
double distance = ApproximateDistance(edgeIT->startCoord.lat, edgeIT->startCoord.lon, nodesIT->lat, nodesIT->lon);
if(edgeIT->speed == -1)
edgeIT->speed = settings.speedProfile.speed[edgeIT->type];
double weight = ( distance * 10. ) / (edgeIT->speed / 3.6);
int intWeight = max(1, (int) weight);
int intDist = max(1, (int)distance);
int ferryIndex = settings.indexInAccessListOf("ferry");
assert(ferryIndex != -1);
short zero = 0;
short one = 1;
fout.write((char*)&edgeIT->start, sizeof(unsigned));
fout.write((char*)&edgeIT->target, sizeof(unsigned));
fout.write((char*)&intDist, sizeof(int));
switch(edgeIT->direction) {
case _Way::notSure:
fout.write((char*)&zero, sizeof(short));
break;
case _Way::oneway:
fout.write((char*)&one, sizeof(short));
break;
case _Way::bidirectional:
fout.write((char*)&zero, sizeof(short));
break;
case _Way::opposite:
fout.write((char*)&one, sizeof(short));
break;
default:
cerr << "[error] edge with no direction: " << edgeIT->direction << endl;
assert(false);
break;
}
fout.write((char*)&intWeight, sizeof(int));
short edgeType = edgeIT->type;
fout.write((char*)&edgeType, sizeof(short));
fout.write((char*)&edgeIT->nameID, sizeof(unsigned));
}
usedEdgeCounter++;
edgeIT++;
}
}
cout << "ok, after " << get_timestamp() - time << "s" << endl;
time = get_timestamp();
cout << "[extractor] setting number of edges ... " << flush;
fout.seekp(positionInFile);
fout.write((char*)&usedEdgeCounter, sizeof(unsigned));
fout.close();
cout << "ok" << endl;
time = get_timestamp();
cout << "[extractor] writing street name index ... " << flush;
vector<unsigned> * nameIndex = new vector<unsigned>(externalMemory.nameVector.size()+1, 0);
outputFileName.append(".names");
ofstream nameOutFile(outputFileName.c_str(), ios::binary);
unsigned sizeOfNameIndex = nameIndex->size();
nameOutFile.write((char *)&(sizeOfNameIndex), sizeof(unsigned));
for(STXXLStringVector::iterator it = externalMemory.nameVector.begin(); it != externalMemory.nameVector.end(); it++) {
unsigned lengthOfRawString = strlen(it->c_str());
nameOutFile.write((char *)&(lengthOfRawString), sizeof(unsigned));
nameOutFile.write(it->c_str(), lengthOfRawString);
}
nameOutFile.close();
delete nameIndex;
cout << "ok, after " << get_timestamp() - time << "s" << endl;
// time = get_timestamp();
// cout << "[extractor] writing address list ... " << flush;
//
// adressFileName.append(".address");
// ofstream addressOutFile(adressFileName.c_str());
// for(STXXLAddressVector::iterator it = adressVector.begin(); it != adressVector.end(); it++) {
// addressOutFile << it->node.id << "|" << it->node.lat << "|" << it->node.lon << "|" << it->city << "|" << it->street << "|" << it->housenumber << "|" << it->state << "|" << it->country << "\n";
// }
// addressOutFile.close();
// cout << "ok, after " << get_timestamp() - time << "s" << endl;
} catch ( const exception& e ) {
cerr << "Caught Execption:" << e.what() << endl;
return false;
}
delete extractCallBacks;
cout << "[extractor] finished." << endl;
return 0;
}
void SpawnRune (edict_t *self, edict_t *attacker, qboolean debug)
{
int iRandom;
int targ_level = 0;
float temp = 0;
gitem_t *item;
edict_t *rune;
attacker = G_GetClient(attacker);
if (!attacker)
return;
if(!self->client)
{
// is this a world monster?
if (self->mtype && (self->svflags & SVF_MONSTER) && self->activator && !self->activator->client)
{
if (IsABoss(self) || (self->mtype == M_COMMANDER))
//boss has a 100% chance to spawn a rune
temp = (float) (self->monsterinfo.level + 1) / (attacker->myskills.level + 1) * 100.0;
else if (self->monsterinfo.bonus_flags & BF_UNIQUE_LIGHTNING
|| self->monsterinfo.bonus_flags & BF_UNIQUE_FIRE)
// unique monsters have a 50% chance to spawn a rune
temp = (float) (self->monsterinfo.level + 1) / (attacker->myskills.level + 1) * 75.0;
else if (self->monsterinfo.bonus_flags & BF_CHAMPION)
// champion monsters have a 15% chance to spawn a rune
temp = (float) (self->monsterinfo.level + 1) / (attacker->myskills.level + 1) * 15.0; // from 2%
else
// monsters have a 5% chance to spawn a rune NOP MONSTERS DON'T DROP RUNES
//temp = (float) (self->monsterinfo.level + 1) / (attacker->myskills.level + 1) * 5.0; // from 0.2%
temp = 1; // 1% to drop runes.
//gi.dprintf("%.3f\n", temp*RUNE_SPAWN_BASE);
if (RUNE_SPAWN_BASE * temp < random())
return;
//set target level
targ_level = (self->monsterinfo.level + attacker->myskills.level) / 2;
// don't allow runes higher than attacker's level
if (targ_level > attacker->myskills.level)
targ_level = attacker->myskills.level;
}
else
return;
}
else if (attacker != self)
{
//boss has a greater chance of dropping a rune
if (attacker->myskills.boss > 0)
temp = (float)attacker->myskills.boss * 5;
else
temp = (float) (self->myskills.level + 1) * 5.0 / (attacker->myskills.level + 1);
// miniboss has greater chance of dropping a rune
if (IsNewbieBasher(self))
temp *= 2;
//boss has a greater chance of dropping a rune
temp *= 1.0 + ((float)self->myskills.boss / 2.0);
if (RUNE_SPAWN_BASE * temp < random())
return;
//set target level
targ_level = (self->myskills.level + attacker->myskills.level) / 2;
}
else if (debug == false)
return;
item = FindItem("Rune"); // get the item properties
rune = Drop_Item(self, item); // create the entity that holds those properties
V_ItemClear(&rune->vrxitem); // initialize the rune
//set target level to 20 if we are debugging
if (debug == true)
targ_level = 20;
rune->vrxitem.quantity = 1;
//Spawn a random rune
iRandom = GetRandom(0, 1000);
if (iRandom < CHANCE_UNIQUE)
{
//spawn a unique
#ifdef ENABLE_UNIQUES
if (!spawnUnique(rune, 0))
#endif
spawnNorm(rune, targ_level, 0);
}
else if (iRandom < CHANCE_UNIQUE + CHANCE_CLASS)
{
//spawn a class-specific rune
spawnClassRune(rune, targ_level);
}
else if (iRandom < CHANCE_UNIQUE + CHANCE_CLASS + CHANCE_COMBO)
{
//spawn a combo rune
spawnCombo(rune, targ_level);
}
else if (iRandom < CHANCE_UNIQUE + CHANCE_CLASS + CHANCE_COMBO + CHANCE_NORM)
{
//spawn a normal rune
spawnNorm(rune, targ_level, 0);
}
else
{
G_FreeEdict(rune);
return;
}
//Randomize id
strcpy(rune->vrxitem.id, GetRandomString(16));
}
edict_t *V_SpawnRune (edict_t *self, edict_t *attacker, float base_drop_chance, float levelmod)
{
int iRandom;
int targ_level;
float temp = 0;
gitem_t *item;
edict_t *rune;
attacker = G_GetClient(attacker);
if (!attacker || !attacker->client)
return NULL;
if(!self->client && self->activator && self->svflags & SVF_MONSTER)
{
temp = (float) (self->monsterinfo.level + 1) / (attacker->myskills.level + 1);
if (base_drop_chance * temp < random())
return NULL;
//set target level
targ_level = (self->monsterinfo.level + attacker->myskills.level) / 2;
// don't allow runes higher than attacker's level
if (targ_level > attacker->myskills.level)
targ_level = attacker->myskills.level;
}
else if (attacker != self && attacker != world)
{
//boss has a greater chance of dropping a rune
if (attacker->myskills.boss > 0)
temp = (float)attacker->myskills.boss / 5.0;
else
temp = (float) (self->myskills.level + 1) / (attacker->myskills.level + 1);
// miniboss has greater chance of dropping a rune
if (IsNewbieBasher(self))
temp *= 2;
//boss has a greater chance of dropping a rune
temp *= 1.0 + ((float)self->myskills.boss / 2.0);
if (base_drop_chance * temp < random())
return NULL;
//set target level
targ_level = (self->myskills.level + attacker->myskills.level) / 2;
}
else
return NULL;
item = FindItem("Rune"); // get the item properties
rune = Drop_Item(self, item); // create the entity that holds those properties
V_ItemClear(&rune->vrxitem); // initialize the rune
if (levelmod)
targ_level *= levelmod;
rune->vrxitem.quantity = 1;
//Spawn a random rune
iRandom = GetRandom(0, 1000);
if (iRandom < CHANCE_UNIQUE)
{
//spawn a unique
// vrx chile 1.4 no uniques until someone makes them
if (!spawnUnique(rune, 0))
spawnNorm(rune, targ_level, 0);
}
else if (iRandom < CHANCE_UNIQUE + CHANCE_CLASS)
{
//spawn a class-specific rune
spawnClassRune(rune, targ_level);
}
else if (iRandom < CHANCE_UNIQUE + CHANCE_CLASS + CHANCE_COMBO)
{
//spawn a combo rune
spawnCombo(rune, targ_level);
}
else if (iRandom < CHANCE_UNIQUE + CHANCE_CLASS + CHANCE_COMBO + CHANCE_NORM)
{
//spawn a normal rune
spawnNorm(rune, targ_level, 0);
}
else
{
G_FreeEdict(rune);
return NULL;
}
//Randomize id
strcpy(rune->vrxitem.id, GetRandomString(16));
return rune;
}