void ProcessManager::Update(const int delta)
{
ProcessList::iterator i = processList.begin();
ProcessList::iterator end = processList.end();
ProcessPtr next;
while(i != end)
{
ProcessPtr process(*i);
if(process->IsDead())
{
next = process->GetNext();
if(next != NULL)
{
ProcessPtr temp((Process*)NULL);
process->SetNext(temp);
this->Attach(next);
}
this->Detach(process);
}
if(process->IsActive() && !process->IsPaused())
{
process->Update(delta);
}
i++;
}
}
I've been looking through my copy of Game Coding Complete 3rd Ed and found the ProcessManager bit interesting. I tried implementing it, but I get the debug assert thing from VS08 saying "list iterator not incrementable".
(ProcessList = std::list<ProcessPtr>, ProcessPtr = boost::shared_ptr<Process>.)
IsDead is a bool flag set when Kill() is called. GetNext() returns a shared pointer to the next process (when it's killed; similar to a singly linked list I think-where each element points to its successor?)
Detach removes it from the list. Attach adds it to the list.
I've tried stepping through with debugger, and it goes:
Update
Update
Update
Update
Update
Killed
//There should be another call here to the next process.
It has one element in the list(one process I attach) until the IsDead flag is set. Then it attaches another process(list has 2 elements) and detaches the first one(list has one element). However, it then tries to increment the iterator and fails.
I'm not sure how to get around this. Any help? I've understood what it's doing in the book, and mine's a pretty close copy.
Thanks. :D
//Here's my entire source if you need it.\Header
#ifndef PROCESS_H
#define PROCESS_H
#include <list>
#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>
class Process;
typedef boost::shared_ptr<Process> ProcessPtr;
#define WAIT 0
#define BOOM 1
class Process : boost::noncopyable
{
public:
Process(int processType);
bool IsDead() const { return isDead; };
bool IsActive() const { return isActive; };
void SetActive(const bool active) { isActive = active; };
void SetAttached(const bool attach) { isAttached = attach; };
bool IsAttached() const { return isAttached; };
bool IsPaused() const { return isPaused; };
bool IHazInit() const { return !isInitTiemNaow; };
int GetType() const{ return type; };
void SetType(const int set) { type = set; };
ProcessPtr GetNext () const { return nextProcess; };
void SetNext(ProcessPtr process) { nextProcess = process; };
virtual void Update(const int delta);
virtual void Init() {};
virtual void PauseToggle() { isPaused = !isPaused; };
virtual void Kill() { isDead = true; isActive = false; };
protected:
int type;
bool isActive, isDead, isPaused, isAttached, isInitTiemNaow;
ProcessPtr nextProcess;
};
typedef std::list< ProcessPtr > ProcessList;
class ProcessManager
{
public:
bool HasAttachments() { return !processList.empty(); };
void Attach(ProcessPtr process);
void Update(const int delta);
private:
void Detach(ProcessPtr process);
ProcessList processList;
};
class WaitProcess : public Process
{
public:
WaitProcess(unsigned int time);
virtual void Update(const int delta);
virtual void Kill();
protected:
unsigned int start, stop;
};
class BoomProcess : public Process
{
public:
BoomProcess():Process(BOOM) {};
virtual void Update(const int delta);
virtual void Kill();
};
#endif
Implementation
#include "Process.h"
Process::Process(int processType)
:type(processType),
isActive(true),
isDead(false),
isPaused(false),
isAttached(false),
isInitTiemNaow(true)
{
}
void Process::Update(const int delta)
{
if(isInitTiemNaow)
{
this->Init();
this->isInitTiemNaow = false;
}
}
void ProcessManager::Attach(ProcessPtr process)
{
process->SetAttached(true);
this->processList.push_back(process);
}
void ProcessManager::Detach(ProcessPtr process)
{
process->SetAttached(false);
this->processList.remove(process);
}
void ProcessManager::Update(const int delta)
{
ProcessList::iterator i = processList.begin();
ProcessList::iterator end = processList.end();
ProcessPtr next;
while(i != end)
{
ProcessPtr process(*i);
if(process->IsDead())
{
next = process->GetNext();
if(next != NULL)
{
ProcessPtr temp((Process*)NULL);
process->SetNext(temp);
this->Attach(next);
}
this->Detach(process);
}
if(process->IsActive() && !process->IsPaused())
{
process->Update(delta);
}
//if(i == processList.end())
std::cout << "foo";
i++;
}
}
WaitProcess::WaitProcess(unsigned int time)
:Process(WAIT),
start(0),
stop(time)
{}
void WaitProcess::Update(const int delta)
{
if(isActive)
{
this->start += delta;
std::cout << "Waiting." << std::endl;
if(start >= stop)
this->Kill();
}
}
void WaitProcess::Kill()
{
std::cout << "Stopped waiting." << std::endl;
Process::Kill();
}
void BoomProcess::Update(const int delta)
{
if(isActive)
{
this->Kill();
}
}
void BoomProcess::Kill()
{
std::cout << "BOOM." << std::endl;
}
And how I use it(it's an absolute for the delta time out of testing+the cin)
#include "Process.h"
int main(int argc, char* argv[])
{
ProcessPtr boom(new BoomProcess());
ProcessPtr wait(new WaitProcess(3000));
ProcessManager manager;
wait->SetNext(boom);
manager.Attach(wait);
while(manager.HasAttachments())
{
manager.Update(300);
}
int x;
std::cin >> x;
return 0;
}
