void GuardedMemory::print_on(outputStream* st) const {
if (_base_addr == NULL) {
st->print_cr("GuardedMemory(" PTR_FORMAT ") not associated to any memory", p2i(this));
return;
}
st->print_cr("GuardedMemory(" PTR_FORMAT ") base_addr=" PTR_FORMAT
" tag=" PTR_FORMAT " user_size=" SIZE_FORMAT " user_data=" PTR_FORMAT,
p2i(this), p2i(_base_addr), p2i(get_tag()), get_user_size(), p2i(get_user_ptr()));
Guard* guard = get_head_guard();
st->print_cr(" Header guard @" PTR_FORMAT " is %s", p2i(guard), (guard->verify() ? "OK" : "BROKEN"));
guard = get_tail_guard();
st->print_cr(" Trailer guard @" PTR_FORMAT " is %s", p2i(guard), (guard->verify() ? "OK" : "BROKEN"));
u_char udata = *get_user_ptr();
switch (udata) {
case uninitBlockPad:
st->print_cr(" User data appears unused");
break;
case freeBlockPad:
st->print_cr(" User data appears to have been freed");
break;
default:
st->print_cr(" User data appears to be in use");
break;
}
}
void mainloop()
{
setup();
for (; is_run(); delay_fps(60))
{
cleardevice();
while (kbhit())
{
int key = getch();
if (key == 'a')
guard.moveLeft();
else if (key == 'd')
guard.moveRight();
}
while (mousemsg())
{
mouse_msg mouse = getmouse();
if (mouse.is_move())
{
guard.set_position(mouse.x);
}
}
updateStatus();
updateScene();
}
}
list<vector<Element> > Guard::getAssymetry (Variable *v) {
EnsureUnicity();
list<vector<Element> > lcall ;
list<vector<Element> > lcallres;
list<Guard *>::iterator it;
list<Guard *> &l = this->FindPredOnVar (*v);
if (! l.empty() ) {
Guard * g = CanonizePredTree (this,v);
l = g->FindPredOnVar (*v);
for (it = l.begin();it != l.end() ; it++ )
lcall.push_back( (*it) -> set);
}
lcall.push_back(v->PClass()->Elts());
lcallres = calcSub::uniquePartition (lcall);
// for (it = l.begin();it != l.end() ; it++ )
// (*it)->RewritePredWithPart (lcallres);
// cerr << endl << "Get Assymetry over variable " << *v << " for guard g=" << *this << endl;
// calcSub::print(cerr,lcallres);
return lcallres;
}
static int
guard_gc (lua_State *L)
{
Guard *guard = lua_touserdata (L, 1);
if (guard->data != NULL)
guard->destroy (guard->data);
return 0;
}
//---------------------------------------------------------------------
// reload the config
size_t Server::loadServers() {
Guard guard;
if (guard.isLoaded()) {
serverInfos.clear();
guard.mapper->import_putty_sessions(serverInfos);
}
return serverInfos.size();
}
bool
Routing_Slip_Queue::dispatch_one (Guard & guard)
{
bool ok = false;
Routing_Slip_Ptr routing_slip;
if (this->queue_.dequeue_head (routing_slip) == 0)
{
++this->active_;
guard.release ();
routing_slip->at_front_of_persist_queue ();
guard.acquire ();
}
return ok;
}
void ProcessVariable::unsubscribe(Guard &guard)
{
guard.check(__FILE__, __LINE__, mutex);
// See comments in stop(): this->id is already 0, state==INIT.
if (isSubscribed(guard))
{
#ifdef CHECK_EVID
void *user = peek_evid_userptr(ev_id);
LOG_ASSERT(user == this);
#endif
evid _ev_id = ev_id;
ev_id = 0;
GuardRelease release(__FILE__, __LINE__, guard);
{
Guard ctx_guard(__FILE__, __LINE__, ctx);
LOG_ASSERT(ctx.isAttached(ctx_guard));
}
try
{
ca_clear_subscription(_ev_id);
}
catch (std::exception &e)
{
LOG_MSG("ProcessVariable::unsubscribe(%s): %s\n",
getName().c_str(), e.what());
}
catch (...)
{
LOG_MSG("ProcessVariable::unsubscribe(%s): Unknown Exception\n",
getName().c_str());
}
}
}
void ProcessVariable::getValue(Guard &guard)
{
guard.check(__FILE__, __LINE__, mutex);
if (state != CONNECTED)
return; // Can't get
++outstanding_gets;
chid _id = id;
GuardRelease release(__FILE__, __LINE__, guard); // Unlock while in CAC.
{
int status;
try
{
status = ca_array_get_callback(dbr_type, dbr_count,
_id, value_callback, this);
}
catch (std::exception &e)
{
LOG_MSG("ProcessVariable::getValue(%s): %s\n",
getName().c_str(), e.what());
}
catch (...)
{
LOG_MSG("ProcessVariable::getValue(%s): Unknown Exception\n",
getName().c_str());
}
if (status != ECA_NORMAL)
{
LOG_MSG("%s: ca_array_get_callback failed: %s\n",
getName().c_str(), ca_message(status));
return;
}
Guard ctx_guard(__FILE__, __LINE__, ctx);
ctx.requestFlush(ctx_guard);
}
}
int main() {
Player player;
Witch witch;
witch.setName("Lucia");
Guard guard;
guard.setName("Sam");
std::cout << "|Player walks around the town and talks with some npcs" << std::endl;
witch.interact(&player);
guard.interact(&player);
std::cout << "|Player goes on a great adventure!" << std::endl;
std::cout << "|but gets beaten up by some foes..." << std::endl;
player.setHp(player.getHp() - 5);
std::cout << "|Back to the town... Let's talk to the witch" << std::endl;
witch.interact(&player);
}
void updateScene()
{
for (int i = 0; i < WINDOW_WIDTH; i++)
for (int j = 0; j < WINDOW_HEIGHT; j++)
if (pixelType[i][j] != 0)
putpixel(i, j, pixelColor[i][j]);
guard.draw();
}
void GroupInfo::addChannel(Guard &group_guard, ArchiveChannel *channel)
{
group_guard.check(__FILE__, __LINE__, mutex);
// Is Channel already in group?
stdList<ArchiveChannel *>::iterator i;
for (i=channels.begin(); i!=channels.end(); ++i)
if (*i == channel)
return;
channels.push_back(channel);
}
// called by ArchiveChannel
void GroupInfo::decConnected(Guard &group_guard, ArchiveChannel &pv)
{
group_guard.check(__FILE__, __LINE__, mutex);
if (num_connected <= 0)
throw GenericException(__FILE__, __LINE__,
"Group %s connect count runs below 0 "
"on decrement from '%s'",
getName().c_str(), pv.getName().c_str());
--num_connected;
}
/*! \internal
\a n is in the signal index range (see QObjectPrivate::signalIndex()).
*/
void QQmlJavaScriptExpression::GuardCapture::captureProperty(QObject *o, int c, int n)
{
if (watcher->wasDeleted())
return;
Q_ASSERT(expression);
if (n == -1) {
if (!errorString) {
errorString = new QStringList;
QString preamble = QLatin1String("QQmlExpression: Expression ") +
expression->m_vtable->expressionIdentifier(expression) +
QLatin1String(" depends on non-NOTIFYable properties:");
errorString->append(preamble);
}
const QMetaObject *metaObj = o->metaObject();
QMetaProperty metaProp = metaObj->property(c);
QString error = QLatin1String(" ") +
QString::fromUtf8(metaObj->className()) +
QLatin1String("::") +
QString::fromUtf8(metaProp.name());
errorString->append(error);
} else {
// Try and find a matching guard
while (!guards.isEmpty() && !guards.first()->isConnected(o, n))
guards.takeFirst()->Delete();
Guard *g = 0;
if (!guards.isEmpty()) {
g = guards.takeFirst();
g->cancelNotify();
Q_ASSERT(g->isConnected(o, n));
} else {
g = Guard::New(expression, engine);
g->connect(o, n, engine);
}
expression->activeGuards.prepend(g);
}
}
template<ACE_SYNCH_DECL> void
Log_Message_Receiver_Impl<ACE_SYNCH_USE>::detach (Log_Message_Receiver_Impl<ACE_SYNCH_USE> *body)
{
ACE_ASSERT (body != 0);
#if defined (ACE_HAS_THREADS)
# if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
Guard guard (copy_lock_);
if (guard.locked () == 0)
return;
# else
// Use the "body"s print lock as copy lock.
ACE_GUARD (ACE_SYNCH_MUTEX,
guard,
global_copy_lock_);
# endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
#endif /* ACE_HAS_THREADS */
if (body->count_-- == 0)
delete body;
}
CURRINT_REPOSITORY_TEMPL_
void RepositoryBase<CURRINT_REPOSITORY_T_>
//
::delete_object (Guard<Obj,wait_m>& obj/*, bool freeMemory*/)
{
assert (obj);
const ObjId objId = fromString<ObjId>
(obj->universal_id());
// (obj.operator->()->universal_id());
delete_object_by_id (objId/*, freeMemory*/);
}
void QQmlJavaScriptExpression::GuardCapture::captureProperty(QQmlNotifier *n)
{
if (expression) {
// Try and find a matching guard
while (!guards.isEmpty() && !guards.first()->isConnected(n))
guards.takeFirst()->Delete();
Guard *g = 0;
if (!guards.isEmpty()) {
g = guards.takeFirst();
g->cancelNotify();
Q_ASSERT(g->isConnected(n));
} else {
g = Guard::New(expression, engine);
g->connect(n);
}
expression->activeGuards.prepend(g);
}
}
Log_Message_Receiver_Impl<ACE_SYNCH_USE> *
Log_Message_Receiver_Impl<ACE_SYNCH_USE>::attach (Log_Message_Receiver_Impl<ACE_SYNCH_USE> *body)
{
ACE_ASSERT (body != 0);
#if defined (ACE_HAS_THREADS)
# if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
Guard guard (copy_lock_);
if (guard.locked () == 0)
return 0;
# else
// Use the "body"s print lock as copy lock.
ACE_GUARD_RETURN (ACE_SYNCH_MUTEX,
guard,
global_copy_lock_,
0);
# endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
#endif /* ACE_HAS_THREADS */
++body->count_;
return body;
}
// called by ArchiveChannel
void GroupInfo::incConnected(Guard &group_guard, ArchiveChannel &pv)
{
group_guard.check(__FILE__, __LINE__, mutex);
++num_connected;
if (num_connected > channels.size())
throw GenericException(__FILE__, __LINE__,
"Group %s connect count is %zu out of %zu "
"on increment from '%s'",
getName().c_str(),
(size_t)num_connected,
(size_t)channels.size(),
pv.getName().c_str());
}
// called by ArchiveChannel
void GroupInfo::disable(Guard &group_guard,
ArchiveChannel *cause, const epicsTime &when)
{
group_guard.check(__FILE__, __LINE__, mutex);
LOG_MSG("'%s' disables group '%s'\n",
cause->getName().c_str(), getName().c_str());
++disable_count;
if (disable_count != 1) // Was already disabled?
return;
// Disable all channels in this group
stdList<ArchiveChannel *>::iterator ci;
for (ci = channels.begin(); ci != channels.end(); ++ci)
{
ArchiveChannel *c = *ci;
Guard guard(__FILE__, __LINE__, *c);
c->disable(guard, when);
}
}
void ProcessVariable::stop(Guard &guard)
{
# ifdef DEBUG_PV
printf("stop ProcessVariable(%s)\n", getName().c_str());
# endif
guard.check(__FILE__, __LINE__, mutex);
LOG_ASSERT(isRunning(guard));
// We'll unlock in unsubscribe(), and then for the ca_clear_channel.
// At those times, an ongoing connection could invoke the connection_handler,
// control_callback or subscribe.
// Setting all indicators back to INIT state will cause those to bail.
chid _id = id;
id = 0;
bool was_connected = (state == CONNECTED);
state = INIT;
outstanding_gets = 0;
unsubscribe(guard);
// Unlock around CA lib. calls to prevent deadlocks.
{
GuardRelease release(__FILE__, __LINE__, guard);
{ // If we were subscribed, this was already checked in unsubscribe()...
Guard ctx_guard(__FILE__, __LINE__, ctx);
LOG_ASSERT(ctx.isAttached(ctx_guard));
}
try
{
ca_clear_channel(_id);
}
catch (std::exception &e)
{
LOG_MSG("ProcessVariable::stop(%s): %s\n",
getName().c_str(), e.what());
}
catch (...)
{
LOG_MSG("ProcessVariable::stop(%s): Unknown Exception\n",
getName().c_str());
}
// If there are listeners, tell them that we are disconnected.
if (was_connected)
firePvDisconnected();
}
}
void ProcessVariable::start(Guard &guard)
{
guard.check(__FILE__, __LINE__, mutex);
# ifdef DEBUG_PV
printf("start ProcessVariable(%s)\n", getName().c_str());
# endif
LOG_ASSERT(! isRunning(guard));
LOG_ASSERT(state == INIT);
state = DISCONNECTED;
// Unlock around CA lib. calls to prevent deadlocks in callbacks.
int status;
chid _id;
{
GuardRelease release(__FILE__, __LINE__, guard);
{
try
{
status = ca_create_channel(getName().c_str(),
connection_handler,
this, CA_PRIORITY_ARCHIVE, &_id);
}
catch (std::exception &e)
{
LOG_MSG("ProcessVariable::start(%s): %s\n",
getName().c_str(), e.what());
}
catch (...)
{
LOG_MSG("ProcessVariable::start(%s): Unknown Exception\n",
getName().c_str());
}
Guard ctx_guard(__FILE__, __LINE__, ctx);
ctx.requestFlush(ctx_guard);
}
}
id = _id;
if (status != ECA_NORMAL)
LOG_MSG("'%s': ca_create_channel failed, status %s\n",
getName().c_str(), ca_message(status));
}
// called by ArchiveChannel
void GroupInfo::enable(Guard &group_guard,
ArchiveChannel *cause, const epicsTime &when)
{
group_guard.check(__FILE__, __LINE__, mutex);
LOG_MSG("'%s' enables group '%s'\n",
cause->getName().c_str(), getName().c_str());
if (disable_count <= 0)
{
LOG_MSG("Group %s is not disabled, ERROR!\n", getName().c_str());
return;
}
--disable_count;
if (disable_count > 0) // Still disabled?
return;
// Enable all channels in this group
stdList<ArchiveChannel *>::iterator ci;
for (ci = channels.begin(); ci != channels.end(); ++ci)
{
ArchiveChannel *c = *ci;
Guard guard(__FILE__, __LINE__, *c);
c->enable(guard, when);
}
}
/*****************************************convol_fun*********************************************************/
BaseGDL* convol_fun( EnvT* e)
{
SizeT nParam=e->NParam( 2);
/************************************Checking_parameters************************************************/
BaseGDL* p0 = e->GetNumericParDefined( 0);
if( p0->Rank() == 0)
e->Throw( "Expression must be an array in this context: "+
e->GetParString(0));
BaseGDL* p1 = e->GetNumericParDefined( 1);
if( p1->Rank() == 0)
e->Throw( "Expression must be an array in this context: "+
e->GetParString(1));
if( p0->N_Elements() < p1->N_Elements())
e->Throw( "Incompatible dimensions for Array and Kernel.");
// rank 1 for kernel works always
if( p1->Rank() != 1)
{
SizeT rank = p0->Rank();
if( rank != p1->Rank())
e->Throw( "Incompatible dimensions for Array and Kernel.");
for( SizeT r=0; r<rank; ++r)
if( p0->Dim( r) < p1->Dim( r))
e->Throw( "Incompatible dimensions for Array and Kernel.");
}
/***************************************Preparing_matrices*************************************************/
// convert kernel to array type
Guard<BaseGDL> p1Guard;
if( p0->Type() == GDL_BYTE)
{
if( p1->Type() != GDL_INT)
{
p1 = p1->Convert2( GDL_INT, BaseGDL::COPY);
p1Guard.Reset( p1);
}
}
else if( p0->Type() != p1->Type())
{
p1 = p1->Convert2( p0->Type(), BaseGDL::COPY);
p1Guard.Reset( p1);
}
BaseGDL* scale;
Guard<BaseGDL> scaleGuard;
if( nParam > 2)
{
scale = e->GetParDefined( 2);
if( scale->Rank() > 0)
e->Throw( "Expression must be a scalar in this context: "+
e->GetParString(2));
// p1 here handles GDL_BYTE case also
if( p1->Type() != scale->Type())
{
scale = scale->Convert2( p1->Type(),BaseGDL::COPY);
scaleGuard.Reset( scale);
}
}
else
{
scale = p1->New( dimension(), BaseGDL::ZERO);
}
/********************************************Arguments_treatement***********************************/
bool center = true;
static int centerIx = e->KeywordIx( "CENTER");
if( e->KeywordPresent( centerIx))
{
DLong c;
e->AssureLongScalarKW( centerIx, c);
center = (c != 0);
}
// overrides EDGE_TRUNCATE
static int edge_wrapIx = e->KeywordIx( "EDGE_WRAP");
bool edge_wrap = e->KeywordSet( edge_wrapIx);
static int edge_truncateIx = e->KeywordIx( "EDGE_TRUNCATE");
bool edge_truncate = e->KeywordSet( edge_truncateIx);
static int edge_zeroIx = e->KeywordIx( "EDGE_ZERO");
bool edge_zero = e->KeywordSet( edge_zeroIx);
int edgeMode = 0;
if( edge_wrap)
edgeMode = 1;
else if( edge_truncate)
edgeMode = 2;
else if( edge_zero)
edgeMode = 3;
// p0, p1 and scale have same type
// p1 has rank of 1 or same rank as p0 with each dimension smaller than p0
// scale is a scalar
/***********************************Parameter_BIAS**************************************/
static int biasIx = e->KeywordIx("BIAS");
bool statusBias = e->KeywordPresent( biasIx );
// DLong bias=0;
BaseGDL* bias;
if(statusBias)
{
bias=e->GetKW( biasIx);
if( p0->Type() != bias->Type())
{
bias = bias->Convert2( p0->Type(), BaseGDL::COPY);
}
}
else bias=p1->New( 1,BaseGDL::ZERO);
/***********************************Parameter_Normalize**********************************/
static int normalIx = e->KeywordIx( "NORMALIZE");
bool normalize = e->KeywordPresent( normalIx);
/***********************************Parameter NAN****************************************/
static int nanIx = e->KeywordIx( "NAN");
bool doNan = e->KeywordPresent( nanIx);
/***********************************Parameter MISSING************************************/
static int missingIx = e->KeywordIx("MISSING");
bool doMissing = e->KeywordPresent( missingIx );
BaseGDL* missing;
if (p0->Type() != GDL_BYTE) {
if (doMissing) {
missing = e->GetKW(missingIx);
if (p0->Type() != missing->Type()) {
missing = missing->Convert2(p0->Type(), BaseGDL::COPY);
}
} else missing = p1->New(1, BaseGDL::ZERO);
} else {
if (doMissing) {
missing = e->GetKW(missingIx);
} else missing = p1->New(1, BaseGDL::ZERO);
missing = missing->Convert2(GDL_LONG, BaseGDL::COPY);
}
/***********************************Parameter INVALID************************************/
static int invalidIx = e->KeywordIx("INVALID");
bool doInvalid = e->KeywordPresent( invalidIx );
BaseGDL* invalid;
if (p0->Type() != GDL_BYTE) {
if (doInvalid) {
invalid = e->GetKW(invalidIx);
if (p0->Type() != invalid->Type()) {
invalid = invalid->Convert2(p0->Type(), BaseGDL::COPY);
}
} else invalid = p1->New(1, BaseGDL::ZERO);
} else {
if (doInvalid) {
invalid = e->GetKW(invalidIx);
} else invalid = p1->New(1, BaseGDL::ZERO);
invalid = invalid->Convert2(GDL_LONG, BaseGDL::COPY);
}
if (!doNan && !doInvalid) doMissing=false;
if (!doMissing && (p0->Type()==GDL_FLOAT ||p0->Type()==GDL_COMPLEX))
missing = SysVar::Values()->GetTag(SysVar::Values()->Desc()->TagIndex("F_NAN"), 0);
if (!doMissing && (p0->Type()==GDL_DOUBLE ||p0->Type()==GDL_COMPLEXDBL))
missing = SysVar::Values()->GetTag(SysVar::Values()->Desc()->TagIndex("D_NAN"), 0);
return p0->Convol( p1, scale, bias, center, normalize, edgeMode, doNan, missing, doMissing, invalid,doInvalid);
} //end of convol_fun
void AttackState::Update(double dt)
{
FSMState::Update(dt);
Guard* g = dynamic_cast<Guard*>(m_FSMOwner);
// Check if the NPC is legit
if (!g)
{
return;
}
if (g->GetAttacked() && g->GetKnockedOut())
{
if (g->GetLastTarget())
{
g->GetLastTarget()->SetTargetted(false); // Tell spy that guard no longer has sight on it
}
else if (g->GetTarget())
{
g->GetTarget()->SetTargetted(false); // Tell spy that guard no longer has sight on it
}
g->SetMoveSpeed(Guard::S_GUARD_PATROL_SPEED);
changeState(new AttackedState());
return;
}
if (!g->GetTarget()) // Target missing
{
m_missingTimer += dt;
if (g->GetLastTarget())
{
//g->GetLastTarget()->SetTargetted(false); // Tell spy that guard no longer has sight on it
}
if (!m_reached)
{
if (m_recordPoint)
{
g->AddToFallback(g->GetTransform().Translation);
m_recordPoint = false;
}
moveToLastSeen(dt);
}
else
{
g->SetMoveSpeed(Guard::S_GUARD_PATROL_SPEED);
g->GetView()->SetScale(Vector2(g->GetDefaultViewRadius() * 2.f, g->GetDefaultViewRadius() * 2.f));
g->UpdateViewPosition();
changeState(new PatrolState());
return;
}
}
else // Target still in sight
{
m_missingTimer = 0.f;
m_recordPoint = true;
g->GetTarget()->SetTargetted(true); // Tell spy that guard spotted it
m_attackTimer += dt;
if (m_attackTimer >= S_TIME_TILL_ATTACK)
{
int killChance = Math::RandIntMinMax(1, 100);
if (killChance < 70) // % chance to kill spy
{
g->GetTarget()->Kill();
g->GetTarget()->SetTargetted(false);
g->SetMoveSpeed(Guard::S_GUARD_PATROL_SPEED);
g->GetView()->SetScale(Vector2(g->GetDefaultViewRadius() * 2.f, g->GetDefaultViewRadius() * 2.f));
g->UpdateViewPosition();
changeState(new PatrolState());
return;
}
m_attackTimer = 0.f;
}
}
if (m_missingTimer >= S_MISSING_TIMER) // Can't find target for a period of time
{
if (g->GetLastTarget())
{
g->GetLastTarget()->SetTargetted(false); // Tell spy that guard no longer has sight on it
}
changeState(new PatrolState());
g->GetView()->SetScale(Vector2(g->GetDefaultViewRadius() * 2.f, g->GetDefaultViewRadius() * 2.f));
g->UpdateViewPosition();
return;
}
}
void AttackState::moveToLastSeen(double dt)
{
Guard* g = dynamic_cast<Guard*>(m_FSMOwner);
// Check if the NPC is legit
if (!g)
{
return;
}
g->SetLookDir((g->GetLastSeen() - g->GetTransform().Translation).Normalized());
float distFromLastSeen = (g->GetTransform().Translation - g->GetLastSeen()).LengthSquared();
float movement = g->GetMoveSpeed() * dt;
float movementSquared = movement * movement;
if (movementSquared > distFromLastSeen) // Walk past waypoint
{
g->SetPos(g->GetLastSeen());
g->UpdateViewPosition();
m_reached = true;
}
else
{
g->SetPos(g->GetTransform().Translation + (g->GetLookDir() * movement));
g->UpdateViewPosition();
}
}
ProcessVariable::State ProcessVariable::getState(Guard &guard) const
{
guard.check(__FILE__, __LINE__, mutex);
return state;
}
void GameState::init()
{
if (m_xLevel != nullptr)
{
delete m_xLevel;
m_xLevel = nullptr;
}
m_xLevel = new Level("../resources/level/", m_xSpriteManager, m_xGameObjectManager);
m_xLevel->loadColorCodes("colorcodes.txt");
m_xLevel->loadFloorColorCodes("floorcolorcodes.txt");
m_xLevel->getRotationsPaths("rotate.txt");
m_xLevel->create("level.png", "patrol.txt");
m_xLevel->createFloor("FirstFloor.png");
sf::Clock *xTimer = new sf::Clock;
m_cClock = sf::Clock();
//m_xPlayer = m_xGameObjectManager->createPlayer(m_xSpriteManager->loadSprite("spy.txt"), sf::Vector2f(64 * 48, 64 * 8), m_xEngine->m_window, 1, m_xLevel, xTimer);
m_xPlayer = m_xGameObjectManager->createPlayer(new Animator(m_xSpriteManager, "../resources/Spritesheets/"), m_xSpriteManager->loadAnimatedSprite("Spy_walk.txt"), sf::Vector2f(64 * 48, 64 * 8), m_xEngine->m_window, 1, m_xLevel, xTimer, m_xStateManager);
m_vGameObjects[MAIN].push_back(m_xPlayer);
m_vGameObjects[MAIN].insert(m_vGameObjects[MAIN].end(), m_xLevel->getObjects()->begin(), m_xLevel->getObjects()->end());
m_xView = new sf::View();
//kommentar
m_xView->reset(sf::FloatRect(0, 0, 1920 * 1, 1080 * 1));
/*m_xPlayer->m_xWeapon = new Gun(true, 2, 1.f, 1.f, &m_vGameObjects[MAIN], m_xGameObjectManager, m_xSpriteManager);
m_xPlayer->m_xWeapon->setAttachedObject(m_xPlayer);*/
/*m_xPlayer->m_xWeapon = new Baton(true, 10, 1.f, 1.f, &m_vGameObjects[MAIN], m_xLevel, m_xGameObjectManager, m_xSpriteManager);
m_xPlayer->m_xWeapon->setAttachedObject(m_xPlayer);*/
m_xPlayer->m_xWeapon = new Garrote(1.f, 2.5f, &m_vGameObjects[MAIN]);
m_xPlayer->m_xWeapon->setAttachedObject(m_xPlayer);
SoundManager soundmanager("../resources/Music/");
m_sIngame = soundmanager.getMusic("Ingame.ogg");
m_sIngame->setVolume(40.0f);
m_sIngame->setLoop(true);
m_sIngame->play();
hud = new HUD(m_xView, m_xSpriteManager, m_xPlayer);
PathFind *path = new PathFind(m_xLevel);
for (auto obj : m_vGameObjects[MAIN])
{
if (obj->getType() == PATROLLINGGUARD || obj->getType() == STATIONARYGUARD)
{
Guard *guard = static_cast<Guard*>(obj);
guard->attachAi(new AIManager(guard, m_xLevel, m_xPlayer));
guard->attachAnimator(new Animator(m_xSpriteManager, "../resources/Spritesheets/"));
if (guard->getIsRotating())
guard->m_xAIManager->forceCurrentState(AIManager::STATIONARY);
else if (guard->getIsPatrolling())
guard->m_xAIManager->forceCurrentState(AIManager::PATROLLING);
}
}
m_xPlayer->setStateObjects(&m_vGameObjects[MAIN]);
}
BaseGDL* _GDL_OBJECT_OverloadBracketsRightSide( EnvUDT* e)
{
// // debug/check
// std::cout << "_GDL_OBJECT_OverloadBracketsRightSide called" << std::endl;
SizeT nParam = e->NParam(); // number of parameters actually given
// int envSize = e->EnvSize(); // number of parameters + keywords 'e' (pro) has defined
if( nParam < 3) // consider implicit SELF
ThrowFromInternalUDSub( e, "At least 2 parameters are needed: ISRANGE, SUB1 [, ...].");
// default behavior: Exact like scalar indexing
BaseGDL* isRange = e->GetKW(1);
if( isRange == NULL)
ThrowFromInternalUDSub( e, "Parameter 1 (ISRANGE) is undefined.");
if( isRange->Rank() == 0)
ThrowFromInternalUDSub( e, "Parameter 1 (ISRANGE) must be an array in this context: " + e->Caller()->GetString(e->GetKW(1)));
SizeT nIsRange = isRange->N_Elements();
if( nIsRange > (nParam - 2)) //- SELF and ISRANGE
ThrowFromInternalUDSub( e, "Parameter 1 (ISRANGE) must have "+i2s(nParam-2)+" elements.");
Guard<DLongGDL> isRangeLongGuard;
DLongGDL* isRangeLong;
if( isRange->Type() == GDL_LONG)
isRangeLong = static_cast<DLongGDL*>( isRange);
else
{
try{
isRangeLong = static_cast<DLongGDL*>( isRange->Convert2( GDL_LONG, BaseGDL::COPY));
}
catch( GDLException& ex)
{
ThrowFromInternalUDSub( e, ex.ANTLRException::getMessage());
}
isRangeLongGuard.Reset( isRangeLong);
}
ArrayIndexVectorT ixList;
// IxExprListT exprList;
try {
for( int p=0; p<nIsRange; ++p)
{
BaseGDL* parX = e->GetKW( p + 2); // implicit SELF, ISRANGE, par1..par8
if( parX == NULL)
ThrowFromInternalUDSub( e, "Parameter is undefined: " + e->Caller()->GetString(e->GetKW( p + 2)));
DLong isRangeX = (*isRangeLong)[p];
if( isRangeX != 0 && isRangeX != 1)
{
ThrowFromInternalUDSub( e, "Value of parameter 1 (ISRANGE["+i2s(p)+"]) is out of allowed range.");
}
if( isRangeX == 1)
{
if( parX->N_Elements() != 3)
{
ThrowFromInternalUDSub( e, "Range vector must have 3 elements: " + e->Caller()->GetString(e->GetKW( p + 2)));
}
DLongGDL* parXLong;
Guard<DLongGDL> parXLongGuard;
if( parX->Type() != GDL_LONG)
{
try{
parXLong = static_cast<DLongGDL*>( parX->Convert2( GDL_LONG, BaseGDL::COPY));
parXLongGuard.Reset( parXLong);
}
catch( GDLException& ex)
{
ThrowFromInternalUDSub( e, ex.ANTLRException::getMessage());
}
}
else
{
parXLong = static_cast<DLongGDL*>( parX);
}
// negative end ix is fine -> CArrayIndexRangeS can handle [b:*:s] ([b,-1,s])
ixList.push_back(new CArrayIndexRangeS( (*parXLong)[0], (*parXLong)[1], (*parXLong)[2]));
}
else // non-range
{
// ATTENTION: These two grab c1 (all others don't)
// a bit unclean, but for maximum efficiency
if( parX->Rank() == 0)
ixList.push_back( new CArrayIndexScalar( parX->Dup()));
else
ixList.push_back( new CArrayIndexIndexed( parX->Dup()));
}
} // for
}
catch( GDLException& ex)
{
ixList.Destruct(); // ixList is not valid afterwards, but as we throw this is ok
throw ex;
}
ArrayIndexListT* aL;
MakeArrayIndex( &ixList, &aL, NULL); // important to get the non-NoAssoc ArrayIndexListT
// because only they clean up ixList on destruction
Guard< ArrayIndexListT> aLGuard( aL);
IxExprListT ixL;
return aL->Index( e->GetKW( 0), ixL); // index SELF
}
void ProcessVariable::subscribe(Guard &guard)
{
guard.check(__FILE__, __LINE__, mutex);
if (dbr_type == 0)
throw GenericException(__FILE__, __LINE__,
"Cannot subscribe to %s, never connected",
getName().c_str());
// Prevent multiple subscriptions
if (isSubscribed(guard))
return;
// While we were unlocked, a disconnect or stop() could have happend,
// in which case we need to bail out.
if (id == 0 || state != CONNECTED)
{
LOG_MSG("'%s': Skipped subscription, state %s, id 0x%lu.\n",
getName().c_str(), getStateStr(guard), (unsigned long) id);
return;
}
chid _id = id;
evid _ev_id = 0;
DbrType _type = dbr_type;
DbrCount _count = dbr_count;
{ // Release around CA call??
// -- GuardRelease release(__FILE__, __LINE__, guard);
// Right now, could a stop() and ca_clear_channel(id) happen,
// so that ca_create_subscription() uses an invalid id?
//
// Task A, CAC client:
// control_callback, pvConnected, subscribe
//
// Task B, Engine or HTTPD:
// stop, clear_channel
//
// LockTest.cpp indicates that the clear_channel() will wait
// for the CAC library to leabe the control_callback.
// So even though we unlock the ProcessVariable and somebody
// could invoke stop() and set id=0, we have the copied _id,
// and the ca_clear_channel(id) won't happen until we leave
// the control_callback.
// This of course only handles the use case of the engine
// where subscribe is invoked from control_callback & pvConnected.
// to be on the safe side, we keep the guard and prevent a stop(),
// until we find a deadlock that forces us to reconsider....
{
int status;
try
{
status = ca_create_subscription(_type, _count, _id,
DBE_LOG | DBE_ALARM,
value_callback, this, &_ev_id);
}
catch (std::exception &e)
{
LOG_MSG("ProcessVariable::subscribe(%s): %s\n",
getName().c_str(), e.what());
}
catch (...)
{
LOG_MSG("ProcessVariable::subscribe(%s): Unknown Exception\n",
getName().c_str());
}
if (status != ECA_NORMAL)
{
LOG_MSG("%s: ca_create_subscription failed: %s\n",
getName().c_str(), ca_message(status));
return;
}
Guard ctx_guard(__FILE__, __LINE__, ctx);
ctx.requestFlush(ctx_guard);
}
}
ev_id = _ev_id;
LOG_ASSERT(ev_id != 0);
#ifdef CHECK_EVID
void *user = peek_evid_userptr(ev_id);
LOG_ASSERT(user == this);
#endif
}
bool ProcessVariable::isRunning(Guard &guard)
{
guard.check(__FILE__, __LINE__, mutex);
return id != 0;
}