Esempio n. 1
0
		/*
		  I'm not sure what is the point of this function.
		  Checked
		*/
		std::list<BookData>::iterator BookCollection::displayIsbn(std::list<BookData>::iterator iter,
			int num)
		{
			char rightBook = 'Y';  // Is this the right book
			std::string input;		// to hold user input

			/// a book?
			if (iter == bookList.end())
			{
				std::cout << "   Not a valid ISBN number." << std::endl;
			} // end if
			else
			{
				iter->bookInfo();

				std::cout << "   Is this the right book? (y/n)" << std::endl;
				std::getline(std::cin, input);
				rightBook = input.at(0);

				// if it is the add the book to the users total
				if (rightBook == 'Y' || rightBook == 'y')
				{
					if (booksAvailable(iter, num))
					{
						return iter;
					} // end if
					else
					{
						std::cout << "Not enough books available."  << std::endl;
						return bookList.end();
					} // end if
					//// check to see if there are books available
					//if (books->operator[](pos).getQuantity() > numBooks)
					//{
					//	std::cout << "   Adding book" << endl;
					//	// Add the book to the vector
					//	buyMe.push_back(books->operator[](pos));
					//	numB.push_back(numBooks);

					//	int newQ = books->operator[](pos).getQuantity()
					//		- numBooks;
					//	books->operator[](pos).setQuantity(newQ);
					//} // end if
					//else
					//{
					//	std::cout << "Not enough books available."  << std::endl;
					//} // end else
					
				} // end if

			} // end else

			
			//// To hold the position of the found book
			//std::list<BookData>::iterator pos = bookList.begin();

			//for (unsigned int index = 0; index < bookList.size(); index++)
			//{
			//	std::cout << std::left << std::setw(WIDTH) << "Title: " 
			//		<< pos->getTitle() << std::endl;
			//	std::cout << std::left << std::setw(WIDTH) << "ISBN: " 
			//		<< pos->getIsbn() << std::endl;
			//	std::cout << std::endl;

			//	pos++;

			//} // end for
			return bookList.end();
			std::cout << std::endl;

		} // end function displayIsbn
