void nobBaseWarehouse::HandleCollectEvent()
{
// Storing wares done?
bool storing_done = false;
// Is storing still wanted?
bool storing_wanted = false;
// Untersuchen, welche Waren und Figuren eingelagert werden sollen
for(unsigned i = 0; i < WARE_TYPES_COUNT; ++i)
{
// Soll Ware eingeliefert werden?
if(!GetInventorySetting(GoodType(i)).IsSet(EInventorySetting::COLLECT))
continue;
storing_wanted = true;
// Lagerhaus suchen, das diese Ware enthält
nobBaseWarehouse* wh = gwg->GetPlayer(player).FindWarehouse(*this, FW::HasWareButNoCollect(GoodType(i)), false, false);
// Gefunden?
if(wh)
{
// Dann bestellen
Ware* ware = wh->OrderWare(GoodType(i), this);
if(ware)
{
RTTR_Assert(IsWareDependent(ware));
storing_done = true;
break;
}
}
}
// Menschen "bestellen" wenn noch keine Ware bestellt wurde
if(!storing_done)
{
for(unsigned i = 0; i < JOB_TYPES_COUNT; ++i)
{
// Soll dieser Typ von Mensch bestellt werden?
if(!GetInventorySetting(Job(i)).IsSet(EInventorySetting::COLLECT))
continue;
storing_wanted = true;
// Lagerhaus suchen, das diesen Job enthält
nobBaseWarehouse* wh = gwg->GetPlayer(player).FindWarehouse(*this, FW::HasFigureButNoCollect(Job(i), false), false, false);
// Gefunden?
if(wh)
{
// Dann bestellen
if(wh->OrderJob(Job(i), this, false))
break;
}
}
}
// Storing still wanted?
// Then continue ordering new stuff
if(storing_wanted)
store_event = em->AddEvent(this, STORE_INTERVAL, 4);
}
void TDMTeam::checkPowerUps() {
std::vector<Ship*> ships = ships::getShips();
bool existAny(false);
for (std::vector<Ship*>::const_iterator it = ships.begin(); it != ships.end(); ++it)
if ((*it)->getOwner()->team() != this && (*it)->attackable()) {
existAny = true;
break;
}
powerUpLocations_.clear();
std::list<PowerUp*> const& powerUps = items::getPowerUps();
for (std::list<PowerUp*>::const_iterator it=powerUps.begin(); it!=powerUps.end(); ++it) {
if (!(*it)->isCollected()) {
powerUpLocations_.push_back((*it)->location());
switch ((*it)->type()) {
case items::puFuel: addJob(Job(Job::jGetPUFuel, 70, &powerUpLocations_.back())); break;
case items::puHealth: addJob(Job(Job::jGetPUHealth, 70, &powerUpLocations_.back())); break;
case items::puReverse: if (existAny) addJob(Job(Job::jGetPUReverse, 70, &powerUpLocations_.back())); break;
case items::puShield: addJob(Job(Job::jGetPUShield, 70, &powerUpLocations_.back())); break;
default: if (existAny) addJob(Job(Job::jGetPUSleep, 70, &powerUpLocations_.back())); break;
}
}
}
}
void nobBaseWarehouse::Clear()
{
for(unsigned i = 0; i < WARE_TYPES_COUNT; ++i)
gwg->GetPlayer(player).DecreaseInventoryWare(GoodType(i), inventory[GoodType(i)]);
for(unsigned i = 0; i < JOB_TYPES_COUNT; ++i)
gwg->GetPlayer(player).DecreaseInventoryJob(Job(i), inventory[Job(i)]);
inventory.clear();
for(std::list<Ware*>::iterator it = waiting_wares.begin(); it != waiting_wares.end(); ++it)
{
(*it)->WareLost(player);
(*it)->Destroy();
delete (*it);
}
waiting_wares.clear();
for (unsigned i = 0; i < 5; ++i)
{
// TODO: inventory!?
reserve_soldiers_available[i] = 0;
reserve_soldiers_claimed_visual[i] = 0;
reserve_soldiers_claimed_real[i] = 0;
}
}
void nobBaseWarehouse::AddToInventory()
{
for(unsigned int i = 0; i < WARE_TYPES_COUNT; ++i)
gwg->GetPlayer(player).IncreaseInventoryWare(GoodType(i), inventory[GoodType(i)]);
for(unsigned int i = 0; i < JOB_TYPES_COUNT; ++i)
gwg->GetPlayer(player).IncreaseInventoryJob(Job(i), inventory[Job(i)]);
}
void TDMTeam::createJobs() {
checkEnemies();
checkPowerUps();
for (int i=0; i<botControllers_.size(); ++i) {
addJob(Job(Job::jLand, 4));
addJob(Job(Job::jCharge, 4));
}
}
/// increase rank
void nofActiveSoldier::IncreaseRank()
{
//max rank reached? -> dont increase!
if(MAX_MILITARY_RANK - (GetRank() + GAMECLIENT.GetGGS().getSelection(ADDON_MAX_RANK)) < 1)
return;
// Einen Rang höher
job = Job(unsigned(job) + 1);
// Inventur entsprechend erhöhen und verringern
gwg->GetPlayer(player)->IncreaseInventoryJob(job, 1);
gwg->GetPlayer(player)->DecreaseInventoryJob(Job(unsigned(job) - 1), 1);
}
void nofPassiveSoldier::Upgrade()
{
// Einen Rang höher
job = Job(unsigned(job) + 1);
// wieder heilen bzw. Hitpoints anpasen
hitpoints = HITPOINTS[gwg->GetPlayer(player)->nation][job - JOB_PRIVATE];
// Inventur entsprechend erhöhen und verringern
gwg->GetPlayer(player)->IncreaseInventoryJob(job, 1);
gwg->GetPlayer(player)->DecreaseInventoryJob(Job(unsigned(job) - 1), 1);
}
void nofPassiveSoldier::Upgrade()
{
assert(!building || !helpers::contains(static_cast<nobMilitary*>(building)->troops, this)); // We must not be in the buildings list while upgrading. This would destroy the ordered list
// Einen Rang höher
job = Job(unsigned(job) + 1);
// wieder heilen bzw. Hitpoints anpasen
hitpoints = HITPOINTS[gwg->GetPlayer(player)->nation][job - JOB_PRIVATE];
// Inventur entsprechend erhöhen und verringern
gwg->GetPlayer(player)->IncreaseInventoryJob(job, 1);
gwg->GetPlayer(player)->DecreaseInventoryJob(Job(unsigned(job) - 1), 1);
}
noFigure::noFigure(SerializedGameData& sgd, const unsigned obj_id) : noMovable(sgd, obj_id),
fs(FigureState(sgd.PopUnsignedChar())),
job_(Job(sgd.PopUnsignedChar())),
player(sgd.PopUnsignedChar()),
cur_rs(sgd.PopObject<RoadSegment>(GOT_ROADSEGMENT)),
rs_pos(sgd.PopUnsignedShort()),
rs_dir(sgd.PopBool()),
on_ship(sgd.PopBool()),
last_id(0xFFFFFFFF)
{
if(fs == FS_GOTOGOAL || fs == FS_GOHOME)
goal_ = sgd.PopObject<noRoadNode>(GOT_UNKNOWN);
else
goal_ = 0;
waiting_for_free_node = sgd.PopBool();
if(fs == FS_WANDER)
{
wander_way = sgd.PopUnsignedShort();
wander_tryings = sgd.PopUnsignedShort();
flagPos_ = sgd.PopMapPoint();
flag_obj_id = sgd.PopUnsignedInt();
burned_wh_id = sgd.PopUnsignedInt();
}
}
// JobSubQueue:QueueJobs
//------------------------------------------------------------------------------
void JobSubQueue::QueueJobs( Array< Node * > & nodes )
{
// Create wrapper Jobs around Nodes
Array< Job * > jobs( nodes.GetSize() );
for ( Node * node : nodes )
{
Job * job = FNEW( Job( node ) );
jobs.Append( job );
}
// Sort Jobs by cost
JobCostSorter sorter;
jobs.Sort( sorter );
// lock to add job
MutexHolder mh( m_Mutex );
const bool wasEmpty = m_Jobs.IsEmpty();
m_Jobs.Append( jobs );
m_Count += (uint32_t)jobs.GetSize();
if ( wasEmpty )
{
return; // skip re-sorting
}
// sort merged lists
m_Jobs.Sort( sorter );
}
void StratumClient::stop() {
QEventLoop waitLoop;
QTimer disconnectTimer;
disconnectTimer.setSingleShot(true);
disconnectTimer.setInterval(RECONNECT_TIMER_INTERVAL);
connect(m_socket, &QTcpSocket::disconnected, &waitLoop, &QEventLoop::quit);
connect(&disconnectTimer, &QTimer::timeout, &waitLoop, &QEventLoop::quit);
m_socket->disconnectFromHost();
disconnectTimer.start();
if (m_socket->state() != QTcpSocket::UnconnectedState) {
waitLoop.exec();
}
if (!disconnectTimer.isActive()) {
m_socket->abort();
disconnectTimer.stop();
}
if (m_reconnectTimerId != -1) {
killTimer(m_reconnectTimerId);
m_reconnectTimerId = -1;
}
if (m_responseTimerId != -1) {
killTimer(m_responseTimerId);
m_responseTimerId = -1;
}
m_activeRequestMap.clear();
m_currentSessionId.clear();
QWriteLocker lock(&m_jobLock);
m_currentJob = Job();
}
// QueueJob (Main Thread)
//------------------------------------------------------------------------------
void JobQueue::QueueJob( Node * node )
{
ASSERT( node->GetState() == Node::DYNAMIC_DEPS_DONE );
// mark as building
node->SetState( Node::BUILDING );
// trivial build tasks are processed immediately and returned
if ( node->GetControlFlags() & Node::FLAG_TRIVIAL_BUILD )
{
Job localJob( node );
Node::BuildResult result = DoBuild( &localJob );
switch( result )
{
case Node::NODE_RESULT_FAILED: node->SetState( Node::FAILED ); break;
case Node::NODE_RESULT_OK: node->SetState( Node::UP_TO_DATE ); break;
default: ASSERT( false ); break;
}
return;
}
Job * job = FNEW( Job( node ) );
// stick in queue
m_LocalAvailableJobs[ node->GetPriority() ].QueueJob( job );
}
void CaptureManager::Preload(int direct)
{
if (!book[direct]->orig && !book[direct]->isLoading)
{
m_queue->AddJob(Job(Job::thread_load, direct, m_capture->getFilename(direct)), 1);
book[direct]->isLoading = true;
}
}
/// Fügt einige Güter hinzu
void nobBaseWarehouse::AddGoods(const Inventory& goods)
{
for(unsigned int i = 0; i < WARE_TYPES_COUNT; ++i)
{
inventory.Add(GoodType(i), goods.goods[i]);
if(goods.goods[i])
CheckUsesForNewWare(GoodType(i));
}
for(unsigned int i = 0; i < JOB_TYPES_COUNT; ++i)
{
inventory.Add(Job(i), goods.people[i]);
if(goods.people[i])
CheckJobsForNewFigure(Job(i));
}
}
inline
static
Ptr
create()
{
Ptr Job(new CountJob());
return Job;
}
void TDMTeam::checkEnemies() {
std::vector<Ship*> ships = ships::getShips();
bool existAny(false);
for (std::vector<Ship*>::const_iterator it = ships.begin(); it != ships.end(); ++it)
if ((*it)->getOwner()->team() != this && (*it)->attackable()) {
existAny = true;
break;
}
if (existAny) {
for (int i=0; i<botControllers_.size(); ++i)
addJob(Job(Job::jAttackAny, 60));
}
else {
for (int i=0; i<botControllers_.size(); ++i)
addJob(Job(Job::jEscape, 6));
}
}
bool nobBaseWarehouse::AreWaresToEmpty() const
{
// Prüfen, ob Warentyp ausgelagert werden soll und ob noch Waren davon vorhanden sind
// Waren überprüfen
for(unsigned i = 0; i < WARE_TYPES_COUNT; ++i)
{
if(GetInventorySetting(GoodType(i)).IsSet(EInventorySetting::SEND) && inventory[GoodType(i)])
return true;
}
// Figuren überprüfen
for(unsigned i = 0; i < JOB_TYPES_COUNT; ++i)
{
if(GetInventorySetting(Job(i)).IsSet(EInventorySetting::SEND) && inventory[Job(i)])
return true;
}
return false;
}
void BotController::checkEnergy() {
if(!ship()->collidable()) {
for (std::map<Ship*, float>::iterator it = aggroTable_.begin(); it != aggroTable_.end(); ++it)
it->second = 0.f;
target_ = NULL;
}
else {
if (!ship()->docked_ && std::max(100 - ship()->getLife(), 100 - ship()->getFuel()) > 30) {
slave_->team()->addJob(Job(Job::jHeal, std::max(100 - ship()->getLife(), 100 - ship()->getFuel()), ship()));
slave_->team()->addJob(Job(Job::jHeal, std::max(100 - ship()->getLife(), 100 - ship()->getFuel()), ship()));
}
if (ship()->frozen_ > 0) {
slave_->team()->addJob(Job(Job::jUnfreeze, 90, ship()));
slave_->team()->addJob(Job(Job::jUnfreeze, 90, ship()));
slave_->team()->addJob(Job(Job::jUnfreeze, 90, ship()));
}
}
}
void addJob (JobType type, std::string const& name,
boost::function <void (Job&)> const& jobFunc)
{
assert (type != jtINVALID);
JobDataMap::iterator iter (m_jobData.find (type));
assert (iter != m_jobData.end ());
if (iter == m_jobData.end ())
return;
JobTypeData& data (iter->second);
// FIXME: Workaround incorrect client shutdown ordering
// do not add jobs to a queue with no threads
assert (type == jtCLIENT || m_workers.getNumberOfThreads () > 0);
{
// If this goes off it means that a child didn't follow
// the Stoppable API rules. A job may only be added if:
//
// - The JobQueue has NOT stopped
// AND
// * We are currently processing jobs
// OR
// * We have have pending jobs
// OR
// * Not all children are stopped
//
ScopedLock lock (m_mutex);
assert (! isStopped() && (
m_processCount>0 ||
! m_jobSet.empty () ||
! areChildrenStopped()));
}
// Don't even add it to the queue if we're stopping
// and the job type is marked for skipOnStop.
//
if (isStopping() && skipOnStop (type))
{
m_journal.debug <<
"Skipping addJob ('" << name << "')";
return;
}
{
ScopedLock lock (m_mutex);
std::pair <std::set <Job>::iterator, bool> result (
m_jobSet.insert (Job (type, name, ++m_lastJob,
data.load (), jobFunc, m_cancelCallback)));
queueJob (*result.first, lock);
}
}
/**
* \details Generate the new jobs that appears at the time t
*/
void Simulation::generateNewJobs(int t)
{
for (unsigned int i = 0; i < _tasks.size(); ++i)
{
Task* task = &_tasks[i];
if (t % task->getPeriod() == task->getOffset())
{
_jobs.push_back(Job(&_tasks[i], t));
}
}
}
Job JobFactory::createModelToRadPreProcessJob(
const openstudio::runmanager::Tools &t_tools,
const openstudio::runmanager::JobParams &t_params,
const openstudio::runmanager::Files &t_files,
const std::vector<openstudio::URLSearchPath> &t_url_search_paths,
bool t_loading,
const boost::optional<openstudio::UUID> &t_uuid,
const JobState &t_state
)
{
return Job(boost::shared_ptr<detail::Job_Impl>(new detail::ModelToRadPreProcessJob(*t_uuid, t_tools, t_params, normalizeURLs(t_files, t_url_search_paths, t_loading, *t_uuid), t_state)));
}
/// increase rank
void nofActiveSoldier::IncreaseRank()
{
//max rank reached? -> dont increase!
if(GetRank() >= gwg->GetGGS().GetMaxMilitaryRank())
return;
// Einen Rang höher
// Inventur entsprechend erhöhen und verringern
gwg->GetPlayer(player).DecreaseInventoryJob(job_, 1);
job_ = Job(unsigned(job_) + 1);
gwg->GetPlayer(player).IncreaseInventoryJob(job_, 1);
}
boost::optional<Job> Job::finishedJob() const
{
boost::shared_ptr<detail::Job_Impl> fj =
m_impl->finishedJob();
if (fj)
{
return Job(fj);
} else {
return boost::optional<Job>();
}
}
boost::optional<Job> Job::parent() const
{
boost::shared_ptr<detail::Job_Impl> p =
m_impl->parent();
if (p)
{
return Job(p);
} else {
return boost::optional<Job>();
}
}
// Process( MsgJob )
//------------------------------------------------------------------------------
void Server::Process( const ConnectionInfo * connection, const Protocol::MsgJob * msg, const void * payload, size_t payloadSize )
{
ClientState * cs = (ClientState *)connection->GetUserData();
MutexHolder mh( cs->m_Mutex );
ASSERT( cs->m_NumJobsRequested > 0 );
cs->m_NumJobsRequested--;
cs->m_NumJobsActive++;
// deserialize job
ConstMemoryStream ms( payload, payloadSize );
Job * job = FNEW( Job( ms ) );
job->SetUserData( cs );
//
const uint64_t toolId = msg->GetToolId();
ASSERT( toolId );
MutexHolder manifestMH( m_ToolManifestsMutex ); // ensure we don't make redundant requests
ToolManifest ** found = m_Tools.FindDeref( toolId );
ToolManifest * manifest = found ? *found : nullptr;
if ( manifest )
{
job->SetToolManifest( manifest );
if ( manifest->IsSynchronized() )
{
// we have all the files - we can do the job
JobQueueRemote::Get().QueueJob( job );
return;
}
// missing some files - request them
RequestMissingFiles( connection, manifest );
}
else
{
// first time seeing this tool
// create manifest object
manifest = FNEW( ToolManifest( toolId ) );
job->SetToolManifest( manifest );
m_Tools.Append( manifest );
// request manifest of tool chain
Protocol::MsgRequestManifest reqMsg( toolId );
reqMsg.Send( connection );
}
// can't start job yet - put it on hold
cs->m_WaitingJobs.Append( job );
}
int GameWorldBase::LUA_AddPeople(lua_State *L)
{
// GameWorldBase *gw = static_cast<GameWorldBase*>(lua_touserdata(L,lua_upvalueindex(1)));
int argc = lua_gettop(L) - 1;
if ((argc < 0) || (argc % 2 == 1))
{
lua_pushstring(L, "wrong arguments: player, ware1, count1, ware2, count2, ...");
lua_error(L);
return(0);
}
// player
unsigned pnr = luaL_checknumber(L, 1);
if (pnr >= GAMECLIENT.GetPlayerCount())
{
lua_pushstring(L, "player number invalid!");
lua_error(L);
return(0);
}
GameClientPlayer *player = GAMECLIENT.GetPlayer(pnr);
nobBaseWarehouse *warehouse = player->GetFirstWH();
if (warehouse == NULL)
{
lua_pushstring(L, "player has no warehouses!");
lua_error(L);
return(0);
}
Goods goods;
unsigned cnt = 2;
for (argc >>= 1; argc > 0; --argc)
{
unsigned type = luaL_checknumber(L, cnt++);
unsigned count = luaL_checknumber(L, cnt++);
if (type < JOB_TYPES_COUNT)
{
goods.people[type] += count;
player->IncreaseInventoryJob(Job(type), count);
}
}
warehouse->AddGoods(goods);
return(0);
}
/** the client thead
@param client
@return null */
static void *thread(struct Client *client) {
struct Job *job;
if(!client || client->prints <= 0) return 0;
for( ; ; ) {
job = Job(client, random_int(client->pages_min, client->pages_max));
if(!SpoolPushJob(job)) return (void *)-1;
if(--client->prints <= 0) break;
sleep(client->ms_idle);
}
printf("%s signing off.\n", client->name);
return 0;
}
int main(int argc, char **argv) {
// For the sake of simplicity we're starting only one thread here
// but you can add as many workers as you want.
boost::thread worker_thread(&::worker);
// posting a first job
cache.process(Job(1, 10));
// waiting for the worker to start
workerStarted.wait();
// checking if some data is in the cache
check(1005);
check(1);
check(9);
// posting another job
cache.process(Job(1000, 20));
// checking some more data
check(2);
check(5);
check(1000);
// requesting termination
printf("main : sending termination\n");
cache.terminate();
// waiting for the thread to finish
worker_thread.join();
// as a bonus we can see what was actually processed by the worker
std::vector<id_type> keys;
printf("main : worker processed %lu elements : ", cache.dumpKeys(keys));
std::copy(keys.begin(), keys.end(), std::ostream_iterator<id_type>(std::cout, " "));
std::cout << std::endl;
return EXIT_SUCCESS;
}
CCMSDIntegrator::CCMSDIntegrator(void)
:
resources((std::vector<IObjectPtr>&) Resource().objects()),
cells((std::vector<IObjectPtr>&) Cell().objects()),
parts((std::vector<IObjectPtr>&) Part().objects()),
processplans((std::vector<IObjectPtr>&) ProcessPlan().objects()),
jobs((std::vector<IObjectPtr>&) Job().objects()),
distributions((std::vector<IObjectPtr>&) Distribution().objects()),
calendars((std::vector<IObjectPtr>&) Calendar().objects()),
layouts((std::vector<IObjectPtr>&) Layout().objects())
{
}
void CaptureManager::Release(int p, int z, bool fluorescence)
{
// unload previous loaded image
if (!IsInNeighborhood(p, z))
{
int direct = CalculateDirect(p, z, fluorescence);
if (book[direct]->isLoading)
book[direct]->isLoading = false;
else
m_queue->AddJob(Job(Job::thread_delete, direct, book[direct]->orig), 1);
book[direct]->orig = NULL;
}
}
