void MockPlugin::onActivate(const char* val)
{
TEST_ONACTIVATE++;
super_type::onActivate(val);
registerObserver("status");
registerObserver("subnode.*");
}
bool DroidObjectImplementation::sendConversationStartTo(SceneObject* player) {
if (!player->isPlayerCreature() || isDead())
return false;
if (player != getLinkedCreature().get())
return false;
BaseDroidModuleComponent* m = getModule("personality_chip");
if (m == NULL) {
return false;
}
DroidPersonalityModuleDataComponent* personality = dynamic_cast<DroidPersonalityModuleDataComponent*>(m);
if (personality == NULL) {
return false;
}
if (personality->getPersonalityConversationTemplate() == 0) {
return false;
}
//Face player.
faceObject(player);
PatrolPoint current(coordinates.getPosition(), getParent().get());
broadcastNextPositionUpdate(¤t);
CreatureObject* playerCreature = cast<CreatureObject*>( player);
StartNpcConversation* conv = new StartNpcConversation(playerCreature, getObjectID(), "");
player->sendMessage(conv);
SortedVector<ManagedReference<Observer*> > observers = getObservers(ObserverEventType::STARTCONVERSATION);
for (int i = 0; i < observers.size(); ++i) {
if (dynamic_cast<ConversationObserver*>(observers.get(i).get()) != NULL) {
return true;
}
}
//Create conversation observer.
ConversationObserver* conversationObserver = ConversationManager::instance()->getConversationObserver(personality->getPersonalityConversationTemplate());
if (conversationObserver != NULL) {
//Register observers.
registerObserver(ObserverEventType::CONVERSE, conversationObserver);
registerObserver(ObserverEventType::STARTCONVERSATION, conversationObserver);
registerObserver(ObserverEventType::SELECTCONVERSATION, conversationObserver);
registerObserver(ObserverEventType::STOPCONVERSATION, conversationObserver);
} else {
error("Could not create conversation observer.");
return false;
}
return true;
}
void ThreatMap::addDamage(CreatureObject* target, uint32 damage, String xp) {
Locker locker(&lockMutex);
ManagedReference<TangibleObject*> strongSelf = self.get();
if (strongSelf == NULL || strongSelf.get() == target)
return;
int idx = find(target);
String xpToAward = "";
if (xp == "") {
WeaponObject* weapon = target->getWeapon();
xpToAward = weapon->getXpType();
} else
xpToAward = xp;
if (idx == -1) {
ThreatMapEntry entry;
entry.addDamage(xpToAward, damage);
entry.addAggro(1);
put(target, entry);
registerObserver(target);
} else {
ThreatMapEntry* entry = &elementAt(idx).getValue();
entry->addDamage(xpToAward, damage);
entry->addAggro(1);
}
}
void ThreatMap::addAggro(CreatureObject* target, int value, uint64 duration) {
Locker locker(&lockMutex);
ManagedReference<TangibleObject*> strongSelf = self.get();
if (strongSelf == NULL || strongSelf.get() == target)
return;
int idx = find(target);
if (idx == -1) {
ThreatMapEntry entry;
entry.addAggro(value);
put(target, entry);
registerObserver(target);
} else {
ThreatMapEntry* entry = &elementAt(idx).getValue();
entry->addAggro(value);
}
if(duration > 0) {
Reference<RemoveAggroTask*> removeAggroTask = new RemoveAggroTask(self.get(), target, value);
removeAggroTask->schedule(duration);
}
}
string RepositoryXL::storeObject(
const string &objectIDRaw,
const shared_ptr<Object> &object,
bool overwrite,
boost::shared_ptr<ValueObject> valueObject) {
shared_ptr<CallingRange> callingRange = getCallingRange();
string objectID = callingRange->initializeID(objectIDRaw);
if (objectIDRaw.empty() && valueObject)
valueObject->setProperty("OBJECTID", objectID);
shared_ptr<ObjectWrapperXL> objectWrapperXL;
ObjectMap::const_iterator result = objectMap_.find(objectID);
if (result == objectMap_.end()) {
objectWrapperXL = shared_ptr<ObjectWrapperXL> (
new ObjectWrapperXL(objectID, object, callingRange));
objectMap_[objectID] = objectWrapperXL;
callingRange->registerObject(objectID, objectWrapperXL);
} else {
objectWrapperXL = boost::static_pointer_cast<ObjectWrapperXL>(result->second);
if (objectWrapperXL->callerKey() != callingRange->key()) {
OH_REQUIRE(overwrite, "Cannot create object with ID '" << objectID <<
"' in cell " << callingRange->addressString() <<
" because an object with that ID already resides in cell " <<
objectWrapperXL->callerAddress());
objectWrapperXL->resetCaller(callingRange);
callingRange->registerObject(objectID, objectWrapperXL);
}
objectWrapperXL->reset(object);
}
registerObserver(objectWrapperXL);
return objectWrapperXL->idFull();
}
void ThreatMap::addDamage(CreatureObject* target, uint32 damage, String xp) {
Locker locker(&lockMutex);
int idx = find(target);
String xpToAward = "";
if (xp == "") {
WeaponObject* weapon = target->getWeapon();
xpToAward = weapon->getXpType();
} else
xpToAward = xp;
if (idx == -1) {
ThreatMapEntry entry;
entry.addDamage(xpToAward, damage);
entry.addAggro(1);
put(target, entry);
registerObserver(target);
} else {
ThreatMapEntry* entry = &elementAt(idx).getValue();
entry->addDamage(xpToAward, damage);
entry->addAggro(1);
}
// randomly change target everytime threatmap is added to, TODO: keep this in mind and perhaps make it slightly more complicated
if (System::random(5) == 0)
currentThreat = target;
}
// hostDiv - the div where the trace data should be displayed
// showTrace - indicates whether the trace should be shown by default (true) or whether the host will control
// when it is shown
processedTraceStream::processedTraceStream(properties::iterator props, std::string hostDiv, bool showTrace) :
traceStream(props.next(), hostDiv, showTrace)
{
// Initialize the directories this processedTraceStream will use for its temporary storage
static bool initialized=false;
if(!initialized) {
// Create the directory that holds the trace-specific scripts
std::pair<std::string, std::string> dirs = dbg.createWidgetDir("procTS");
workDir = dirs.first;
maxFileID = 0;
}
queue = new traceObserverQueue();
// Add this trace object as a change listener to all the context variables
long numCmds = properties::getInt(props, "numCmds");
for(long i=0; i<numCmds; i++) {
commandProcessors.push_back(new externalTraceProcessor_File(props.get(txt()<<"cmd"<<i), txt()<<workDir<<"/in"<<(maxFileID++)));
queue->push_back(commandProcessors.back());
}
// The final observer in the queue is the original traceStream, which accepts the observations and sends
// them to be visualized
queue->push_back(this);
// Route all of this traceStream's observations through queue
registerObserver(queue);
}
IpccImpl::IpccImpl(
lmp::DWORD localCCId,
node::NodeApplicationIF& node,
NetworkIFSocketIF& networkIFSocket,
boost::asio::io_context& io_context,
const boost::asio::ip::udp::endpoint& remote_endpoint,
bool isActiveSetup)
: m_localCCId(localCCId),
m_node(node),
m_networkIFSocket(networkIFSocket),
m_io_context(io_context),
m_remote_endpoint(remote_endpoint),
m_remoteNodeId(0),
m_remoteCCId(0),
m_isActiveSetup(isActiveSetup),
m_FSM(*this),
m_helloInterval(std::chrono::milliseconds(150)),
m_helloDeadInterval(std::chrono::milliseconds(500)),
m_configSend_timer(m_io_context,
std::chrono::milliseconds(500),
3,
1,
boost::function<bool (bool)>(
boost::bind(&IpccImpl::evtConfRet,
this,
_1))),
m_hello_timer(m_io_context,
m_helloInterval,
boost::function<bool (void)>(
boost::bind(&IpccImpl::evtHelloRet,
this))),
m_helloDead_timer(m_io_context,
m_helloDeadInterval,
boost::function<bool (void)>(
boost::bind(&IpccImpl::evtHoldTimer,
this))),
m_goingDown_timer(m_io_context,
m_helloDeadInterval,
boost::function<bool (void)>(
boost::bind(&IpccImpl::evtDownTimer,
this))),
m_TxSeqNum(0),
m_RcvSeqNum(0),
m_Observers(),
m_neighborAdjacencyObservers(),
m_fsm_mutex(),
m_messageId(0),
m_configMsg()
{
std::cout << "Node(" << m_node.getNodeId() << ").IPCC(localCCId = " << getLocalCCId()
<< ", remoteAddress = " << m_remote_endpoint.address().to_v4().to_ulong()
<< ", remotePortNumber = " << m_remote_endpoint.port() << ") ctor" << std::endl;
{
boost::unique_lock<boost::shared_mutex> guard(m_fsm_mutex);
m_FSM.start();
}
registerObserver(m_node);
}
void ThreatMap::addHeal(CreatureObject* target, int value) {
Locker locker(&lockMutex);
int idx = find(target);
if (idx == -1) {
ThreatMapEntry entry;
entry.addHeal(value);
entry.addAggro(2);
put(target, entry);
registerObserver(target);
} else {
ThreatMapEntry* entry = &elementAt(idx).getValue();
entry->addHeal(value);
entry->addAggro(2);
}
}
// Places the given set of traceObservers immediately after this observer and before all of the observers that watch it
void traceObserver::prependObservers(const std::set<traceObserver*>& newObservers) {
// Back up the original set of observers and remove them
map<traceObserver*, int> origObservers = observers;
while(observers.size()>0) {
// newObservers and origObservers must be disjoint
assert(newObservers.find(observers.begin()->first) == newObservers.end());
unregisterObserver(observers.begin()->first);
}
// Add each new observer to this observer
for(set<traceObserver*>::const_iterator n=newObservers.begin(); n!=newObservers.end(); n++) {
registerObserver(*n);
// And add all of the original observers to watch this current new observer
for(map<traceObserver*, int>::iterator o=origObservers.begin(); o!=origObservers.end(); o++)
(*n)->registerObserver(o->first);
}
}
void ThreatMap::addHeal(CreatureObject* target, int value) {
Locker locker(&lockMutex);
ManagedReference<TangibleObject*> strongSelf = self.get();
if (strongSelf == NULL || strongSelf.get() == target)
return;
int idx = find(target);
if (idx == -1) {
ThreatMapEntry entry;
entry.addHeal(value);
entry.addAggro(1);
put(target, entry);
registerObserver(target);
} else {
ThreatMapEntry* entry = &elementAt(idx).getValue();
entry->addHeal(value);
entry->addAggro(1);
}
}
bool ThreatMap::setThreatState(CreatureObject* target, uint64 state, uint64 duration, uint64 cooldown) {
Locker locker(&lockMutex);
if((hasState(state) && isUniqueState(state))
|| !cooldownTimerMap.isPast(String::valueOf(state)))
return false;
int idx = find(target);
if (idx == -1) {
ThreatMapEntry entry;
entry.setThreatState(state);
put(target, entry);
registerObserver(target);
} else {
ThreatMapEntry* entry = &elementAt(idx).getValue();
entry->setThreatState(state);
}
if(duration > 0) {
Reference<ClearThreatStateTask*> clearThreat = new ClearThreatStateTask(self.get(), target, state);
clearThreat->schedule(duration);
}
if(cooldown > 0) {
cooldownTimerMap.updateToCurrentAndAddMili(String::valueOf(state), duration + cooldown);
}
if(isUniqueState(state)) {
cooldownTimerMap.updateToCurrentTime("doEvaluation");
}
#ifdef DEBUG
System::out << "Setting threat state on " << target->getObjectID() << ": " << state << endl;
#endif
return true;
}
void MLC_SerialTargetPlugin::onActivate(const char * val)
{
super_type::onActivate(val);
registerObserver("");
}
bool CANController::registerObserver(CANObserver *observer)
{
return registerObserver(observer, 0, 0);
}
/*! Register an observer which gets notified of changed key/value
* pairs.
* \deprecated Obsolete coding style.
*/
void ConfigManager::RegisterObserver(ConfigObserver *observer, const String &key)
{
registerObserver(observer, key);
}
// hostDiv - the div where the trace data should be displayed
// showTrace - indicates whether the trace should be shown by default (true) or whether the host will control
// when it is shown
traceStream::traceStream(properties::iterator props, std::string hostDiv, bool showTrace) :
hostDiv(hostDiv), showTrace(showTrace)
{
static bool initialized = false;
if(!initialized) {
// Create the directory that holds the trace-specific scripts
dbg.createWidgetDir("trace");
pair<string, string> paths = dbg.createWidgetDir("trace");
outDir = paths.first;
htmlOutDir = paths.second;
// Table/Lines visualization
//dbg.includeScript("https://www.google.com/jsapi", "text/javascript");
//dbg.includeScript("http://yui.yahooapis.com/3.11.0/build/yui/yui-min.js", "text/javascript");
dbg.includeWidgetScript("yui-min.js", "text/javascript"); dbg.includeFile("yui-min.js");
// JQuery must be loaded before prototype.js. Because we don't have a clean way to guaranteed this, we'll load jquery in sight_layout.C
//dbg.includeWidgetScript("jquery-1.8.1.min.js", "text/javascript"); dbg.includeFile("jquery-1.8.1.min.js");
dbg.includeWidgetScript("underscore-min.js", "text/javascript"); dbg.includeFile("underscore-min.js");
// Three.js
dbg.includeWidgetScript("Three.js", "text/javascript"); dbg.includeFile("Three.js");
dbg.includeWidgetScript("Detector.js", "text/javascript"); dbg.includeFile("Detector.js");
dbg.includeWidgetScript("OrbitControls.js", "text/javascript"); dbg.includeFile("OrbitControls.js");
dbg.includeWidgetScript("THREEx.WindowResize.js", "text/javascript"); dbg.includeFile("THREEx.WindowResize.js");
dbg.createWidgetDir("THREE/src/materials");
dbg.includeWidgetScript("THREE/src/materials/ShaderMaterial.js", "text/javascript");
dbg.includeFile("THREE/src/materials/ShaderMaterial.js");
dbg.createWidgetDir("THREE/src/extras");
dbg.includeWidgetScript("THREE/src/extras/ImageUtils.js", "text/javascript");
dbg.includeFile("THREE/src/extras/ImageUtils.js");
//dbg.includeWidgetScript("Stats.js", "text/javascript"); dbg.includeFile("Stats.js");
// JQuery
dbg.includeWidgetScript("jquery-1.9.1.min.js", "text/javascript"); dbg.includeFile("jquery-1.9.1.min.js");
dbg.includeWidgetScript("jquery-ui.js", "text/javascript"); dbg.includeFile("jquery-ui.js");
dbg.includeWidgetScript("jquery-ui.css", "text/css"); dbg.includeFile("jquery-ui.css");
// D3 Widgets
dbg.includeWidgetScript("d3.v3.min.js", "text/javascript"); dbg.includeFile("d3.v3.min.js");
//dbg.includeWidgetScript("d3.v3.js", "text/javascript"); dbg.includeFile("d3.v3.js");
dbg.includeWidgetScript("trace/table.js", "text/javascript"); dbg.includeFile("trace/table.js");
dbg.includeWidgetScript("trace/boxplot.js", "text/javascript"); dbg.includeFile("trace/boxplot.js");
dbg.includeWidgetScript("trace/gradient.js", "text/javascript"); dbg.includeFile("trace/gradient.js");
dbg.includeWidgetScript("trace/scatter.js", "text/javascript"); dbg.includeFile("trace/scatter.js");
dbg.includeWidgetScript("trace/scatter3d.js", "text/javascript"); dbg.includeFile("trace/scatter3d.js");
// Decision Trees
//dbg.includeWidgetScript("ID3-Decision-Tree/js/id3.js", "text/javascript");
//dbg.includeScript("https://www.google.com/jsapi?autoload={\"modules\":[{\"name\":\"visualization\",\"version\":\"1\",\"packages\":[\"orgchart\"]}]}", "text/javascript");
//dbg.includeFile("ID3-Decision-Tree");
dbg.includeWidgetScript("trace/ID3/id3.js", "text/javascript");
dbg.includeWidgetScript("trace/ID3/dndTree.js", "text/javascript");
dbg.includeWidgetScript("trace/ID3/dndTree.css", "text/css");
dbg.includeFile("trace/ID3");
dbg.includeWidgetScript("trace/trace.js", "text/javascript"); dbg.includeFile("trace/trace.js");
initialized = true;
}
traceID = properties::getInt(props, "traceID");
viz = (vizT)properties::getInt(props, "viz");
//cout << "ts::ts this="<<this<<" props="<<props.str()<<endl<<"viz="<<viz<<endl;
// Add this trace object as a change listener to all the context variables
long numCtxtAttrs = properties::getInt(props, "numCtxtAttrs");
if(numCtxtAttrs > 0) {
for(long i=0; i<numCtxtAttrs; i++) {
string ctxtName = properties::get(props, txt()<<"ctxtAttr_"<<i);
contextAttrs.push_back(ctxtName);
// Context attributes cannot be repeated
assert(contextAttrsSet.find(ctxtName) == contextAttrsSet.end());
contextAttrsSet.insert(ctxtName);
//attributes.addObs(properties::get(props, txt()<<"ctxtAttr_"<<i), this);
}
contextAttrsInitialized = true;
} else
contextAttrsInitialized = false;
//traceAttrsInitialized = false;
registerObserver(new traceFileWriterTSV(txt()<<outDir<<"/data_individual/"<<
"trace_"<<traceID<<".tsv"));
active[traceID] = this;
}
