void Commands::forceRaid(Player& player, const std::string& param)
{
Raid* raid = Raids::getInstance()->getRaidByName(param);
if (!raid || !raid->isLoaded()) {
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "No such raid exists.");
return;
}
if (Raids::getInstance()->getRunning()) {
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Another raid is already being executed.");
return;
}
Raids::getInstance()->setRunning(raid);
RaidEvent* event = raid->getNextRaidEvent();
if (!event) {
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "The raid does not contain any data.");
return;
}
raid->setState(RAIDSTATE_EXECUTING);
uint32_t ticks = event->getDelay();
if (ticks > 0) {
g_scheduler.addEvent(createSchedulerTask(ticks, std::bind(&Raid::executeRaidEvent, raid, event)));
} else {
g_dispatcher.addTask(createTask(std::bind(&Raid::executeRaidEvent, raid, event)));
}
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Raid started.");
}
void Raid::startRaid()
{
RaidEvent* raidEvent = getNextRaidEvent();
if (raidEvent) {
state = RAIDSTATE_EXECUTING;
nextEventEvent = g_scheduler.addEvent(createSchedulerTask(raidEvent->getDelay(), std::bind(&Raid::executeRaidEvent, this, raidEvent)));
}
}
bool Raid::executeRaidEvent(RaidEvent* raidEvent)
{
if(!raidEvent->executeEvent())
return !resetRaid(false);
RaidEvent* newRaidEvent = getNextRaidEvent();
if(!newRaidEvent)
return !resetRaid(false);
nextEvent = Scheduler::getInstance().addEvent(createSchedulerTask(
std::max(RAID_MINTICKS, (int32_t)(newRaidEvent->getDelay() - raidEvent->getDelay())),
boost::bind(&Raid::executeRaidEvent, this, newRaidEvent)));
return true;
}
bool Raid::startRaid()
{
if(refCount)
return true;
RaidEvent* raidEvent = getNextRaidEvent();
if(!raidEvent)
return false;
nextEvent = Scheduler::getInstance().addEvent(createSchedulerTask(
raidEvent->getDelay(), boost::bind(&Raid::executeRaidEvent, this, raidEvent)));
Raids::getInstance()->setRunning(this);
return true;
}
void Raid::executeRaidEvent(RaidEvent* raidEvent)
{
if (raidEvent->executeEvent()) {
nextEvent++;
RaidEvent* newRaidEvent = getNextRaidEvent();
if (newRaidEvent) {
uint32_t ticks = static_cast<uint32_t>(std::max<int32_t>(RAID_MINTICKS, newRaidEvent->getDelay() - raidEvent->getDelay()));
nextEventEvent = g_scheduler.addEvent(createSchedulerTask(ticks, std::bind(&Raid::executeRaidEvent, this, newRaidEvent)));
} else {
resetRaid();
}
} else {
resetRaid();
}
}
void Raid::executeRaidEvent(RaidEvent* raidEvent)
{
if(raidEvent->executeEvent())
{
nextEvent++;
RaidEvent* newRaidEvent = getNextRaidEvent();
if(newRaidEvent)
{
uint32_t ticks = (uint32_t)std::max(((uint32_t)RAID_MINTICKS), ((int32_t)newRaidEvent->getDelay() - raidEvent->getDelay()));
nextEventEvent = g_scheduler.addEvent(createSchedulerTask(ticks, boost::bind(&Raid::executeRaidEvent, this, newRaidEvent)));
}
else
resetRaid();
}
else
resetRaid();
}
bool Raid::loadFromXml(const std::string& _filename)
{
if (isLoaded()) {
return true;
}
pugi::xml_document doc;
pugi::xml_parse_result result = doc.load_file(_filename.c_str());
if (!result) {
std::cout << "[Error - Raid::loadFromXml] Failed to load " << _filename << ": " << result.description() << std::endl;
return false;
}
for (pugi::xml_node eventNode = doc.child("raid").first_child(); eventNode; eventNode = eventNode.next_sibling()) {
RaidEvent* event;
if (strcasecmp(eventNode.name(), "announce") == 0) {
event = new AnnounceEvent();
} else if (strcasecmp(eventNode.name(), "singlespawn") == 0) {
event = new SingleSpawnEvent();
} else if (strcasecmp(eventNode.name(), "areaspawn") == 0) {
event = new AreaSpawnEvent();
} else if (strcasecmp(eventNode.name(), "script") == 0) {
event = new ScriptEvent(&Raids::getInstance()->getScriptInterface());
} else {
continue;
}
if (event->configureRaidEvent(eventNode)) {
raidEvents.push_back(event);
} else {
std::cout << "[Error - Raid::loadFromXml] In file (" << _filename << "), eventNode: " << eventNode.name() << std::endl;
delete event;
}
}
//sort by delay time
std::sort(raidEvents.begin(), raidEvents.end(), RaidEvent::compareEvents);
loaded = true;
return true;
}
bool Raid::loadFromXml(const std::string& filename)
{
if (isLoaded()) {
return true;
}
pugi::xml_document doc;
pugi::xml_parse_result result = doc.load_file(filename.c_str());
if (!result) {
printXMLError("Error - Raid::loadFromXml", filename, result);
return false;
}
for (auto eventNode : doc.child("raid").children()) {
RaidEvent* event;
if (strcasecmp(eventNode.name(), "announce") == 0) {
event = new AnnounceEvent();
} else if (strcasecmp(eventNode.name(), "singlespawn") == 0) {
event = new SingleSpawnEvent();
} else if (strcasecmp(eventNode.name(), "areaspawn") == 0) {
event = new AreaSpawnEvent();
} else if (strcasecmp(eventNode.name(), "script") == 0) {
event = new ScriptEvent(&g_game.raids.getScriptInterface());
} else {
continue;
}
if (event->configureRaidEvent(eventNode)) {
raidEvents.push_back(event);
} else {
std::cout << "[Error - Raid::loadFromXml] In file (" << filename << "), eventNode: " << eventNode.name() << std::endl;
delete event;
}
}
//sort by delay time
std::sort(raidEvents.begin(), raidEvents.end(), RaidEvent::compareEvents);
loaded = true;
return true;
}
bool Commands::forceRaid(Creature* creature, const std::string& cmd, const std::string& param)
{
Player* player = creature->getPlayer();
if(!player){
return false;
}
Raid* raid = Raids::getInstance()->getRaidByName(param);
if(!raid || !raid->isLoaded()){
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "No such raid exists.");
return false;
}
if(Raids::getInstance()->getRunning()){
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Another raid is already being executed.");
return false;
}
Raids::getInstance()->setRunning(raid);
RaidEvent* event = raid->getNextRaidEvent();
if(!event){
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "The raid does not contain any data.");
return false;
}
raid->setState(RAIDSTATE_EXECUTING);
uint32_t ticks = event->getDelay();
if(ticks > 0){
Scheduler::getScheduler().addEvent(createSchedulerTask(ticks,
boost::bind(&Raid::executeRaidEvent, raid, event)));
}
else{
Dispatcher::getDispatcher().addTask(createTask(
boost::bind(&Raid::executeRaidEvent, raid, event)));
}
player->sendTextMessage(MSG_STATUS_CONSOLE_BLUE, "Raid started.");
return true;
}
bool Raid::loadFromXml(const std::string& _filename)
{
if(isLoaded())
return true;
xmlDocPtr doc = xmlParseFile(_filename.c_str());
if(doc)
{
xmlNodePtr root, eventNode;
root = xmlDocGetRootElement(doc);
if(xmlStrcmp(root->name,(const xmlChar*)"raid") != 0)
{
std::cout << "[Error] Raids: Wrong root node." << std::endl;
xmlFreeDoc(doc);
return false;
}
std::string strValue;
eventNode = root->children;
while(eventNode)
{
RaidEvent* event;
if(xmlStrcmp(eventNode->name, (const xmlChar*)"announce") == 0)
event = new AnnounceEvent();
else if(xmlStrcmp(eventNode->name, (const xmlChar*)"singlespawn") == 0)
event = new SingleSpawnEvent();
else if(xmlStrcmp(eventNode->name, (const xmlChar*)"areaspawn") == 0)
event = new AreaSpawnEvent();
else if(xmlStrcmp(eventNode->name, (const xmlChar*)"script") == 0)
event = new ScriptEvent();
else
{
eventNode = eventNode->next;
continue;
}
if(event->configureRaidEvent(eventNode))
raidEvents.push_back(event);
else
{
std::cout << "Raids: Error in file(" << _filename << ") eventNode: " << eventNode->name << std::endl;
delete event;
}
eventNode = eventNode->next;
}
//sort by delay time
std::sort(raidEvents.begin(), raidEvents.end(), RaidEvent::compareEvents);
xmlFreeDoc(doc);
}
else
{
std::cout << "[Error] Raid: Could not load " << _filename << "!" << std::endl;
return false;
}
loaded = true;
return true;
}
bool Raid::loadFromXml(const std::string& _filename)
{
if(isLoaded())
return true;
xmlDocPtr doc = xmlParseFile(_filename.c_str());
if(!doc)
{
std::clog << "[Error - Raid::loadFromXml] Could not load raid file (" << _filename << ")." << std::endl;
std::clog << getLastXMLError() << std::endl;
return false;
}
xmlNodePtr root, eventNode;
root = xmlDocGetRootElement(doc);
if(xmlStrcmp(root->name,(const xmlChar*)"raid"))
{
std::clog << "[Error - Raid::loadFromXml] Malformed raid file (" << _filename << ")." << std::endl;
xmlFreeDoc(doc);
return false;
}
std::string strValue;
eventNode = root->children;
while(eventNode)
{
RaidEvent* event;
if(!xmlStrcmp(eventNode->name, (const xmlChar*)"announce"))
event = new AnnounceEvent(this, ref);
else if(!xmlStrcmp(eventNode->name, (const xmlChar*)"effect"))
event = new EffectEvent(this, ref);
else if(!xmlStrcmp(eventNode->name, (const xmlChar*)"itemspawn"))
event = new ItemSpawnEvent(this, ref);
else if(!xmlStrcmp(eventNode->name, (const xmlChar*)"singlespawn"))
event = new SingleSpawnEvent(this, ref);
else if(!xmlStrcmp(eventNode->name, (const xmlChar*)"areaspawn"))
event = new AreaSpawnEvent(this, ref);
else if(!xmlStrcmp(eventNode->name, (const xmlChar*)"script"))
event = new ScriptEvent(this, ref);
else
{
eventNode = eventNode->next;
continue;
}
if(!event->configureRaidEvent(eventNode))
{
std::clog << "[Error - Raid::loadFromXml] Could not configure raid in file: " << _filename << ", eventNode: " << eventNode->name << std::endl;
delete event;
}
else
raidEvents.push_back(event);
eventNode = eventNode->next;
}
//sort by delay time
std::sort(raidEvents.begin(), raidEvents.end(), RaidEvent::compareEvents);
xmlFreeDoc(doc);
loaded = true;
return true;
}