Esempio n. 2
0
const bool ofxWidget::isAtFront() const {
	if (sAllWidgets.empty())
		return false;
	auto it = findIt(mThis, sAllWidgets.begin(), sAllWidgets.end());
	return (std::prev(it, mNumChildren) == sAllWidgets.begin());
}
void output_html_results(bool show_description, const std::string& tagname)
{
   std::stringstream os;
   if(result_list.size())
   {
      //
      // start by outputting the table header:
      //
      os << "<table border=\"1\" cellspacing=\"1\">\n";
      os << "<tr><td><strong>Expression</strong></td>";
      if(show_description)
         os << "<td><strong>Text</strong></td>";
#if defined(BOOST_HAS_GRETA)
      if(time_greta == true)
         os << "<td><strong>GRETA</strong></td>";
      if(time_safe_greta == true)
         os << "<td><strong>GRETA<BR>(non-recursive mode)</strong></td>";
#endif
      if(time_boost == true)
         os << "<td><strong>Boost</strong></td>";
      if(time_localised_boost == true)
         os << "<td><strong>Boost + C++ locale</strong></td>";
#if defined(BOOST_HAS_POSIX)
      if(time_posix == true)
         os << "<td><strong>POSIX</strong></td>";
#endif
#ifdef BOOST_HAS_PCRE
      if(time_pcre == true)
         os << "<td><strong>PCRE</strong></td>";
#endif
#ifdef BOOST_HAS_XPRESSIVE
      if(time_xpressive == true)
         os << "<td><strong>Dynamic Xpressive</strong></td>";
#endif
      os << "</tr>\n";

      //
      // Now enumerate through all the test results:
      //
      std::list<results>::const_iterator first, last;
      first = result_list.begin();
      last = result_list.end();
      while(first != last)
      {
         os << "<tr><td><code>" << html_quote(first->expression) << "</code></td>";
         if(show_description)
            os << "<td>" << html_quote(first->description) << "</td>";
#if defined(BOOST_HAS_GRETA)
         if(time_greta == true)
         {
            print_result(os, first->greta_time, first->factor);
            if(first->greta_time > 0)
            {
               greta_total += first->greta_time / first->factor;
               ++greta_test_count;
            }
         }
         if(time_safe_greta == true)
         {
            print_result(os, first->safe_greta_time, first->factor);
            if(first->safe_greta_time > 0)
            {
               safe_greta_total += first->safe_greta_time / first->factor;
               ++safe_greta_test_count;
            }
         }
#endif
#if defined(BOOST_HAS_POSIX)
         if(time_boost == true)
         {
            print_result(os, first->boost_time, first->factor);
            if(first->boost_time > 0)
            {
               boost_total += first->boost_time / first->factor;
               ++boost_test_count;
            }
         }
#endif
         if(time_localised_boost == true)
         {
            print_result(os, first->localised_boost_time, first->factor);
            if(first->localised_boost_time > 0)
            {
               locale_boost_total += first->localised_boost_time / first->factor;
               ++locale_boost_test_count;
            }
         }
         if(time_posix == true)
         {
            print_result(os, first->posix_time, first->factor);
            if(first->posix_time > 0)
            {
               posix_total += first->posix_time / first->factor;
               ++posix_test_count;
            }
         }
#if defined(BOOST_HAS_PCRE)
         if(time_pcre == true)
         {
            print_result(os, first->pcre_time, first->factor);
            if(first->pcre_time > 0)
            {
               pcre_total += first->pcre_time / first->factor;
               ++pcre_test_count;
            }
         }
#endif
#if defined(BOOST_HAS_XPRESSIVE)
         if(time_xpressive == true)
         {
            print_result(os, first->xpressive_time, first->factor);
            if(first->xpressive_time > 0)
            {
               xpressive_total += first->xpressive_time / first->factor;
               ++xpressive_test_count;
            }
         }
#endif
         os << "</tr>\n";
         ++first;
      }
      os << "</table>\n";
      result_list.clear();
   }
   else
   {
      os << "<P><I>Results not available...</I></P>\n";
   }

   std::string result = os.str();

   std::string::size_type pos = html_contents.find(tagname);
   if(pos != std::string::npos)
   {
      html_contents.replace(pos, tagname.size(), result);
   }
}
Esempio n. 4
0
void writeReports(std::string scale) {
	std::map<std::string, Report>::iterator repIter = reports.begin();

	std::cout << std::endl;
	std::cout << FORMAT_COL << "byte sent";
	std::cout << FORMAT_COL << "pkts sent";
	std::cout << FORMAT_COL << "sleep";
	std::cout << FORMAT_COL << "scale";
	switch (type) {
	case PUB_RTP: {
		std::cout << FORMAT_COL << "[RTP]";
		break;
	}
	case PUB_MCAST: {
		std::cout << FORMAT_COL << "[RTP/MCAST]";
		break;
	}
	case PUB_TCP: {
		std::cout << FORMAT_COL << "[TCP]";
		break;
	}
	}
	std::cout << FORMAT_COL << bytesToDisplay(bytesTotal);
	std::cout << FORMAT_COL << std::endl;
	// ===

	std::cout << FORMAT_COL << bytesToDisplay(intervalFactor * (double)bytesWritten) + "/s";
	std::cout << FORMAT_COL << toStr(intervalFactor * (double)packetsWritten) + "pkt/s";
	std::cout << FORMAT_COL << timeToDisplay(delay * 1000);
	std::cout << FORMAT_COL << scale;

	std::cout << FORMAT_COL << "---";
	std::cout << std::endl;

	if (reports.size() > 0) {

		// print report messages

		std::cout << FORMAT_COL << "byte recv";
		std::cout << FORMAT_COL << "pkts recv";
		std::cout << FORMAT_COL << "pkts loss";
		std::cout << FORMAT_COL << "% loss";
		std::cout << FORMAT_COL << "compression";
		std::cout << FORMAT_COL << "pkts late";
		std::cout << FORMAT_COL << "RTT";
		std::cout << FORMAT_COL << "dscvd";
		std::cout << FORMAT_COL << "name";
		std::cout << std::endl;

		repIter = reports.begin();
		while(repIter != reports.end()) {
			Report& report = repIter->second;
			std::cout << FORMAT_COL << bytesToDisplay(intervalFactor * (double)(report.bytesRcvd)) + "/s";
			std::cout << FORMAT_COL << toStr(intervalFactor * (double)(report.pktsRcvd)) + "pkt/s";
			std::cout << FORMAT_COL << toStr(intervalFactor * (double)(report.pktsDropped)) + "pkt/s";
			std::cout << FORMAT_COL << toStr(report.pcntLoss) + "%";

            // 0.0746/0.0227 inter message
            // 0.925/0.402 intra message
            std::stringstream comprSS;
            comprSS << std::setprecision(3) << report.compressRatioHead << "/" << std::setprecision(3) << report.compressRatioPayload;
            std::cout << FORMAT_COL << comprSS.str();

			std::cout << FORMAT_COL << (report.pktsLate > 100000 ? "N/A" : toStr(report.pktsLate) + "pkt");
			std::cout << FORMAT_COL << (report.roundTripTime > 100000 ? "N/A" : toStr(report.roundTripTime) + "ms");
			std::cout << FORMAT_COL << (report.discoveryTime > 100000 ? "N/A" : toStr(report.discoveryTime) + "ms");
			std::cout << FORMAT_COL << report.pubId.substr(0, 6) + " (" + report.hostName + ")";
			std::cout << std::endl;

			report.pktsRcvd = 0;
			report.bytesRcvd = 0;
			report.pktsLate = 0;
			report.roundTripTime = 10000000;
			repIter++;
		}
	}
	//				reports.clear();

	// append our information into allReports
	Report senderReport;
	senderReport.bytesRcvd = bytesWritten;
	senderReport.pktsRcvd = packetsWritten;
	senderReport.pertainingPacket = currSeqNr;
	senderReports.push_back(senderReport);
}
Esempio n. 5
0
void ofxWidget::bringToFront(std::list<weak_ptr<ofxWidget>>::iterator it_)
{
	if (it_->expired())
		return;

	// ---------| invariant: element is valid

	auto element = it_->lock();

	// We're conservative with re-ordering.
	// Let's move the iterator backward to see if we are actually 
	// already sorted.
	// If the list were already sorted, then moving back from the current
	// iterator by the number of its children would bring us 
	// to the beginning of sAllWidgets. Then, there is no need to re-order.
	if (std::prev(it_, element->mNumChildren) == sAllWidgets.begin())
		return;

	// ----------| invariant: element (range) not yet at front.

	/*
	Algorithm:

	while current object range has a parent, put current object
	range to the front of parent range make parent range current
	object range.

	As soon as there is no parent anymore, put last object range
	to the front of the list

	Heuristic: parent iterator's position always to be found
	after current iterator.
	*/

	auto parent = element->mParent.lock();
	auto elementIt = it_;

	while (parent) {

		auto itParent = findIt(element->mParent, std::next(elementIt), sAllWidgets.end()); // start our search for parent after current element.

		// if element has parent, bring element range to front of parent range.
		if (std::prev(elementIt, element->mNumChildren) != std::prev(itParent, parent->mNumChildren)) {
			sAllWidgets.splice(
				std::prev(itParent, parent->mNumChildren), 					// where to move elements to -> front of parent range
				sAllWidgets, 												// where to take elements from
				std::prev(elementIt, element->mNumChildren),
				std::next(elementIt));		// range of elements to move -> range of current element and its children
		}

		// because sAllWidgets is a list, splice will only invalidate iterators 
		// before our next search range.

		elementIt = itParent;
		element = elementIt->lock();
		parent = element->mParent.lock();
	}

	// now move the element range (which is now our most senior parent element range) to the front fo the list.

	if (std::prev(elementIt, element->mNumChildren) != sAllWidgets.begin()) {
		sAllWidgets.splice(
			sAllWidgets.begin(),
			sAllWidgets,
			std::prev(elementIt, element->mNumChildren), // from the beginning of our now most senior parent element range
			std::next(elementIt));						 // to the end of our now most senior parent element range
	}

	ofxWidget::bVisibleListDirty = true;
}
Esempio n. 6
0
bool Monsters::loadMonster(const std::string& file, const std::string& monsterName, std::list<std::pair<MonsterType*, std::string>>& monsterScriptList, bool reloading /*= false*/)
{
	MonsterType* mType = nullptr;
	bool new_mType = true;

	pugi::xml_document doc;
	pugi::xml_parse_result result = doc.load_file(file.c_str());
	if (!result) {
		printXMLError("Error - Monsters::loadMonster", file, result);
		return false;
	}

	pugi::xml_node monsterNode = doc.child("monster");
	if (!monsterNode) {
		std::cout << "[Error - Monsters::loadMonster] Missing monster node in: " << file << std::endl;
		return false;
	}

	pugi::xml_attribute attr;
	if (!(attr = monsterNode.attribute("name"))) {
		std::cout << "[Error - Monsters::loadMonster] Missing name in: " << file << std::endl;
		return false;
	}

	if (reloading) {
		mType = getMonsterType(monsterName);
		if (mType != nullptr) {
			new_mType = false;
			mType->reset();
		}
	}

	if (new_mType) {
		mType = &monsters[asLowerCaseString(monsterName)];
	}

	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("skull"))) {
		mType->skull = getSkullType(attr.as_string());
	}

	if ((attr = monsterNode.attribute("script"))) {
		monsterScriptList.emplace_back(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 (auto flagNode : node.children()) {
			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<uint16_t>(attr.value());
			} else if (strcasecmp(attrName, "lightcolor") == 0) {
				mType->lightColor = pugi::cast<uint16_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 = pugi::cast<uint32_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 (auto attackNode : node.children()) {
			spellBlock_t sb;
			if (deserializeSpell(attackNode, sb, monsterName)) {
				mType->attackSpells.emplace_back(std::move(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 (auto defenseNode : node.children()) {
			spellBlock_t sb;
			if (deserializeSpell(defenseNode, sb, monsterName)) {
				mType->defenseSpells.emplace_back(std::move(sb));
			} else {
				std::cout << "[Warning - Monsters::loadMonster] Cant load spell. " << file << std::endl;
			}
		}
	}

	if ((node = monsterNode.child("immunities"))) {
		for (auto immunityNode : node.children()) {
			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 (auto voiceNode : node.children()) {
			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.emplace_back(vb);
		}
	}

	if ((node = monsterNode.child("loot"))) {
		for (auto lootNode : node.children()) {
			LootBlock lootBlock;
			if (loadLootItem(lootNode, lootBlock)) {
				mType->lootItems.emplace_back(std::move(lootBlock));
			} else {
				std::cout << "[Warning - Monsters::loadMonster] Cant load loot. " << file << std::endl;
			}
		}
	}

	if ((node = monsterNode.child("elements"))) {
		for (auto elementNode : node.children()) {
			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 (auto summonNode : node.children()) {
			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->summons.emplace_back(sb);
			} else {
				std::cout << "[Warning - Monsters::loadMonster] Missing summon name. " << file << std::endl;
			}
		}
	}

	if ((node = monsterNode.child("script"))) {
		for (auto eventNode : node.children()) {
			if ((attr = eventNode.attribute("name"))) {
				mType->scripts.emplace_back(attr.as_string());
			} else {
				std::cout << "[Warning - Monsters::loadMonster] Missing name for script event. " << file << std::endl;
			}
		}
	}

	mType->summons.shrink_to_fit();
	mType->lootItems.shrink_to_fit();
	mType->attackSpells.shrink_to_fit();
	mType->defenseSpells.shrink_to_fit();
	mType->voiceVector.shrink_to_fit();
	mType->scripts.shrink_to_fit();
	return true;
}
Esempio n. 7
0
 void FilterTargets(std::list<Unit*>& unitList)
 {
     unitList.remove_if (OrientationCheck(GetCaster()));
 }
Esempio n. 8
0
bool Vma::get_pages_for_range(const RangePtr &mrange,
			      std::list<PartialPageInfo> &ppinfo)
{
    ppinfo.clear();
    
    if (mrange->size() <= 0) {
	warn << "Vma::get_pages_for_range - invalid range\n";
	return false;
    }
    if (!range()->contains(mrange)) {
	warn << "Vma::get_pages_for_range - range "
	    << mrange->to_string() << " outside vma " << to_string() << "\n";
	return false;
    }

    unsigned int start_pgnum, end_pgnum;
    if (!addr_to_pgnum(mrange->start(), start_pgnum)) {
	warn << "Vma::get_pages_for_range - can't get start pgnum\n";
	return false;
    }
    if (!addr_to_pgnum(mrange->end() - 1, end_pgnum)) {
	warn << "Vma::get_pages_for_range - can't get end pgnum\n";
	return false;
    }
    if (start_pgnum > end_pgnum) {
	warn << "start_pgnum greater than end: "
	     << start_pgnum << ", " << end_pgnum << "\n";
	return false;
    }
    if (start_pgnum >= _pages.size()) {
	warn << "Vma::get_pages_for_range - start pgnum out of range: "
	     << start_pgnum << ", " << _pages.size() << " " << _fname << "\n";
	return false;
    }
    if (end_pgnum >= _pages.size()) {
	warn << "Vma::get_pages_for_range - end pgnum out of range: "
	     << end_pgnum << ", " << _pages.size() << "\n";
	return false;
    }

    if (start_pgnum == end_pgnum) {
	ppinfo.push_back(PartialPageInfo(_pages[start_pgnum], mrange->size()));
	return true;
    }

    Address bytes = Elf::page_size()
	- (mrange->start() - Elf::page_align_down(mrange->start()));
    ppinfo.push_back(PartialPageInfo(_pages[start_pgnum], bytes));

    bytes = mrange->end() - Elf::page_align_down(mrange->end() - 1);
    if (bytes > 0) {
	ppinfo.push_back(PartialPageInfo(_pages[end_pgnum], bytes));
    }

    bytes = Elf::page_size();
    for (unsigned int pgnum = start_pgnum + 1; pgnum < end_pgnum; ++pgnum) {
	ppinfo.push_back(PartialPageInfo(_pages[pgnum], bytes));
    }

    return true;
}
Esempio n. 9
0
void M3U8Parser::parseSegments(vlc_object_t *p_obj, Representation *rep, const std::list<Tag *> &tagslist)
{
    SegmentList *segmentList = new (std::nothrow) SegmentList(rep);

    rep->setTimescale(100);
    rep->b_loaded = true;

    mtime_t totalduration = 0;
    mtime_t nzStartTime = 0;
    mtime_t absReferenceTime = VLC_TS_INVALID;
    uint64_t sequenceNumber = 0;
    bool discontinuity = false;
    std::size_t prevbyterangeoffset = 0;
    const SingleValueTag *ctx_byterange = NULL;
    SegmentEncryption encryption;
    const ValuesListTag *ctx_extinf = NULL;

    std::list<Tag *>::const_iterator it;
    for(it = tagslist.begin(); it != tagslist.end(); ++it)
    {
        const Tag *tag = *it;
        switch(tag->getType())
        {
            /* using static cast as attribute type permits avoiding class check */
            case SingleValueTag::EXTXMEDIASEQUENCE:
            {
                sequenceNumber = (static_cast<const SingleValueTag*>(tag))->getValue().decimal();
            }
            break;

            case ValuesListTag::EXTINF:
            {
                ctx_extinf = static_cast<const ValuesListTag *>(tag);
            }
            break;

            case SingleValueTag::URI:
            {
                const SingleValueTag *uritag = static_cast<const SingleValueTag *>(tag);
                if(uritag->getValue().value.empty())
                {
                    ctx_extinf = NULL;
                    ctx_byterange = NULL;
                    break;
                }

                HLSSegment *segment = new (std::nothrow) HLSSegment(rep, sequenceNumber++);
                if(!segment)
                    break;

                segment->setSourceUrl(uritag->getValue().value);
                if((unsigned)rep->getStreamFormat() == StreamFormat::UNKNOWN)
                    setFormatFromExtension(rep, uritag->getValue().value);

                if(ctx_extinf)
                {
                    if(ctx_extinf->getAttributeByName("DURATION"))
                    {
                        const mtime_t nzDuration = CLOCK_FREQ * ctx_extinf->getAttributeByName("DURATION")->floatingPoint();
                        segment->duration.Set(ctx_extinf->getAttributeByName("DURATION")->floatingPoint() * (uint64_t) rep->getTimescale());
                        segment->startTime.Set(rep->getTimescale().ToScaled(nzStartTime));
                        nzStartTime += nzDuration;
                        totalduration += nzDuration;

                        if(absReferenceTime > VLC_TS_INVALID)
                        {
                            segment->utcTime = absReferenceTime;
                            absReferenceTime += nzDuration;
                        }
                    }
                    ctx_extinf = NULL;
                }

                segmentList->addSegment(segment);

                if(ctx_byterange)
                {
                    std::pair<std::size_t,std::size_t> range = ctx_byterange->getValue().getByteRange();
                    if(range.first == 0)
                        range.first = prevbyterangeoffset;
                    prevbyterangeoffset = range.first + range.second;
                    segment->setByteRange(range.first, prevbyterangeoffset);
                    ctx_byterange = NULL;
                }

                if(discontinuity)
                {
                    segment->discontinuity = true;
                    discontinuity = false;
                }

                if(encryption.method != SegmentEncryption::NONE)
                    segment->setEncryption(encryption);
            }
            break;

            case SingleValueTag::EXTXTARGETDURATION:
                rep->targetDuration = static_cast<const SingleValueTag *>(tag)->getValue().decimal();
                break;

            case SingleValueTag::EXTXPLAYLISTTYPE:
                rep->b_live = (static_cast<const SingleValueTag *>(tag)->getValue().value != "VOD");
                break;

            case SingleValueTag::EXTXBYTERANGE:
                ctx_byterange = static_cast<const SingleValueTag *>(tag);
                break;

            case SingleValueTag::EXTXPROGRAMDATETIME:
                rep->b_consistent = false;
                absReferenceTime = VLC_TS_0 +
                        UTCTime(static_cast<const SingleValueTag *>(tag)->getValue().value).mtime();
                break;

            case AttributesTag::EXTXKEY:
            {
                const AttributesTag *keytag = static_cast<const AttributesTag *>(tag);
                if( keytag->getAttributeByName("METHOD") &&
                    keytag->getAttributeByName("METHOD")->value == "AES-128" &&
                    keytag->getAttributeByName("URI") )
                {
                    encryption.method = SegmentEncryption::AES_128;
                    encryption.key.clear();

                    Url keyurl(keytag->getAttributeByName("URI")->quotedString());
                    if(!keyurl.hasScheme())
                    {
                        keyurl.prepend(Helper::getDirectoryPath(rep->getPlaylistUrl().toString()).append("/"));
                    }

                    block_t *p_block = Retrieve::HTTP(p_obj, keyurl.toString());
                    if(p_block)
                    {
                        if(p_block->i_buffer == 16)
                        {
                            encryption.key.resize(16);
                            memcpy(&encryption.key[0], p_block->p_buffer, 16);
                        }
                        block_Release(p_block);
                    }

                    if(keytag->getAttributeByName("IV"))
                    {
                        encryption.iv.clear();
                        encryption.iv = keytag->getAttributeByName("IV")->hexSequence();
                    }
                }
                else
                {
                    /* unsupported or invalid */
                    encryption.method = SegmentEncryption::NONE;
                    encryption.key.clear();
                    encryption.iv.clear();
                }
            }
            break;

            case Tag::EXTXDISCONTINUITY:
                discontinuity  = true;
                break;

            case Tag::EXTXENDLIST:
                rep->b_live = false;
                break;
        }
    }

    if(rep->isLive())
    {
        rep->getPlaylist()->duration.Set(0);
    }
    else if(totalduration > rep->getPlaylist()->duration.Get())
    {
        rep->getPlaylist()->duration.Set(totalduration);
    }

    rep->setSegmentList(segmentList);
}
Esempio n. 10
0
void Floor::addWaitingPeople(const std::list<HumanPtr>& people) {
	containedPeople_.insert(containedPeople_.end(), people.begin(), people.end());
}
Esempio n. 11
0
 void FilterTargets(std::list<WorldObject*>& unitList)
 {
     unitList.remove_if(Trinity::ObjectGUIDCheck(GetCaster()->GetChannelObjectGuid()));
 }
Esempio n. 12
0
 virtual ~Block() {
     blocks.remove(this);
 }
Esempio n. 13
0
 Block( XGame *g ) : Sprite(g) {
     blocks.push_back(this);
     z = maxZ--;
 }
Esempio n. 14
0
 void FilterTargets(std::list<Unit*>& unitList)
 {
     unitList.remove_if(SanctumSentryCheck());
 }
Esempio n. 15
0
int countValueDuplicators(const std::list<TemplateBase<DuplicatorType> >& values)
{
    return values.size();
}
void GameState_BasePlayable::HandleSFEvents(std::list<sf::Event>& sfEvents) {
	mMenuStateMachine->RefreshStack();

	if (inoutFader != 0) {
		if (cancelNavMapGenBtn)
			cancelNavMapGenBtn->HandleSFEvents(sfEvents);

		std::list<sf::Event>::iterator itSfEvent = sfEvents.begin();
		while (itSfEvent != sfEvents.end()) {
			switch (itSfEvent->Type) {
				case sf::Event::Closed:
					Game->GetRenderWindow()->Close();
				break;
				default:
				break;
			}

			++itSfEvent;
		}

		return;
	}

	if (!mMenuStateMachine->IsEmpty())
		mMenuStateMachine->HandleSFEvents(sfEvents);

	std::list<sf::Event>::iterator itSfEvent = sfEvents.begin();
	while (itSfEvent != sfEvents.end()) {
		switch (itSfEvent->Type) {
			case sf::Event::Closed:
				Game->GetRenderWindow()->Close();
			break;
			case sf::Event::KeyPressed:
				switch (itSfEvent->Key.Code) {
					case sf::Key::Escape:
						if (!finished) {
							if (!mMenuStateMachine->IsEmpty())
								OnPause(false);
							else
								OnPause(true);
						}
					break;
					case sf::Key::Space:
						if (HUD) {
							GameObject* interactee = HUD->GetInteractee();
							if (interactee) {
								if (interactee == chest && chest) {
									goldPickedUp += MyMagicNumbers::goldValue_chest;

									for (unsigned int i = 0; i != 2; ++i) {
										if (objectives[i] == chest) {
											OnObjectiveCompleted(i);
											objectives[i] = 0;
										}
									}
									PopWorldSpace(chest);
									delete chest;
									chest = 0;

									SoundEffect* coinJingle = new SoundEffect("Content/Audio/coin.wav");
									coinJingle->oneShot = true;
									Sounds->RefreshVol_Effect_Of(coinJingle);
									coinJingle->Play();

									HUD->SetAmountGold(goldPickedUp);

									HUD->SetInteractContextNote(0);
								}
								else if (/*interactee == princess && */princess) {
									princess->StartFollowing(princess->IsFollowingAnyone() ?
																0 : player);

									HUD->SetInteractContextNote(0);


									// if following than it's considered completed..
									if (princess->IsFollowingAnyone()) {
										for (unsigned int i = 0; i != 2; ++i) {
											// if it was the active objective
											if (objectives[i] == princess
													&& objectives[i]->objectiveState == ACTIVE) {
												OnObjectiveCompleted(i);
											}
										}
									}
									else {
										// However..
										for (unsigned int i = 0; i != 2; ++i) {
											// if the active objective is a goal
											if (objectives[i]
													&& objectives[i]->objectiveState == ACTIVE
													&& objectives[i]->entityType == ID_GOAL) {

												// looking backwards
												for (int j = i - 1; j >= 0; --j) {
													// j represents the last objective

													// if it was this princess
													if (objectives[j] == princess) {
														// then that princess should have been brought here

														// so we set the current goal state to inactive, and hide it
														objectives[i]->objectiveState = INACTIVE;
														PopWorldSpace(dynamic_cast<Goal*>(objectives[i]));

														// and reactivate the former princess objective
														objectives[j]->objectiveState = ACTIVE;
														HUD->SetObjective("Content/Textures/princess_thumbnail.png");
													}
												}

											}
										}
									}

								}
							}
						}
					break;
					default:
					break;
				}
			break;
			default:
			break;
		}

		++itSfEvent;
	}

	if (finished) {
		if (player) player->PauseAudio();
		if (princess) princess->PauseAudio();

		const EntityMap& guards = (*GameObjects)[ID_GUARD];
		for (EntityMap::const_iterator itG = guards.begin(); itG != guards.end(); itG++) {
			dynamic_cast<Guard*>(itG->second)->PauseAudio();
		}
	}
}
Esempio n. 17
0
void Creature::startAutoWalk(const std::list<Direction>& listDir)
{
	listWalkDir = listDir;
	addEventWalk(listDir.size() == 1);
}
Esempio n. 18
0
 void FilterTargets(std::list<Unit*>& unitList)
 {
     unitList.remove_if(PlayerOrPetCheck());
 }
Esempio n. 19
0
void MouseTest( GLFWwindow* window, GameObjectBird *pBird, ScreenLine* pLine1, ScreenLine* pLine2, std::list<GameObject *>  gameObjectList  )
{

	// Quick and dirty test, if these work the rest do.
	// --> try move the mouse inside the window, click right, click left
	if (!pBird)
		return;
	
	if (pBird->bState==SLING)
	{
		pBird->pBody->SetActive(false);
		b2Vec2 newPos( PixelToMeter((float)slingX), PixelToMeter((float)slingY) );
		pBird->pBody->SetTransform( newPos, 0.0f );
	}

	double xpos;
	double ypos;

	static float lastXPos;
	static float lastYPos;
	// get mouse position
	glfwGetCursorPos( window, &xpos, &ypos);
	Camera *pCam = Camera::Instance();
	pCam;
	// correct for origin
	double t = ypos / 600.0;
	ypos = 600.0 + t * (-600.0);


	MouseState			mState = NONE;
	PositionState		pState = UNKNOWN;

	GameObject* b = pBird;
	Matrix viewMatrix = pCam->getViewMatrix();
	Matrix projMatrix = pCam->getProjMatrix();
	Matrix worldMatrix = b->pGameSprite->returnWorld();
	Vect vout = Vect(0.0f,0.0f,0.0f) * worldMatrix * viewMatrix * projMatrix; 
	float zoom = vout[w];
	
	vout[x] = vout[x]/vout[w];
	vout[y] = vout[y]/vout[w];

	float X = (vout[x]+1.0f)*(pCam->viewport_width/2.0f);
	float Y= (vout[y]+1.0f)*(pCam->viewport_height/2.0f);

	Vect birdPos(pBird->pos.x, pBird->pos.y,0.0f);
	Vect mousePos((float ) xpos,(float ) ypos, 0.0f);
	
	Vect local( X, Y, 0.0f);
	Vect Dist = mousePos - local;
	
	if ( Dist.mag() < (10.0f / zoom) )
	{
		pState = INSIDE;
	}
	else
	{
		pState = OUTSIDE;
	}
	//printf("%f - %f", Dist[x],Dist[y] );
	//printf("  |  %f - %f", X, Y );
	//xpos = xpos + Dist[x]*zoom;
	//ypos = ypos + Dist[y]*zoom;
	//printf("%f - %f ",xpos, ypos);
	mState = NONE;
	if( glfwGetMouseButton (window, GLFW_MOUSE_BUTTON_RIGHT ) == GLFW_PRESS)
	{
		mState = RIGHT;
	}

	if( glfwGetMouseButton (window, GLFW_MOUSE_BUTTON_LEFT ) == GLFW_PRESS)
	{
		
		mState = LEFT;
	}

	if (mState == LEFT && pBird->bState == NORMAL1)
	{
		pBird->bState = NORMAL2;
		pBird->onMouseAction();
		
	}

// Enter MOVING state
	if( mState == LEFT && pState == INSIDE)
	{
		;
		pBird->bState = MOVING;
		pBird->pBody->SetActive(false);
	}
	
	// small sublty here, once moving, left dictates mode
	if ( pBird->bState == MOVING)
	{
		if( mState == LEFT )//this drags the bird around
		{
			/*b2Vec2 newPos( PixelToMeter((float)xpos), PixelToMeter((float)ypos) );
			pBird->pBody->SetTransform( newPos, 0.0f );
			
			pLine1->posB=B;
			pLine2->posB=B;*/
			b2Vec2 slingPos(PixelToMeter((float)slingX), PixelToMeter((float)slingY));
			b2Vec2 newPos(PixelToMeter((float)pBird->pos.x+Dist[x]*zoom), PixelToMeter((float)pBird->pos.y+Dist[y]*zoom));
			
			b2Vec2 check(PixelToMeter((float)pBird->pos.x+Dist[x]*zoom-slingX), PixelToMeter((float)pBird->pos.y+Dist[y]*zoom - slingY));
			if (check.Length() > 2)
			{
				check.Normalize();
				newPos = slingPos + 2*check;
			}
			else
			{
				newPos.Set( PixelToMeter((float)pBird->pos.x+Dist[x]*zoom), PixelToMeter((float)pBird->pos.y+Dist[y]*zoom) );
			}
			//printf("%f - %f ",newPos.x, newPos.y);
			pBird->pBody->SetTransform( newPos, 0.0f );
			Vect2D B(MeterToPixel((float)newPos.x), MeterToPixel((float)newPos.y));
			pLine1->posB=B;
			pLine2->posB=B;	
		}
		else//this fires bird from the slingshot
		{	
			
			b2Vec2 slingshot(PixelToMeter(slingX-pBird->pos.x), PixelToMeter(slingY-pBird->pos.y));
			pBird->bState = NORMAL1;
			pBird->pBody->SetActive(true);
			float32 mag = slingshot.Length();
			if (mag>2)
				mag=2;
			slingshot.Normalize();
			if (pBird->pBody->GetMass()<10)
				mag*=20;
			else
				mag*=200;
			b2Vec2 vel;
			vel = mag * slingshot;
			pBird->pBody->ApplyLinearImpulse( vel, pBird->pBody->GetWorldCenter(), true );
			pBird->pBody->SetActive(true);
			Vect2D B(slingX, slingY) ;
			pLine1->posB=B;
			pLine2->posB=B;
			pBird->launch();
			AzulCore::clearTrails();
			std::list< GameObject *>::iterator it=gameObjectList.begin();
			while( it!=gameObjectList.end() )
			{
				GameObject *pGameObj = *it++;
				
				pGameObj->damageActive=true;
			}
		}
	}
	if (pBird->bState==SLING)
	{
		pBird->pBody->SetActive(false);
		b2Vec2 newPos( PixelToMeter((float)slingX), PixelToMeter((float)slingY) );
		pBird->pBody->SetTransform( newPos, 0.0f );
	}

	if (pBird->bState==SLING||pBird->bState==MOVING)
	{
		AzulCore::setTargetAndSpeed((slingX), (slingY), -0.2f,0.01f);
	}
	else 
	{
		AzulCore::setTargetAndSpeed(pBird->pos.x, pBird->pos.y, 0.1f,10.0f);
	}
		
}
Esempio n. 20
0
void levelClass::readLevelEdit(std::string nameLevel, std::list<infoEvent>& listEvent, std::list<characterClass*>& listEnemy, std::map<std::pair<int, int>, itemClass*>& mapLevel, int& endOfLevel, int& heightLevel, std::string& typeLevel)
{
    std::ifstream file(nameLevel.c_str());

    if(file.is_open())
    {
        std::string line;
        std::string typeLine = "END";
        while(std::getline(file, line))
        {
            if(line == "END")
            {
                if(typeLine == "SPAWN_ENEMY" || typeLine == "CHANGE_MAP")
                    typeLine = "EVENT";
                else
                    typeLine = "END";
            }
            if(typeLine == "MAP")
            {
                std::string name = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseX = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseY = line;
                mapLevel.insert(std::pair<std::pair<int, int>, itemClass*>(std::pair<int, int>(std::atoi(poseX.c_str()), std::atoi(poseY.c_str())), new basicBlocClass(name, std::atoi(poseX.c_str()), std::atoi(poseY.c_str()))));
            }
            else if(typeLine == "ENEMY")
            {
                std::string name = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseX = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseY = line;
                if(name == "BOSS")
                    listEnemy.push_back(new bossEnemyClass(std::atoi(poseX.c_str()), std::atoi(poseY.c_str()), name));
                else
                    listEnemy.push_back(new basicEnemyClass(std::atoi(poseX.c_str()), std::atoi(poseY.c_str()), name));
            }
            else if(typeLine == "EVENT")
            {
                std::string name = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                if(name == "MESSAGE")
                {
                    std::string poseX = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string poseY = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string width = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string height = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string message = line;
                    while(message.find("\\n") != std::string::npos)
                    {
                        message.replace(message.find("\\n"), 2, "&n");
                    }
                    infoEvent tmp;
                    sf::RectangleShape surface;
                    surface.setPosition(std::atoi(poseX.c_str()), std::atoi(poseY.c_str()));
                    surface.setSize(sf::Vector2f(std::atoi(width.c_str()), std::atoi(height.c_str())));
                    surface.setFillColor(sf::Color::Cyan);
                    tmp.name = "MESSAGE";
                    tmp.surface = surface;
                    tmp.valX = 0;
                    tmp.valY = 0;
                    tmp.action.push_back(message);
                    listEvent.push_back(tmp);
                }
                else if(name == "SPAWN_ENEMY")
                {
                    std::string poseX = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string poseY = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string width = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string height = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string newPoseX = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string newPoseY = line;
                    sf::RectangleShape surface;
                    surface.setPosition(std::atoi(poseX.c_str()), std::atoi(poseY.c_str()));
                    surface.setSize(sf::Vector2f(std::atoi(width.c_str()), std::atoi(height.c_str())));
                    surface.setFillColor(sf::Color::Cyan);
                    infoEvent tmp;
                    tmp.name = "SPAWN_ENEMY";
                    tmp.surface = surface;
                    tmp.valX = std::atoi(newPoseX.c_str());
                    tmp.valY = std::atoi(newPoseY.c_str());
                    typeLine = "SPAWN_ENEMY";
                    listEvent.push_back(tmp);
                }
                else if(name == "CHANGE_MAP")
                {
                    std::string poseX = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string poseY = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string width = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string height = line;
                    sf::RectangleShape surface;
                    surface.setPosition(std::atoi(poseX.c_str()), std::atoi(poseY.c_str()));
                    surface.setSize(sf::Vector2f(std::atoi(width.c_str()), std::atoi(height.c_str())));
                    surface.setFillColor(sf::Color::Cyan);
                    infoEvent tmp;
                    tmp.name = "CHANGE_MAP";
                    tmp.surface = surface;
                    tmp.valX = 0;
                    tmp.valY = 0;
                    typeLine = "CHANGE_MAP";
                    listEvent.push_back(tmp);
                }
            }
            else if(typeLine == "SPAWN_ENEMY")
            {
                std::string name = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseX = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseY = line;
                listEvent.back().action.push_back(name + " " + poseX + " " + poseY);
            }
            else if(typeLine == "CHANGE_MAP")
            {
                std::string name = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseX = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseY = line;
                listEvent.back().action.push_back(name + " " + poseX + " " + poseY);
            }
            else if(typeLine == "HEIGHT")
            {
                heightLevel = std::atoi(line.c_str());
            }
            else if(typeLine == "ENDOFLEVEL")
            {
                endOfLevel = std::atoi(line.c_str());
            }
            else if(typeLine == "TYPELEVEL")
            {
                typeLevel = line.c_str();
            }

            if(line == "MAP")
                typeLine = "MAP";
            else if(line == "ENEMY")
                typeLine = "ENEMY";
            else if(line == "EVENT")
                typeLine = "EVENT";
            else if(line == "HEIGHT")
                typeLine = "HEIGHT";
            else if(line == "ENDOFLEVEL")
                typeLine = "ENDOFLEVEL";
            else if(line == "TYPELEVEL")
                typeLine = "TYPELEVEL";
        }
    file.close();
    }
}
Esempio n. 21
0
void Stage::execute(StreamPointTable& table, std::list<Stage *>& stages)
{
    std::vector<bool> skips(table.capacity());
    std::list<Stage *> filters;
    SpatialReference srs;

    // Separate out the first stage.
    Stage *reader = stages.front();

    // Build a list of all stages except the first.  We may have a writer in
    // this list in addition to filters, but we treat them in the same way.
    auto begin = stages.begin();
    begin++;
    std::copy(begin, stages.end(), std::back_inserter(filters));

    for (Stage *s : stages)
    {
        s->ready(table);
        srs = s->getSpatialReference();
        if (!srs.empty())
            table.setSpatialReference(srs);
    }

    // Loop until we're finished.  We handle the number of points up to
    // the capacity of the StreamPointTable that we've been provided.

    bool finished = false;
    while (!finished)
    {
        // Clear the spatial reference when processing starts.
        table.clearSpatialReferences();
        PointId idx = 0;
        PointRef point(table, idx);
        point_count_t pointLimit = table.capacity();

        // When we get false back from a reader, we're done, so set
        // the point limit to the number of points processed in this loop
        // of the table.
        for (PointId idx = 0; idx < pointLimit; idx++)
        {
            point.setPointId(idx);
            finished = !reader->processOne(point);
            if (finished)
                pointLimit = idx;
        }
        srs = reader->getSpatialReference();
        if (!srs.empty())
            table.setSpatialReference(srs);

        // When we get a false back from a filter, we're filtering out a
        // point, so add it to the list of skips so that it doesn't get
        // processed by subsequent filters.
        for (Stage *s : filters)
        {
            for (PointId idx = 0; idx < pointLimit; idx++)
            {
                if (skips[idx])
                    continue;
                point.setPointId(idx);
                if (!s->processOne(point))
                    skips[idx] = true;
            }
            srs = s->getSpatialReference();
            if (!srs.empty())
                table.setSpatialReference(srs);
        }

        // Yes, vector<bool> is terrible.  Can do something better later.
        for (size_t i = 0; i < skips.size(); ++i)
            skips[i] = false;
        table.reset();
    }

    for (Stage *s : stages)
        s->done(table);
}
Esempio n. 22
0
void levelClass::readLevel(std::string nameLevel, std::list<eventClass*>& listEvent, std::list<characterClass*>& listEnemy, std::map<std::pair<int, int>, itemClass*>& mapLevel, int& endOfLevel, int& heightLevel, std::string& typeLevel, int poseXPlayer, lightManagerClass& lightManager)
{
    std::ifstream file(nameLevel.c_str());

    if(file.is_open())
    {
        std::string line;
        std::string typeLine = "END";
        spawnEnemyEventClass* tmpEventSpawn;
        changeMapEventClass* tmpChangeMap;
        while(std::getline(file, line))
        {
            if(line == "END")
            {
                if(typeLine == "SPAWN_ENEMY" || typeLine == "CHANGE_MAP")
                    typeLine = "EVENT";
                else
                    typeLine = "END";
            }
            if(typeLine == "MAP")
            {
                std::string name = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseX = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseY = line;
                mapLevel.insert(std::pair<std::pair<int, int>, itemClass*>(std::pair<int, int>(std::atoi(poseX.c_str()), std::atoi(poseY.c_str())), new basicBlocClass(name, std::atoi(poseX.c_str()), std::atoi(poseY.c_str()))));
            }
            else if(typeLine == "ENEMY")
            {
                std::string name = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseX = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseY = line;
                if(name == "BOSS")
                    listEnemy.push_back(new bossEnemyClass(std::atoi(poseX.c_str()), std::atoi(poseY.c_str()), name));
                else
                    listEnemy.push_back(new basicEnemyClass(std::atoi(poseX.c_str()), std::atoi(poseY.c_str()), name));
            }
            else if(typeLine == "EVENT")
            {
                std::string name = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                if(name == "MESSAGE")
                {
                    std::string poseX = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string poseY = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string width = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string height = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string message = line;
                    while(message.find("\\n") != std::string::npos)
                    {
                        message.replace(message.find("\\n"), 2, "\n");
                    }
                    if(std::atoi(poseX.c_str()) > poseXPlayer)
                    {
                        sf::RectangleShape surface;
                        surface.setPosition(std::atoi(poseX.c_str()), std::atoi(poseY.c_str()));
                        surface.setSize(sf::Vector2f(std::atoi(width.c_str()), std::atoi(height.c_str())));
                        listEvent.push_back(new messageEventClass(message, surface));
                    }
                }
                else if(name == "SPAWN_ENEMY")
                {
                    std::string poseX = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string poseY = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string width = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string height = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string newPoseX = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string newPoseY = line;
                    sf::RectangleShape surface;
                    surface.setPosition(std::atoi(poseX.c_str()), std::atoi(poseY.c_str()));
                    surface.setSize(sf::Vector2f(std::atoi(width.c_str()), std::atoi(height.c_str())));
                    tmpEventSpawn = new spawnEnemyEventClass(surface, std::atoi(newPoseX.c_str()), std::atoi(newPoseY.c_str()));
                    typeLine = "SPAWN_ENEMY";
                    listEvent.push_back(tmpEventSpawn);
                }
                else if(name == "CHANGE_MAP")
                {
                    std::string poseX = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string poseY = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string width = line.substr(0, line.find(' '));
                    line.erase(0, line.find(' ') + 1);
                    std::string height = line;
                    sf::RectangleShape surface;
                    surface.setPosition(std::atoi(poseX.c_str()), std::atoi(poseY.c_str()));
                    surface.setSize(sf::Vector2f(std::atoi(width.c_str()), std::atoi(height.c_str())));
                    tmpChangeMap = new changeMapEventClass(surface);
                    typeLine = "CHANGE_MAP";
                    listEvent.push_back(tmpChangeMap);
                }
            }
            else if(typeLine == "SPAWN_ENEMY")
            {
                std::string name = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseX = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseY = line;
                tmpEventSpawn->addToList(name, std::atoi(poseX.c_str()), std::atoi(poseY.c_str()));
            }
            else if(typeLine == "CHANGE_MAP")
            {
                std::string name = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseX = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseY = line;
                tmpChangeMap->addToList(name, std::atoi(poseX.c_str()), std::atoi(poseY.c_str()));
            }
            else if(typeLine == "LIGHT_WALL")
            {
                std::string poseXFirst = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseYFirst = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseXSecond = line.substr(0, line.find(' '));
                line.erase(0, line.find(' ') + 1);
                std::string poseYSecond = line;
                lightManager.addWall(sf::Vector2f(atoi(poseXFirst.c_str()), atoi(poseYFirst.c_str())), sf::Vector2f(atoi(poseXSecond.c_str()), atoi(poseYSecond.c_str())));
            }
            else if(typeLine == "HEIGHT")
            {
                heightLevel = std::atoi(line.c_str());
            }
            else if(typeLine == "ENDOFLEVEL")
            {
                endOfLevel = std::atoi(line.c_str());
            }
            else if(typeLine == "TYPELEVEL")
            {
                typeLevel = line.c_str();
            }

            if(line == "MAP")
                typeLine = "MAP";
            else if(line == "ENEMY")
                typeLine = "ENEMY";
            else if(line == "EVENT")
                typeLine = "EVENT";
            else if(line == "LIGHT_WALL")
                typeLine = "LIGHT_WALL";
            else if(line == "HEIGHT")
                typeLine = "HEIGHT";
            else if(line == "ENDOFLEVEL")
                typeLine = "ENDOFLEVEL";
            else if(line == "TYPELEVEL")
                typeLine = "TYPELEVEL";
        }
        file.close();
    }
}
Esempio n. 23
0
int main(int argc, char** argv) {
	int option;
    streamFile = argv[0]; // default
	while ((option = getopt(argc, argv, "zcsm:w:l:r:f:t:i:o:d:x:y:e:")) != -1) {
		switch(option) {
		case 'z':
			useZeroCopy = true;
			break;
        case 'y':
                compressionWithState = true;
                // fall through
		case 'x': {
            char* compArg = optarg;
            
            // http://stackoverflow.com/a/53878/990120
            std::list<std::string> compArgs;
            do {
                const char *begin = compArg;
                while(*compArg != ':' && *compArg)
                    compArg++;

                compArgs.push_back(std::string(begin, compArg - begin));
                
            } while(0 != *compArg++);
            
            if (!compArgs.empty()) {
                compressionType = compArgs.front();
                compArgs.pop_front();
            } else {
                printUsageAndExit();
            }

            if (!compArgs.empty()) {
                compressionLevel = strTo<int>(compArgs.front());
                if (toStr(compressionLevel) != compArgs.front())
                    printUsageAndExit();
                compArgs.pop_front();
            }

            if (!compArgs.empty()) {
                if (!compressionWithState)
                    printUsageAndExit();
                compressionRefreshInterval = strTo<int>(compArgs.front());
                if (toStr(compressionRefreshInterval) != compArgs.front())
                    printUsageAndExit();
                compArgs.pop_front();
            }

		}
		break;
		case 'c':
			isClient = true;
			break;
		case 's':
			isServer = true;
			break;
		case 'l':
			pcntLossOk = atof((const char*)optarg);
			break;
		case 't':
			if (strncasecmp(optarg, "tcp", 3) == 0) {
				type = PUB_TCP;
			} else if (strncasecmp(optarg, "mcast", 5) == 0) {
				type = PUB_MCAST;
			} else if (strncasecmp(optarg, "rtp", 3) == 0) {
				type = PUB_RTP;
			}
			break;
		case 'f':
			streamFile = optarg;
			break;
		case 'm':
			mtu = displayToBytes(optarg);
			break;
		case 'e':
			waitToConclude = strTo<uint64_t>(optarg);
			break;
		case 'r':
			if (strcmp(optarg, "max") == 0 || strcmp(optarg, "inf") == 0) {
				fixedBytesPerSecond = (size_t)-1;
			} else {
				fixedBytesPerSecond = displayToBytes(optarg);
			}
			break;
		case 'd':
			duration = atoi((const char*)optarg);
			break;
		case 'o':
			filePrefix = optarg;
			break;
		case 'w':
			waitForSubs = atoi((const char*)optarg);
			break;
		case 'i':
			reportInterval = atoi((const char*)optarg);
			break;
		default:
			printUsageAndExit();
			break;
		}
	}

	if (!isClient && !isServer)
		printUsageAndExit();

	if (fixedBytesPerSecond > 0)
		bytesPerSecond = fixedBytesPerSecond;

	if (mtu < MIN_MTU)
		mtu = MIN_MTU;

	DiscoveryConfigMDNS discConfig;
//	discConfig.setDomain("throughput");
	disc = Discovery(&discConfig);

	Subscriber sub("reports");
	ReportReceiver reportRecv;
	sub.setReceiver(&reportRecv);
	node.addSubscriber(sub);

	if (isServer) {
		runAsServer();
	} else {
		runAsClient();
	}

	if (filePrefix.size() > 0) {
		// wait for missing reports, then make sure no more reports are coming in
		Thread::sleepMs(waitToConclude);
		sub.setReceiver(NULL);

		// write files
		std::map<std::string, std::list<Report> >::iterator reportIter = allReports.begin();
		std::map<std::string, std::ofstream*> fileHandles;

		// open a file per reporter and write header
		while(reportIter != allReports.end()) {
			std::string pubUUID = reportIter->first;
			std::string reportFileName = filePrefix + pubUUID.substr(0,8) + ".data";
			fileHandles[pubUUID] = new std::ofstream();
			fileHandles[pubUUID]->open(reportFileName.c_str(), std::fstream::out);
            Report::writeCSVHead(*fileHandles[pubUUID]);
#ifdef UNIX
			// that's only useful if there is only a single reporter per host
			std::string linkFrom = filePrefix + pubUUID.substr(0,8) + ".data";
			std::string linkTo = filePrefix + reportIter->second.back().hostId + ".host.data";

			unlink(linkTo.c_str());
			symlink(linkFrom.c_str(), linkTo.c_str());
#endif
			reportIter++;
		}

		// write reports
		std::fstream senderReport;
		std::string senderReportFileName = filePrefix + "sender.data";
		senderReport.open(senderReportFileName.c_str(), std::fstream::out);
		senderReport << "\"Payload Compressibility\", \"Bytes Sent\", \"Packets sent\"" << std::endl;

		std::list<Report>::iterator senderRepIter = senderReports.begin();
		while(senderRepIter!= senderReports.end()) {
            senderReport << compressionActualRatio << ", ";
            senderReport << senderRepIter->bytesRcvd << ", ";
			senderReport << senderRepIter->pktsRcvd << std::endl;
			senderRepIter++;

			reportIter = allReports.begin();
			while(reportIter != allReports.end()) {

				if (reportIter->second.size() == 0) {
					// all data consumed - insert missing at end
					*fileHandles[reportIter->first] << "-" << std::endl;
					break;
				}

				if (reportIter->second.front().pertainingPacket > senderRepIter->pertainingPacket) {
					// no data for reporting period!
					*fileHandles[reportIter->first] << "-" << std::endl;
				} else {
					reportIter->second.front().writeCSVData(*fileHandles[reportIter->first]);
					reportIter->second.pop_front();
				}

#if 0
				// discard multiple reports?
				while(reportIter->second.size() > 0 &&
				        reportIter->second.front().pertainingPacket < senderRepIter->pertainingPacket) {
					reportIter->second.pop_front();
				}
#endif
				reportIter++;
			}
		}

		std::map<std::string, std::ofstream*>::iterator fhIter = fileHandles.begin();
		while(fhIter != fileHandles.end()) {
			fhIter->second->close();
			delete(fhIter->second);
			fhIter++;
		}

		senderReport.close();

#if 0
		while(true) {
			reportIter = allReports.begin();
			size_t nextReportingEnd = 4294967295; // 2**32 - 1
			std::string nextReporter;

			// break when we consumed all reports
			if (allReports.size() == 0)
				break;

			while(reportIter != allReports.end()) {
				// walk through the report iterators and find next report due
				size_t nextDueReport = reportIter->second.front().pertainingPacket;
				if (nextDueReport < nextReportingEnd) {
					nextReportingEnd = nextDueReport;
					nextReporter     = reportIter->first;
				}
				reportIter++;
			}
			// ok, write earliest report into earlist's reports file
			Report& nextReport = allReports[nextReporter].front();

			fileHandles[nextReporter] << nextReport.discoveryTime << ", ";
			fileHandles[nextReporter] << nextReport.bytesRcvd << ", ";
			fileHandles[nextReporter] << nextReport.pktsRcvd << ", ";
			fileHandles[nextReporter] << nextReport.pktsLate << ", ";
			fileHandles[nextReporter] << nextReport.roundTripTime << ", ";
			fileHandles[nextReporter] << nextReport.pcntLoss << ", ";
			fileHandles[nextReporter] << nextReport.pktsDropped << ", ";
			fileHandles[nextReporter] << nextReport.hostName << std::endl;

			allReports[nextReporter].pop_front();

			if (allReports[nextReporter].size() == 0) {
				allReports.erase(nextReporter);
			} else {
				// fill with newlines if we skipped reports
				Report& upcomingReport = allReports[nextReporter].front();
				for(int i = 1; nextReport.reportNr + i < upcomingReport.reportNr; i++) {
					fileHandles[nextReporter] << std::endl;
				}
			}
		}

		std::map<std::string, std::fstream>::iterator fhIter = fileHandles.begin();
		while(fhIter != fileHandles.end()) {
			fhIter->second.close();
			fhIter++;
		}

		// write sender reports
		std::fstream senderReport;
		std::string reportFileName = filePrefix + "sender.data";
		senderReport.open(reportFileName.c_str(), std::fstream::out);
		std::list<Report>::iterator senderRepIter = senderReports.begin();
		while(senderRepIter!= senderReports.end()) {
			senderReport << senderRepIter->bytesRcvd << ", ";
			senderReport << senderRepIter->pktsRcvd << std::endl;
			senderRepIter++;
		}
		senderReport.close();
#endif
	}
}
Esempio n. 24
0
		_branch *add(int p) {
			_branch *b = new _branch(p);
			inner.push_back(b);
			return b;
		}
Esempio n. 25
0
// ----------------------------------------------------------------------
// static method - called once for all widgets by the
//                 WidgetEventResponder, which self-
//                 registers to all events upon creation of the first widget.
//
bool ofxWidget::mouseEvent(ofMouseEventArgs& args_) {
	// If we register a mouse down event, we do a hit test over
	// all visible widgets, and re-order if necessary.
	// Then, and in all other cases, we do a hit-test on the 
	// frontmost widget and, if positive, forward the event to this 
	// widget.

	updateVisibleWidgetsList();

	if (sVisibleWidgets.empty()) return false;

	// ---------| invariant: there are some widgets flying around.

	bool eventAttended = false;

	float mx = args_.x;
	float my = args_.y;

	// if we have a mouse down on a widget, we need to check which 
	// widget was hit and potentially re-order widgets.

	// find the first widget that is under the mouse, that is also visible
	// if it is not yet up front, bring it to the front.

	// hit-test only visible widgets - this makes sure to only evaluate 
	// the widgets which are visible, and whose parents are visible, too.
	auto itUnderMouse = std::find_if(sVisibleWidgets.begin(), sVisibleWidgets.end(), [&mx, &my](std::weak_ptr<ofxWidget>& w) ->bool {
		auto p = w.lock();
		if (p && p->mVisible && p->mRect.inside(mx, my)) {
			return true;
		} else {
			return false;
		}
	});

	// if we have a click, we want to make sure the widget gets to be the topmost widget.
	if (args_.type == ofMouseEventArgs::Pressed) {

		// --- now iterate over sAllWidgets instead of just the visible widgets.
		// we need to do this, because otherwise the reorder check won't be safe 
		// as the number of children in sVisibleWidgets is potentially incorrect,
		// as the number of children there refers to all children of a widget,
		// and not just the visible children of the widget.
		auto itPressedWidget = (itUnderMouse == sVisibleWidgets.end() ?
			sAllWidgets.end() :
			findIt(*itUnderMouse, sAllWidgets.begin(), sAllWidgets.end()));

		if (itPressedWidget != sAllWidgets.end()) {
			if (!isSame(*itPressedWidget, sFocusedWidget)) {
				// change in focus detected.
				// first, let the first element know that it is losing focus
				if (auto previousElementInFocus = sFocusedWidget.lock())
					if (previousElementInFocus->onFocusLeave)
						previousElementInFocus->onFocusLeave();

				sFocusedWidget = *itPressedWidget;

				// now that the new wiget is at the front, send an activate callback.
				if (auto nextFocusedWidget = sFocusedWidget.lock())
					if (nextFocusedWidget->onFocusEnter)
						nextFocusedWidget->onFocusEnter();
			}
			bringToFront(itPressedWidget); // reorder widgets
		} else {
			// hit test was not successful, no wigets found.
			if (auto previousElementInFocus = sFocusedWidget.lock())
				if (previousElementInFocus->onFocusLeave)
					previousElementInFocus->onFocusLeave();

			sFocusedWidget.reset(); // no widget gets the focus, then.
		}
	} // end if (args_.type == ofMouseEventArgs::Pressed)

	// now, we will attempt to send the mouse event to the widget that 
	// is in focus.

	if (itUnderMouse != sVisibleWidgets.end()) {
			// a widget is under the mouse.
			// is it the same as the current widget under the mouse?
		if (!isSame(*itUnderMouse, sWidgetUnderMouse)) {
			if (auto nU = itUnderMouse->lock())
			{
				// there is a new widget under the mouse
				if (auto w = sWidgetUnderMouse.lock()) {
					// there was an old widget under the mouse
					if (w->onMouseLeave)
						w->onMouseLeave();
					w->mHover = false;
				}
				if (nU->onMouseEnter)
					nU->onMouseEnter();
				nU->mHover = true;
				sWidgetUnderMouse = *itUnderMouse;
			}
		}
	} else {
		if (auto w = sWidgetUnderMouse.lock()) {
			// there was a widget under mouse,
			// but now there is none.
			if (w->onMouseLeave)
				w->onMouseLeave();
			w->mHover = false;
			sWidgetUnderMouse.reset();
		}
	}

	if (auto w = sFocusedWidget.lock()) {
		if (w->onMouse) {
			w->onMouse(args_);
			eventAttended = true;
		}
	}

	// store last mouse position last thing, so that 
	// we are able to calculate a difference.
	sLastMousePos.set(mx, my);
	return eventAttended;
}
Esempio n. 26
0
 void FilterTargets(std::list<WorldObject*>& targets)
 {
     targets.remove(GetExplTargetUnit());
 }
Esempio n. 27
0
const bool ofxWidget::isActivated() const {
	return (sAllWidgets.empty()) ? false : isSame(mThis, sFocusedWidget);
}
Esempio n. 28
0
int countValueIdentities(const std::list<ValueIdentity>& values)
{
    return values.size();
}
Esempio n. 29
0
 void JustSummoned(Creature* pSummon)
 {
     SummonList.push_back(pSummon->GetGUID());
 }
Esempio n. 30
0
 coverage_generator(Syn const* rule, std::list<sbmt::span_string> const& lst, Constituents rng, bool toplevel, sbmt::span_t total)
  : rule(rule), itr(lst.begin()), end(lst.end()), rng(boost::begin(rng),boost::end(rng)), toplevel(toplevel), total(total) 
 {
     pop();
 }