bool Entity::attack(){ if (Victim == NULL) return false; // Don't attack dead or hurt people if (Victim->Action == CHAR_DIE || Victim->Action == CHAR_HURT) return false; // Set attacker and victim Victim->Attacker = this; this->Victim = Victim; notify(*this, EVENT_ATTACK); // Return if hit missed if ((rand() % 1000) > getToHit(Victim)) { std::string miss_msg = getEntityType().c_str() + std::string(" missed!"); log_message->setString(miss_msg); log_message->setColor(sf::Color::Yellow); addMessage(miss_msg.c_str(), 1000, sf::Color::Yellow); return false; } // Return if hit dodged if ((rand() % 1000) <= getAgility(Victim)) { std::string dodge_msg = getEntityType().c_str() + std::string(" dodged!"); log_message->setString(dodge_msg); log_message->setColor(sf::Color::Yellow); addMessage(dodge_msg.c_str(), 1000, sf::Color::Yellow); return false; } // If this is asleep, randomly wake them up (50% chance) if (Victim->Ailments & AILMENT_SLEEP) { if ((rand() % 100) < 50) Victim->Ailments &= ~AILMENT_SLEEP; } // Attack landed, apply damage damage(Victim, true, getAttack(this), -1, -1); return true; }
float Archer::getCollisionPriority(Entity* e) const { if (e->getEntityType() == getEntityType()) { return -0.4f; } return 1.f; }
bool operator<( FullID const& rhs ) const { // first look at the EntityType if( getEntityType() != rhs.getEntityType() ) { return getEntityType() < rhs.getEntityType(); } // then compare the SystemPaths // FIXME: should be faster is there is SystemPath::compare() if( getSystemPath() != rhs.getSystemPath() ) { return getSystemPath() < rhs.getSystemPath(); } // finally compare the ID strings return getID() < rhs.getID(); }
bool operator==( FullID const& rhs ) const { // first look at the EntityType if( getEntityType() != rhs.getEntityType() ) { return false; } // then compare the SystemPaths if( getSystemPath() != rhs.getSystemPath() ) { return false; } // finally compare the ID strings return getID() == rhs.getID(); }
Atlas::Message::MapType EntityRecipe::createEntity(Eris::TypeService& typeService) { S_LOG_VERBOSE("Creating entity."); ScriptingService& scriptingService = EmberServices::getSingleton().getScriptingService(); // Loading script code scriptingService.executeCode(mScript, "LuaScriptingProvider"); // Walking through adapter bindings for (BindingsStore::iterator I = mBindings.begin(); I != mBindings.end(); ++I) { const std::string& func = I->second->getFunc(); S_LOG_VERBOSE(" binding: " << I->first << " to func " << func); if (func.empty()) { std::vector<std::string>& adapters = I->second->getAdapters(); if (adapters.size() == 1) { std::string adapterName = adapters[0]; Atlas::Message::Element val = mGUIAdapters[adapterName]->getValue(); I->second->setValue(val); } else { S_LOG_WARNING("Should be only one adapter without calling function."); } } else { Lua::LuaScriptingCallContext callContext; lua_State* L = static_cast<Lua::LuaScriptingProvider*> (scriptingService.getProviderFor("LuaScriptingProvider"))->getLuaState(); // Pushing function params std::vector<std::string>& adapters = I->second->getAdapters(); for (std::vector<std::string>::iterator J = adapters.begin(); J != adapters.end(); J++) { std::string adapterName = *J; Atlas::Message::Element* val = new Atlas::Message::Element(mGUIAdapters[adapterName]->getValue()); tolua_pushusertype_and_takeownership(L, val, "Atlas::Message::Element"); } // Calling test function scriptingService.callFunction(func, adapters.size(), "LuaScriptingProvider", &callContext); LuaRef returnValue(callContext.getReturnValue()); Atlas::Message::Element returnObj; returnObj = returnValue.asObject<Atlas::Message::Element> ("Atlas::Message::Element"); I->second->setValue(returnObj); } } //Inject all default attributes that aren't yet added. // TiXmlElement *elem = mEntitySpec->FirstChildElement("atlas"); // if (elem) // { // Eris::TypeInfo* erisType = mConn->getTypeService()->getTypeByName(getEntityType()); // if (erisType) { // const Atlas::Message::MapType& defaultAttributes = erisType->getAttributes(); // for (Atlas::Message::MapType::const_iterator I = defaultAttributes.begin(); I != defaultAttributes.end(); ++I) { // bool hasAttribute = false; // TiXmlNode* child(0); // while(child = elem->IterateChildren(child)) { // if (child->ToElement()) { // if (std::string(child->ToElement()->Attribute("name")) == I->first) { // hasAttribute = true; // break; // } // } // } // // if (!hasAttribute) { // //The attribute isn't present, we'll inject it // //This a bit contrived, since we'll now first convert the atlas into xml and inject it into the TiXmlElement (which will convert the xml strings into TiXml structures). And then later on we'll parse the xml again and create the final atlas data from it. However, the main reason for doing it this way is that in the future we would want to have nested child elements, which could be repeated. And in those cases we'll want to work directly with xml. // } // } // } // } /* std::stringstream str; Atlas::Message::Element element(message); Atlas::Message::QueuedDecoder decoder; Atlas::Codecs::XML codec(str, decoder); Atlas::Formatter formatter(str, codec); Atlas::Message::Encoder encoder(formatter); formatter.streamBegin(); encoder.streamMessageElement(message); formatter.streamEnd(); */ if (mEntitySpec) { // Print entity into string TiXmlPrinter printer; printer.SetStreamPrinting(); mEntitySpec->Accept(&printer); S_LOG_VERBOSE("Composed entity: " << printer.Str()); std::stringstream strStream(printer.CStr(), std::ios::in); // Create objects Atlas::Message::QueuedDecoder decoder; Atlas::Codecs::XML codec(strStream, decoder); // Read whole stream into decoder queue while (!strStream.eof()) { codec.poll(); } // Read decoder queue while (decoder.queueSize() > 0) { Atlas::Message::MapType m = decoder.popMessage(); Eris::TypeInfo* erisType = typeService.getTypeByName(getEntityType()); if (erisType) { const Atlas::Message::MapType& defaultAttributes = erisType->getAttributes(); for (Atlas::Message::MapType::const_iterator I = defaultAttributes.begin(); I != defaultAttributes.end(); ++I) { if (m.find(I->first) == m.end()) { m.insert(Atlas::Message::MapType::value_type(I->first, I->second)); } } } return m; } } else { Atlas::Message::MapType msg; msg["parents"] = Atlas::Message::ListType(1, mEntityType); msg["name"] = getName(); return msg; } S_LOG_WARNING("No entity composed"); return Atlas::Message::MapType(); }
bool Entity::damage(Entity *Victim, bool PhysicalAttack, long Amount, long DmgClass, long CureClass){ char Text[128]; float Resist; float Range; long DmgAmount; // Error checking if (Victim == NULL) return false; // Can't attack if already dead or being hurt (or not enabled) if ( Victim->Action == CHAR_DIE || Victim->Action == CHAR_HURT) return false; // Adjust for definition if physical attack if (PhysicalAttack == true) { // Random value for less/more damage (-+20%) Range = (float)((rand() % 20) + 90) / 100.0f; DmgAmount = (long)((float)Amount * Range); // Subtract for defense of victim (allow -20% difference) Range = (float)((rand() % 20) + 80) / 100.0f; DmgAmount -= (long)((float)getDefense(Victim) * Range); } else { // Adjust for magical attack Resist = 1.0f - ((float)getResistance(Victim) / 100.0f); DmgAmount = (long)((float)Amount * Resist); } // Bounds check value if (DmgAmount < 0) DmgAmount = 0; // Check for double damage if (Victim->definition.Class == DmgClass) DmgAmount *= 2; // Check for cure damage if (Victim->definition.Class == CureClass) DmgAmount = -(labs(DmgAmount) / 2); // If no physical damage is dealt then randomly deal // 10-20% of damage from the original amount. if (!DmgAmount && PhysicalAttack == true) { Range = (float)((rand() % 10) + 10) / 100.0f; DmgAmount = (long)((float)Amount * Range); } // Subtract damage amount Victim->current_health -= DmgAmount; // Set hurt status and display message if (DmgAmount > 0) { sprintf_s(Text, "-%lu HP", DmgAmount); std::string msg = Victim->getEntityType() + " loss " + std::to_string(DmgAmount) + " HP"; log_message->setString(msg); log_message->setColor(sf::Color::Red); Victim->addMessage(Text, 1000, sf::Color::Red); // Only set hurt if any damage (and idle or moving) if (DmgAmount) { if (Victim->Action == CHAR_MOVE || Victim->Action == CHAR_IDLE) setAction( CHAR_HURT); notify(*Victim, EVENT_HURT); } } // Display cure amount if (DmgAmount < 0) { sprintf_s(Text, "+%lu HP", -DmgAmount); std::string msg = getEntityType() + " gained " + std::to_string(DmgAmount) + " HP" ; log_message->setString(msg); log_message->setColor(sf::Color::Green); addMessage(Text, 1000, sf::Color::Green); } return true; }
FullID Entity::getFullID() const { return FullID( getEntityType(), getSystemPath(), getID() ); }
int StreamStore::getInformation(std::shared_ptr<InformationSpecification> request, std::vector<std::shared_ptr<InformationElement<GContainer>>> &outInfo, bool useTransfromation) { int count = 0; for (auto &stream : this->collections) { auto gstream = std::static_pointer_cast<InformationStream<GContainer>>(stream); auto infoSpec = stream->getDescription()->getInformationSpecification(); if (request->getEntity() != "*" && request->getEntity() != infoSpec->getEntity()) { continue; } if (request->getEntityType() != infoSpec->getEntityType()) { continue; } if (request->getScope() != infoSpec->getScope()) { continue; } if (request->getRepresentation() != infoSpec->getRepresentation()) { if (useTransfromation && request->getRelatedEntity() == "" && infoSpec->getRelatedEntity() == "") { // check if transformation exists auto rep = this->gcontainerFactory->getTransformation(infoSpec->getRepresentation(), request->getRepresentation()); if (rep == nullptr) continue; std::shared_ptr<GContainer> input[1]; input[0] = gstream->getLast()->getInformation(); auto transInfo = rep->transform(input); if (transInfo == nullptr) continue; auto spec = std::make_shared<InformationSpecification>(infoSpec->getEntity(), infoSpec->getEntityType(), infoSpec->getScope(), request->getRepresentation(), infoSpec->getRelatedEntity()); auto element = std::make_shared<InformationElement<GContainer>>(spec, transInfo); outInfo.push_back(element); ++count; } continue; } if (request->getRelatedEntity() != infoSpec->getRelatedEntity()) { continue; } outInfo.push_back(gstream->getLast()); ++count; } return count; }