SWORD25: removed BS_ prefix from rest of the classes.

The things which are intentionally left with the prefix:
BS_LOG, BS_ASSERT, BS_Rect, BS_String.

svn-id: r53261

37 files changed, 168 insertions, 168 deletions

diff --git a/engines/sword25/gfx/animation.cpp b/engines/sword25/gfx/animation.cpp
index 7c4d05da73..71670a59c5 100644
--- a/engines/sword25/gfx/animation.cpp
+++ b/engines/sword25/gfx/animation.cpp
@@ -92,7 +92,7 @@ Animation::Animation(RenderObjectPtr<RenderObject> ParentPtr, const AnimationTem
 
 // -----------------------------------------------------------------------------
 
-Animation::Animation(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) :
+Animation::Animation(InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) :
 	TimedRenderObject(ParentPtr, RenderObject::TYPE_ANIMATION, Handle) {
 	// Das BS_RenderObject konnte nicht erzeugt werden, daher muss an dieser Stelle abgebrochen werden.
 	if (!m_InitSuccess) return;
@@ -107,8 +107,8 @@ Animation::Animation(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObj
 
 void Animation::InitializeAnimationResource(const Common::String &FileName) {
 	// Die Resource wird für die gesamte Lebensdauer des Animations-Objektes gelockt.
-	BS_Resource *ResourcePtr = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(FileName);
-	if (ResourcePtr && ResourcePtr->GetType() == BS_Resource::TYPE_ANIMATION)
+	Resource *ResourcePtr = Kernel::GetInstance()->GetResourceManager()->RequestResource(FileName);
+	if (ResourcePtr && ResourcePtr->GetType() == Resource::TYPE_ANIMATION)
 		m_AnimationResourcePtr = static_cast<AnimationResource *>(ResourcePtr);
 	else {
 		BS_LOG_ERRORLN("The resource \"%s\" could not be requested. The Animation can't be created.", FileName.c_str());
@@ -207,13 +207,13 @@ bool Animation::DoRender() {
 	BS_ASSERT(m_CurrentFrame < animationDescriptionPtr->GetFrameCount());
 
 	// Bitmap des aktuellen Frames holen
-	BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->GetFrame(m_CurrentFrame).FileName);
+	Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->GetFrame(m_CurrentFrame).FileName);
 	BS_ASSERT(pResource);
-	BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP);
+	BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
 	BitmapResource *pBitmapResource = static_cast<BitmapResource *>(pResource);
 
 	// Framebufferobjekt holen
-	GraphicEngine *pGfx = static_cast<GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
+	GraphicEngine *pGfx = static_cast<GraphicEngine *>(Kernel::GetInstance()->GetService("gfx"));
 	BS_ASSERT(pGfx);
 
 	// Bitmap zeichnen
@@ -346,9 +346,9 @@ void Animation::ComputeCurrentCharacteristics() {
 	BS_ASSERT(animationDescriptionPtr);
 	const AnimationResource::Frame &CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame);
 
-	BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(CurFrame.FileName);
+	Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(CurFrame.FileName);
 	BS_ASSERT(pResource);
-	BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP);
+	BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
 	BitmapResource *pBitmap = static_cast<BitmapResource *>(pResource);
 
 	// Größe des Bitmaps auf die Animation übertragen
@@ -371,7 +371,7 @@ bool Animation::LockAllFrames() {
 		AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
 		BS_ASSERT(animationDescriptionPtr);
 		for (unsigned int i = 0; i < animationDescriptionPtr->GetFrameCount(); ++i) {
-			if (!BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->GetFrame(i).FileName)) {
+			if (!Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->GetFrame(i).FileName)) {
 				BS_LOG_ERRORLN("Could not lock all animation frames.");
 				return false;
 			}
@@ -390,8 +390,8 @@ bool Animation::UnlockAllFrames() {
 		AnimationDescription *animationDescriptionPtr = GetAnimationDescription();
 		BS_ASSERT(animationDescriptionPtr);
 		for (unsigned int i = 0; i < animationDescriptionPtr->GetFrameCount(); ++i) {
-			BS_Resource *pResource;
-			if (!(pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->GetFrame(i).FileName))) {
+			Resource *pResource;
+			if (!(pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->GetFrame(i).FileName))) {
 				BS_LOG_ERRORLN("Could not unlock all animation frames.");
 				return false;
 			}
@@ -602,9 +602,9 @@ int Animation::ComputeXModifier() const {
 	BS_ASSERT(animationDescriptionPtr);
 	const AnimationResource::Frame &CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame);
 
-	BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(CurFrame.FileName);
+	Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(CurFrame.FileName);
 	BS_ASSERT(pResource);
-	BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP);
+	BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
 	BitmapResource *pBitmap = static_cast<BitmapResource *>(pResource);
 
 	int Result = CurFrame.FlipV ? - static_cast<int>((pBitmap->GetWidth() - 1 - CurFrame.HotspotX) * m_ScaleFactorX) :
@@ -622,9 +622,9 @@ int Animation::ComputeYModifier() const {
 	BS_ASSERT(animationDescriptionPtr);
 	const AnimationResource::Frame &CurFrame = animationDescriptionPtr->GetFrame(m_CurrentFrame);
 
-	BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(CurFrame.FileName);
+	Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(CurFrame.FileName);
 	BS_ASSERT(pResource);
-	BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP);
+	BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
 	BitmapResource *pBitmap = static_cast<BitmapResource *>(pResource);
 
 	int Result = CurFrame.FlipH ? - static_cast<int>((pBitmap->GetHeight() - 1 - CurFrame.HotspotY) * m_ScaleFactorY) :
@@ -666,7 +666,7 @@ void Animation::RegisterDeleteCallback(ANIMATION_CALLBACK Callback, unsigned int
 // Persistenz
 // -----------------------------------------------------------------------------
 
-void Animation::PersistCallbackVector(BS_OutputPersistenceBlock &Writer, const Common::Array<ANIMATION_CALLBACK_DATA> & Vector) {
+void Animation::PersistCallbackVector(OutputPersistenceBlock &Writer, const Common::Array<ANIMATION_CALLBACK_DATA> & Vector) {
 	// Anzahl an Callbacks persistieren.
 	Writer.Write(Vector.size());
 
@@ -682,7 +682,7 @@ void Animation::PersistCallbackVector(BS_OutputPersistenceBlock &Writer, const C
 
 // -----------------------------------------------------------------------------
 
-void Animation::UnpersistCallbackVector(BS_InputPersistenceBlock &Reader, Common::Array<ANIMATION_CALLBACK_DATA> & Vector) {
+void Animation::UnpersistCallbackVector(InputPersistenceBlock &Reader, Common::Array<ANIMATION_CALLBACK_DATA> & Vector) {
 	// Callbackvector leeren.
 	Vector.resize(0);
 
@@ -706,7 +706,7 @@ void Animation::UnpersistCallbackVector(BS_InputPersistenceBlock &Reader, Common
 
 // -----------------------------------------------------------------------------
 
-bool Animation::Persist(BS_OutputPersistenceBlock &Writer) {
+bool Animation::Persist(OutputPersistenceBlock &Writer) {
 	bool Result = true;
 
 	Result &= RenderObject::Persist(Writer);
@@ -749,7 +749,7 @@ bool Animation::Persist(BS_OutputPersistenceBlock &Writer) {
 
 // -----------------------------------------------------------------------------
 
-bool Animation::Unpersist(BS_InputPersistenceBlock &Reader) {
+bool Animation::Unpersist(InputPersistenceBlock &Reader) {
 	bool Result = true;
 
 	Result &= RenderObject::Unpersist(Reader);
diff --git a/engines/sword25/gfx/animation.h b/engines/sword25/gfx/animation.h
index 978b1ae151..cc09246f96 100644
--- a/engines/sword25/gfx/animation.h
+++ b/engines/sword25/gfx/animation.h
@@ -46,12 +46,12 @@
 namespace Sword25 {
 
 // Forward declarations
-class BS_Kernel;
+class Kernel;
 class BS_PackageManager;
 class AnimationResource;
 class AnimationTemplate;
 class AnimationDescription;
-class BS_InputPersistenceBlock;
+class InputPersistenceBlock;
 
 class Animation : public TimedRenderObject {
 	friend class RenderObject;
@@ -59,7 +59,7 @@ class Animation : public TimedRenderObject {
 private:
 	Animation(RenderObjectPtr<RenderObject> ParentPtr, const Common::String &FileName);
 	Animation(RenderObjectPtr<RenderObject> ParentPtr, const AnimationTemplate &Template);
-	Animation(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle);
+	Animation(InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle);
 
 public:
 	enum ANIMATION_TYPES {
@@ -135,8 +135,8 @@ public:
 		return m_ScaleFactorY;
 	}
 
-	virtual bool Persist(BS_OutputPersistenceBlock &Writer);
-	virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
+	virtual bool Persist(OutputPersistenceBlock &Writer);
+	virtual bool Unpersist(InputPersistenceBlock &Reader);
 
 	virtual void FrameNotification(int TimeElapsed);
 
@@ -221,8 +221,8 @@ private:
 	int ComputeYModifier() const;
 
 	void InitMembers();
-	void PersistCallbackVector(BS_OutputPersistenceBlock &Writer, const Common::Array<ANIMATION_CALLBACK_DATA> & Vector);
-	void UnpersistCallbackVector(BS_InputPersistenceBlock &Reader, Common::Array<ANIMATION_CALLBACK_DATA> & Vector);
+	void PersistCallbackVector(OutputPersistenceBlock &Writer, const Common::Array<ANIMATION_CALLBACK_DATA> & Vector);
+	void UnpersistCallbackVector(InputPersistenceBlock &Reader, Common::Array<ANIMATION_CALLBACK_DATA> & Vector);
 	AnimationDescription *GetAnimationDescription() const;
 	void InitializeAnimationResource(const Common::String &FileName);
 };
diff --git a/engines/sword25/gfx/animationdescription.cpp b/engines/sword25/gfx/animationdescription.cpp
index 44a9d8de06..622940c3ec 100644
--- a/engines/sword25/gfx/animationdescription.cpp
+++ b/engines/sword25/gfx/animationdescription.cpp
@@ -46,7 +46,7 @@ namespace Sword25 {
 // Persistenz
 // -----------------------------------------------------------------------------
 
-bool AnimationDescription::Persist(BS_OutputPersistenceBlock &Writer) {
+bool AnimationDescription::Persist(OutputPersistenceBlock &Writer) {
 	Writer.Write(static_cast<unsigned int>(m_AnimationType));
 	Writer.Write(m_FPS);
 	Writer.Write(m_MillisPerFrame);
@@ -59,7 +59,7 @@ bool AnimationDescription::Persist(BS_OutputPersistenceBlock &Writer) {
 
 // -----------------------------------------------------------------------------
 
-bool AnimationDescription::Unpersist(BS_InputPersistenceBlock &Reader) {
+bool AnimationDescription::Unpersist(InputPersistenceBlock &Reader) {
 	unsigned int AnimationType;
 	Reader.Read(AnimationType);
 	m_AnimationType = static_cast<Animation::ANIMATION_TYPES>(AnimationType);
diff --git a/engines/sword25/gfx/animationdescription.h b/engines/sword25/gfx/animationdescription.h
index 3ac441a767..2fab8287c7 100644
--- a/engines/sword25/gfx/animationdescription.h
+++ b/engines/sword25/gfx/animationdescription.h
@@ -49,7 +49,7 @@ namespace Sword25 {
 // Klassendefinition
 // -----------------------------------------------------------------------------
 
-class AnimationDescription : public BS_Persistable {
+class AnimationDescription : public Persistable {
 protected:
 	AnimationDescription() :
 		m_AnimationType(Animation::AT_LOOP),
@@ -102,8 +102,8 @@ public:
 		return m_ColorModulationAllowed;
 	}
 
-	virtual bool Persist(BS_OutputPersistenceBlock &Writer);
-	virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
+	virtual bool Persist(OutputPersistenceBlock &Writer);
+	virtual bool Unpersist(InputPersistenceBlock &Reader);
 
 protected:
 	Animation::ANIMATION_TYPES   m_AnimationType;
diff --git a/engines/sword25/gfx/animationresource.cpp b/engines/sword25/gfx/animationresource.cpp
index 770c60f7ce..1803171304 100644
--- a/engines/sword25/gfx/animationresource.cpp
+++ b/engines/sword25/gfx/animationresource.cpp
@@ -65,10 +65,10 @@ const int   MAX_FPS     = 200;
 // -----------------------------------------------------------------------------
 
 AnimationResource::AnimationResource(const Common::String &FileName) :
-	BS_Resource(FileName, BS_Resource::TYPE_ANIMATION),
+	Resource(FileName, Resource::TYPE_ANIMATION),
 	m_Valid(false) {
 	// Pointer auf den Package-Manager bekommen
-	PackageManager *PackagePtr = BS_Kernel::GetInstance()->GetPackage();
+	PackageManager *PackagePtr = Kernel::GetInstance()->GetPackage();
 	BS_ASSERT(PackagePtr);
 
 	// Animations-XML laden
@@ -266,7 +266,7 @@ AnimationResource::~AnimationResource() {
 bool AnimationResource::PrecacheAllFrames() const {
 	Common::Array<Frame>::const_iterator Iter = m_Frames.begin();
 	for (; Iter != m_Frames.end(); ++Iter) {
-		if (!BS_Kernel::GetInstance()->GetResourceManager()->PrecacheResource((*Iter).FileName)) {
+		if (!Kernel::GetInstance()->GetResourceManager()->PrecacheResource((*Iter).FileName)) {
 			BS_LOG_ERRORLN("Could not precache \"%s\".", (*Iter).FileName.c_str());
 			return false;
 		}
@@ -289,7 +289,7 @@ bool AnimationResource::ComputeFeatures() {
 	Common::Array<Frame>::const_iterator Iter = m_Frames.begin();
 	for (; Iter != m_Frames.end(); ++Iter) {
 		BitmapResource *pBitmap;
-		if (!(pBitmap = static_cast<BitmapResource *>(BS_Kernel::GetInstance()->GetResourceManager()->RequestResource((*Iter).FileName)))) {
+		if (!(pBitmap = static_cast<BitmapResource *>(Kernel::GetInstance()->GetResourceManager()->RequestResource((*Iter).FileName)))) {
 			BS_LOG_ERRORLN("Could not request \"%s\".", (*Iter).FileName.c_str());
 			return false;
 		}
diff --git a/engines/sword25/gfx/animationresource.h b/engines/sword25/gfx/animationresource.h
index 806861f07e..8e1c36ef0f 100644
--- a/engines/sword25/gfx/animationresource.h
+++ b/engines/sword25/gfx/animationresource.h
@@ -56,14 +56,14 @@ namespace Sword25 {
 // Forward Declarations
 // -----------------------------------------------------------------------------
 
-class BS_Kernel;
+class Kernel;
 class PackageManager;
 
 // -----------------------------------------------------------------------------
 // Class Definition
 // -----------------------------------------------------------------------------
 
-class AnimationResource : public BS_Resource, public AnimationDescription {
+class AnimationResource : public Resource, public AnimationDescription {
 public:
 	AnimationResource(const Common::String &FileName);
 	virtual ~AnimationResource();
diff --git a/engines/sword25/gfx/animationtemplate.cpp b/engines/sword25/gfx/animationtemplate.cpp
index c573d06b1e..426cbabfea 100644
--- a/engines/sword25/gfx/animationtemplate.cpp
+++ b/engines/sword25/gfx/animationtemplate.cpp
@@ -79,7 +79,7 @@ unsigned int AnimationTemplate::Create(const AnimationTemplate &Other) {
 
 // -----------------------------------------------------------------------------
 
-unsigned int AnimationTemplate::Create(BS_InputPersistenceBlock &Reader, unsigned int Handle) {
+unsigned int AnimationTemplate::Create(InputPersistenceBlock &Reader, unsigned int Handle) {
 	AnimationTemplate *AnimationTemplatePtr = new AnimationTemplate(Reader, Handle);
 
 	if (AnimationTemplatePtr->IsValid()) {
@@ -133,7 +133,7 @@ AnimationTemplate::AnimationTemplate(const AnimationTemplate &Other) {
 
 // -----------------------------------------------------------------------------
 
-AnimationTemplate::AnimationTemplate(BS_InputPersistenceBlock &Reader, unsigned int Handle) {
+AnimationTemplate::AnimationTemplate(InputPersistenceBlock &Reader, unsigned int Handle) {
 	// Objekt registrieren.
 	AnimationTemplateRegistry::GetInstance().RegisterObject(this, Handle);
 
@@ -144,9 +144,9 @@ AnimationTemplate::AnimationTemplate(BS_InputPersistenceBlock &Reader, unsigned
 // -----------------------------------------------------------------------------
 
 AnimationResource *AnimationTemplate::RequestSourceAnimation(const Common::String &SourceAnimation) const {
-	BS_ResourceManager *RMPtr = BS_Kernel::GetInstance()->GetResourceManager();
-	BS_Resource *ResourcePtr;
-	if (NULL == (ResourcePtr = RMPtr->RequestResource(SourceAnimation)) || ResourcePtr->GetType() != BS_Resource::TYPE_ANIMATION) {
+	ResourceManager *RMPtr = Kernel::GetInstance()->GetResourceManager();
+	Resource *ResourcePtr;
+	if (NULL == (ResourcePtr = RMPtr->RequestResource(SourceAnimation)) || ResourcePtr->GetType() != Resource::TYPE_ANIMATION) {
 		BS_LOG_ERRORLN("The resource \"%s\" could not be requested or is has an invalid type. The animation template can't be created.", SourceAnimation.c_str());
 		return 0;
 	}
@@ -212,7 +212,7 @@ void AnimationTemplate::SetFPS(int FPS) {
 
 // -----------------------------------------------------------------------------
 
-bool AnimationTemplate::Persist(BS_OutputPersistenceBlock &Writer) {
+bool AnimationTemplate::Persist(OutputPersistenceBlock &Writer) {
 	bool Result = true;
 
 	// Parent persistieren.
@@ -242,7 +242,7 @@ bool AnimationTemplate::Persist(BS_OutputPersistenceBlock &Writer) {
 
 // -----------------------------------------------------------------------------
 
-bool AnimationTemplate::Unpersist(BS_InputPersistenceBlock &Reader) {
+bool AnimationTemplate::Unpersist(InputPersistenceBlock &Reader) {
 	bool Result = true;
 
 	// Parent wieder herstellen.
diff --git a/engines/sword25/gfx/animationtemplate.h b/engines/sword25/gfx/animationtemplate.h
index 63e09bc20a..1a5e8813a9 100644
--- a/engines/sword25/gfx/animationtemplate.h
+++ b/engines/sword25/gfx/animationtemplate.h
@@ -63,13 +63,13 @@ class AnimationTemplate : public AnimationDescription {
 public:
 	static unsigned int Create(const Common::String &SourceAnimation);
 	static unsigned int Create(const AnimationTemplate &Other);
-	static unsigned int Create(BS_InputPersistenceBlock &Reader, unsigned int Handle);
+	static unsigned int Create(InputPersistenceBlock &Reader, unsigned int Handle);
 	AnimationTemplate *ResolveHandle(unsigned int Handle) const;
 
 private:
 	AnimationTemplate(const Common::String &SourceAnimation);
 	AnimationTemplate(const AnimationTemplate &Other);
-	AnimationTemplate(BS_InputPersistenceBlock &Reader, unsigned int Handle);
+	AnimationTemplate(InputPersistenceBlock &Reader, unsigned int Handle);
 
 public:
 	~AnimationTemplate();
@@ -119,8 +119,8 @@ public:
 	*/
 	void SetFPS(int FPS);
 
-	virtual bool Persist(BS_OutputPersistenceBlock &Writer);
-	virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
+	virtual bool Persist(OutputPersistenceBlock &Writer);
+	virtual bool Unpersist(InputPersistenceBlock &Reader);
 
 private:
 	Common::Array<Frame>  m_Frames;
diff --git a/engines/sword25/gfx/animationtemplateregistry.cpp b/engines/sword25/gfx/animationtemplateregistry.cpp
index d15a1947e8..ee0713d13a 100644
--- a/engines/sword25/gfx/animationtemplateregistry.cpp
+++ b/engines/sword25/gfx/animationtemplateregistry.cpp
@@ -69,7 +69,7 @@ void AnimationTemplateRegistry::LogWarningLn(const char *Message) const {
 
 // -----------------------------------------------------------------------------
 
-bool AnimationTemplateRegistry::Persist(BS_OutputPersistenceBlock &Writer) {
+bool AnimationTemplateRegistry::Persist(OutputPersistenceBlock &Writer) {
 	bool Result = true;
 
 	// Das nächste zu vergebene Handle schreiben.
@@ -95,7 +95,7 @@ bool AnimationTemplateRegistry::Persist(BS_OutputPersistenceBlock &Writer) {
 
 // -----------------------------------------------------------------------------
 
-bool AnimationTemplateRegistry::Unpersist(BS_InputPersistenceBlock &Reader) {
+bool AnimationTemplateRegistry::Unpersist(InputPersistenceBlock &Reader) {
 	bool Result = true;
 
 	// Das nächste zu vergebene Handle wieder herstellen.
diff --git a/engines/sword25/gfx/animationtemplateregistry.h b/engines/sword25/gfx/animationtemplateregistry.h
index b5947a8841..0aaa0d3728 100644
--- a/engines/sword25/gfx/animationtemplateregistry.h
+++ b/engines/sword25/gfx/animationtemplateregistry.h
@@ -59,15 +59,15 @@ class AnimationTemplate;
 // Klassendeklaration
 // -----------------------------------------------------------------------------
 
-class AnimationTemplateRegistry : public BS_ObjectRegistry<AnimationTemplate>, public BS_Persistable {
+class AnimationTemplateRegistry : public ObjectRegistry<AnimationTemplate>, public Persistable {
 public:
 	static AnimationTemplateRegistry &GetInstance() {
 		if (!m_InstancePtr.get()) m_InstancePtr.reset(new AnimationTemplateRegistry);
 		return *m_InstancePtr.get();
 	}
 
-	virtual bool Persist(BS_OutputPersistenceBlock &Writer);
-	virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
+	virtual bool Persist(OutputPersistenceBlock &Writer);
+	virtual bool Unpersist(InputPersistenceBlock &Reader);
 
 private:
 	virtual void LogErrorLn(const char *Message) const;
diff --git a/engines/sword25/gfx/bitmap.cpp b/engines/sword25/gfx/bitmap.cpp
index d5354d534d..07bfbd11a9 100644
--- a/engines/sword25/gfx/bitmap.cpp
+++ b/engines/sword25/gfx/bitmap.cpp
@@ -174,7 +174,7 @@ void Bitmap::SetFlipV(bool FlipV) {
 // Persistenz
 // -----------------------------------------------------------------------------
 
-bool Bitmap::Persist(BS_OutputPersistenceBlock &Writer) {
+bool Bitmap::Persist(OutputPersistenceBlock &Writer) {
 	bool Result = true;
 
 	Result &= RenderObject::Persist(Writer);
@@ -191,7 +191,7 @@ bool Bitmap::Persist(BS_OutputPersistenceBlock &Writer) {
 
 // -----------------------------------------------------------------------------
 
-bool Bitmap::Unpersist(BS_InputPersistenceBlock &Reader) {
+bool Bitmap::Unpersist(InputPersistenceBlock &Reader) {
 	bool Result = true;
 
 	Result &= RenderObject::Unpersist(Reader);
diff --git a/engines/sword25/gfx/bitmap.h b/engines/sword25/gfx/bitmap.h
index 01d1b288da..77fe08342b 100644
--- a/engines/sword25/gfx/bitmap.h
+++ b/engines/sword25/gfx/bitmap.h
@@ -179,8 +179,8 @@ public:
 	virtual bool    IsColorModulationAllowed() const = 0;
 	virtual bool    IsSetContentAllowed() const = 0;
 
-	virtual bool    Persist(BS_OutputPersistenceBlock &Writer);
-	virtual bool    Unpersist(BS_InputPersistenceBlock &Reader);
+	virtual bool    Persist(OutputPersistenceBlock &Writer);
+	virtual bool    Unpersist(InputPersistenceBlock &Reader);
 
 protected:
 	bool            m_FlipH;
diff --git a/engines/sword25/gfx/bitmapresource.cpp b/engines/sword25/gfx/bitmapresource.cpp
index 4470cccb9f..0db6110fad 100644
--- a/engines/sword25/gfx/bitmapresource.cpp
+++ b/engines/sword25/gfx/bitmapresource.cpp
@@ -50,7 +50,7 @@ namespace Sword25 {
 BitmapResource::BitmapResource(const Common::String &Filename, Image *pImage) :
 	m_Valid(false),
 	m_pImage(pImage),
-	BS_Resource(Filename, BS_Resource::TYPE_BITMAP) {
+	Resource(Filename, Resource::TYPE_BITMAP) {
 	m_Valid = m_pImage != 0;
 }
 
diff --git a/engines/sword25/gfx/bitmapresource.h b/engines/sword25/gfx/bitmapresource.h
index 75bdf161f5..11d854ea08 100644
--- a/engines/sword25/gfx/bitmapresource.h
+++ b/engines/sword25/gfx/bitmapresource.h
@@ -48,7 +48,7 @@ namespace Sword25 {
 
 class BS_Rect;
 
-class BitmapResource : public BS_Resource {
+class BitmapResource : public Resource {
 public:
 	/**
 	    @brief Die möglichen Flippingparameter für die Blit-Methode.
diff --git a/engines/sword25/gfx/dynamicbitmap.cpp b/engines/sword25/gfx/dynamicbitmap.cpp
index c0d307bca4..ad35b34962 100644
--- a/engines/sword25/gfx/dynamicbitmap.cpp
+++ b/engines/sword25/gfx/dynamicbitmap.cpp
@@ -65,7 +65,7 @@ DynamicBitmap::DynamicBitmap(RenderObjectPtr<RenderObject> ParentPtr, unsigned i
 
 // -----------------------------------------------------------------------------
 
-DynamicBitmap::DynamicBitmap(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) :
+DynamicBitmap::DynamicBitmap(InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) :
 	Bitmap(ParentPtr, TYPE_DYNAMICBITMAP, Handle) {
 	m_InitSuccess = Unpersist(Reader);
 }
@@ -101,7 +101,7 @@ unsigned int DynamicBitmap::GetPixel(int X, int Y) const {
 
 bool DynamicBitmap::DoRender() {
 	// Framebufferobjekt holen
-	GraphicEngine *pGfx = static_cast<GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
+	GraphicEngine *pGfx = static_cast<GraphicEngine *>(Kernel::GetInstance()->GetService("gfx"));
 	BS_ASSERT(pGfx);
 
 	// Bitmap zeichnen
@@ -157,7 +157,7 @@ bool DynamicBitmap::IsSetContentAllowed() const {
 // Persistenz
 // -----------------------------------------------------------------------------
 
-bool DynamicBitmap::Persist(BS_OutputPersistenceBlock &Writer) {
+bool DynamicBitmap::Persist(OutputPersistenceBlock &Writer) {
 	bool Result = true;
 
 	Result &= Bitmap::Persist(Writer);
@@ -171,7 +171,7 @@ bool DynamicBitmap::Persist(BS_OutputPersistenceBlock &Writer) {
 	return Result;
 }
 
-bool DynamicBitmap::Unpersist(BS_InputPersistenceBlock &Reader) {
+bool DynamicBitmap::Unpersist(InputPersistenceBlock &Reader) {
 	bool Result = true;
 
 	Result &= Bitmap::Unpersist(Reader);
diff --git a/engines/sword25/gfx/dynamicbitmap.h b/engines/sword25/gfx/dynamicbitmap.h
index 4cc47b14a5..76fa585c8a 100644
--- a/engines/sword25/gfx/dynamicbitmap.h
+++ b/engines/sword25/gfx/dynamicbitmap.h
@@ -69,15 +69,15 @@ public:
 	virtual bool    IsColorModulationAllowed() const;
 	virtual bool    IsSetContentAllowed() const;
 
-	virtual bool    Persist(BS_OutputPersistenceBlock &Writer);
-	virtual bool    Unpersist(BS_InputPersistenceBlock &Reader);
+	virtual bool    Persist(OutputPersistenceBlock &Writer);
+	virtual bool    Unpersist(InputPersistenceBlock &Reader);
 
 protected:
 	virtual bool    DoRender();
 
 private:
 	DynamicBitmap(RenderObjectPtr<RenderObject> ParentPtr, unsigned int Width, unsigned int Height);
-	DynamicBitmap(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle);
+	DynamicBitmap(InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle);
 
 	bool CreateGLImage(unsigned int Width, unsigned int Height);
 
diff --git a/engines/sword25/gfx/fontresource.cpp b/engines/sword25/gfx/fontresource.cpp
index 6d2a7a99a5..a398c0a6d6 100644
--- a/engines/sword25/gfx/fontresource.cpp
+++ b/engines/sword25/gfx/fontresource.cpp
@@ -60,10 +60,10 @@ static const unsigned int DEFAULT_GAPWIDTH = 1;
 // Konstruktion / Destruktion
 // -----------------------------------------------------------------------------
 
-FontResource::FontResource(BS_Kernel *pKernel, const Common::String &FileName) :
+FontResource::FontResource(Kernel *pKernel, const Common::String &FileName) :
 	_pKernel(pKernel),
 	_Valid(false),
-	BS_Resource(FileName, BS_Resource::TYPE_FONT) {
+	Resource(FileName, Resource::TYPE_FONT) {
 	// XML Fontdatei parsen
 	TiXmlDocument Doc;
 	if (!_ParseXMLDocument(FileName, Doc)) {
diff --git a/engines/sword25/gfx/fontresource.h b/engines/sword25/gfx/fontresource.h
index 8c45219b37..3888927f9c 100644
--- a/engines/sword25/gfx/fontresource.h
+++ b/engines/sword25/gfx/fontresource.h
@@ -52,13 +52,13 @@ namespace Sword25 {
 // Forward declarations
 // -----------------------------------------------------------------------------
 
-class BS_Kernel;
+class Kernel;
 
 // -----------------------------------------------------------------------------
 // Klassendefinition
 // -----------------------------------------------------------------------------
 
-class FontResource : public BS_Resource {
+class FontResource : public Resource {
 public:
 	/**
 	    @brief Erzeugt eine neues Exemplar von BS_FontResource
@@ -66,7 +66,7 @@ public:
 	    @param FileName der Dateiname der zu ladenen Resource
 	    @remark Wenn der Konstruktor erfolgreich ausgeführt werden konnte gibt die Methode IsValid true zurück.
 	*/
-	FontResource(BS_Kernel *pKernel, const Common::String &FileName);
+	FontResource(Kernel *pKernel, const Common::String &FileName);
 
 	/**
 	    @brief Gibt true zurück, wenn das Objekt korrekt initialisiert wurde.
@@ -113,7 +113,7 @@ public:
 	}
 
 private:
-	BS_Kernel *_pKernel;
+	Kernel *_pKernel;
 	bool        _Valid;
 	Common::String  _BitmapFileName;
 	int         _LineHeight;
diff --git a/engines/sword25/gfx/graphicengine.cpp b/engines/sword25/gfx/graphicengine.cpp
index 1f7f253a53..d51157e4ac 100644
--- a/engines/sword25/gfx/graphicengine.cpp
+++ b/engines/sword25/gfx/graphicengine.cpp
@@ -60,7 +60,7 @@ using namespace Lua;
 
 static const unsigned int FRAMETIME_SAMPLE_COUNT = 5;       // Anzahl der Framezeiten über die, die Framezeit gemittelt wird
 
-GraphicEngine::GraphicEngine(BS_Kernel *pKernel) :
+GraphicEngine::GraphicEngine(Kernel *pKernel) :
 	m_Width(0),
 	m_Height(0),
 	m_BitDepth(0),
@@ -70,7 +70,7 @@ GraphicEngine::GraphicEngine(BS_Kernel *pKernel) :
 	m_TimerActive(true),
 	m_FrameTimeSampleSlot(0),
 	m_RepaintedPixels(0),
-	BS_ResourceService(pKernel) {
+	ResourceService(pKernel) {
 	m_FrameTimeSamples.resize(FRAMETIME_SAMPLE_COUNT);
 
 	if (!RegisterScriptBindings())
@@ -83,7 +83,7 @@ GraphicEngine::GraphicEngine(BS_Kernel *pKernel) :
 
 void  GraphicEngine::UpdateLastFrameDuration() {
 	// Aktuelle Zeit holen
-	uint64_t CurrentTime = BS_Kernel::GetInstance()->GetMicroTicks();
+	uint64_t CurrentTime = Kernel::GetInstance()->GetMicroTicks();
 
 	// Verstrichene Zeit seit letztem Frame berechnen und zu große Zeitsprünge ( > 250 msek.) unterbinden
 	// (kann vorkommen bei geladenen Spielständen, während des Debuggings oder Hardwareungenauigkeiten)
@@ -201,14 +201,14 @@ unsigned int GraphicEngine::LuaColorToARGBColor(lua_State *L, int StackIndex) {
 
 // -----------------------------------------------------------------------------
 
-bool GraphicEngine::Persist(BS_OutputPersistenceBlock &Writer) {
+bool GraphicEngine::Persist(OutputPersistenceBlock &Writer) {
 	Writer.Write(m_TimerActive);
 	return true;
 }
 
 // -----------------------------------------------------------------------------
 
-bool GraphicEngine::Unpersist(BS_InputPersistenceBlock &Reader) {
+bool GraphicEngine::Unpersist(InputPersistenceBlock &Reader) {
 	Reader.Read(m_TimerActive);
 	return Reader.IsGood();
 }
diff --git a/engines/sword25/gfx/graphicengine.h b/engines/sword25/gfx/graphicengine.h
index e68969e128..8968cc898e 100644
--- a/engines/sword25/gfx/graphicengine.h
+++ b/engines/sword25/gfx/graphicengine.h
@@ -57,7 +57,7 @@
 
 namespace Sword25 {
 
-class BS_Kernel;
+class Kernel;
 class Image;
 class Panel;
 class Screenshot;
@@ -77,7 +77,7 @@ typedef unsigned int BS_COLOR;
     Die bisher einzige Implementation ist BS_DDrawGfx.
 */
 
-class GraphicEngine : public BS_ResourceService, public BS_Persistable {
+class GraphicEngine : public ResourceService, public Persistable {
 public:
 	// Enums
 	// -----
@@ -358,8 +358,8 @@ public:
 
 	// Persistence Methods
 	// -------------------
-	virtual bool Persist(BS_OutputPersistenceBlock &Writer);
-	virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
+	virtual bool Persist(OutputPersistenceBlock &Writer);
+	virtual bool Unpersist(InputPersistenceBlock &Reader);
 
 	static void ARGBColorToLuaColor(lua_State *L, unsigned int Color);
 	static unsigned int LuaColorToARGBColor(lua_State *L, int StackIndex);
@@ -367,7 +367,7 @@ public:
 protected:
 	// Constructor
 	// -----------
-	GraphicEngine(BS_Kernel *pKernel);
+	GraphicEngine(Kernel *pKernel);
 
 	// Display Variables
 	// -----------------
diff --git a/engines/sword25/gfx/graphicengine_script.cpp b/engines/sword25/gfx/graphicengine_script.cpp
index 92f5750d25..67cbf31889 100644
--- a/engines/sword25/gfx/graphicengine_script.cpp
+++ b/engines/sword25/gfx/graphicengine_script.cpp
@@ -252,7 +252,7 @@ static const luaL_reg ANIMATION_TEMPLATE_METHODS[] = {
 // -----------------------------------------------------------------------------
 
 static GraphicEngine *GetGE() {
-	BS_Kernel *pKernel = BS_Kernel::GetInstance();
+	Kernel *pKernel = Kernel::GetInstance();
 	BS_ASSERT(pKernel);
 	GraphicEngine *pGE = static_cast<GraphicEngine *>(pKernel->GetService("gfx"));
 	BS_ASSERT(pGE);
@@ -1249,7 +1249,7 @@ static int A_IsPlaying(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static bool AnimationLoopPointCallback(unsigned int Handle) {
-	lua_State *L = static_cast<lua_State *>(BS_Kernel::GetInstance()->GetScript()->GetScriptObject());
+	lua_State *L = static_cast<lua_State *>(Kernel::GetInstance()->GetScript()->GetScriptObject());
 	LoopPointCallbackPtr->InvokeCallbackFunctions(L, Handle);
 
 	return true;
@@ -1287,7 +1287,7 @@ static bool AnimationActionCallback(unsigned int Handle) {
 	RenderObjectPtr<Animation> AnimationPtr(Handle);
 	if (AnimationPtr.IsValid()) {
 		ActionCallbackPtr->Action = AnimationPtr->GetCurrentAction();
-		lua_State *L = static_cast<lua_State *>(BS_Kernel::GetInstance()->GetScript()->GetScriptObject());
+		lua_State *L = static_cast<lua_State *>(Kernel::GetInstance()->GetScript()->GetScriptObject());
 		ActionCallbackPtr->InvokeCallbackFunctions(L, AnimationPtr->GetHandle());
 	}
 
@@ -1323,7 +1323,7 @@ static int A_UnregisterActionCallback(lua_State *L) {
 // -----------------------------------------------------------------------------
 
 static bool AnimationDeleteCallback(unsigned int Handle) {
-	lua_State *L = static_cast<lua_State *>(BS_Kernel::GetInstance()->GetScript()->GetScriptObject());
+	lua_State *L = static_cast<lua_State *>(Kernel::GetInstance()->GetScript()->GetScriptObject());
 	LoopPointCallbackPtr->RemoveAllObjectCallbacks(L, Handle);
 
 	return true;
@@ -1526,7 +1526,7 @@ static const luaL_reg TEXT_METHODS[] = {
 // -----------------------------------------------------------------------------
 
 bool GraphicEngine::RegisterScriptBindings() {
-	BS_Kernel *pKernel = BS_Kernel::GetInstance();
+	Kernel *pKernel = Kernel::GetInstance();
 	BS_ASSERT(pKernel);
 	ScriptEngine *pScript = static_cast<ScriptEngine *>(pKernel->GetService("script"));
 	BS_ASSERT(pScript);
diff --git a/engines/sword25/gfx/opengl/glimage.cpp b/engines/sword25/gfx/opengl/glimage.cpp
index 0d17eb1758..a690cc19ee 100644
--- a/engines/sword25/gfx/opengl/glimage.cpp
+++ b/engines/sword25/gfx/opengl/glimage.cpp
@@ -57,10 +57,10 @@ GLImage::GLImage(const Common::String &Filename, bool &Result) :
 	m_Height(0) {
 	Result = false;
 
-	PackageManager *pPackage = static_cast<PackageManager *>(BS_Kernel::GetInstance()->GetService("package"));
+	PackageManager *pPackage = static_cast<PackageManager *>(Kernel::GetInstance()->GetService("package"));
 	BS_ASSERT(pPackage);
 
-	_backSurface = (static_cast<GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx")))->getSurface();
+	_backSurface = (static_cast<GraphicEngine *>(Kernel::GetInstance()->GetService("gfx")))->getSurface();
 
 	// Datei laden
 	char *pFileData;
diff --git a/engines/sword25/gfx/opengl/openglgfx.cpp b/engines/sword25/gfx/opengl/openglgfx.cpp
index c30fc8ed0d..e73654ce95 100644
--- a/engines/sword25/gfx/opengl/openglgfx.cpp
+++ b/engines/sword25/gfx/opengl/openglgfx.cpp
@@ -73,7 +73,7 @@ const Common::String B25S_EXTENSION(".b25s");
 // CONSTRUCTION / DESTRUCTION
 // -----------------------------------------------------------------------------
 
-OpenGLGfx::OpenGLGfx(BS_Kernel *pKernel) :
+OpenGLGfx::OpenGLGfx(Kernel *pKernel) :
 	GraphicEngine(pKernel),
 	m_GLspritesInitialized(false) {
 }
@@ -86,7 +86,7 @@ OpenGLGfx::~OpenGLGfx() {
 
 // -----------------------------------------------------------------------------
 
-BS_Service *OpenGLGfx_CreateObject(BS_Kernel *pKernel) {
+Service *OpenGLGfx_CreateObject(Kernel *pKernel) {
 	return new OpenGLGfx(pKernel);
 }
 
@@ -285,7 +285,7 @@ void OpenGLGfx::FlipImagedataVertical(unsigned int Width, unsigned int Height, b
 // RESOURCE MANAGING
 // -----------------------------------------------------------------------------
 
-BS_Resource *OpenGLGfx::LoadResource(const Common::String &FileName) {
+Resource *OpenGLGfx::LoadResource(const Common::String &FileName) {
 	BS_ASSERT(CanLoadResource(FileName));
 
 	// Bild für den Softwarebuffer laden
@@ -328,7 +328,7 @@ BS_Resource *OpenGLGfx::LoadResource(const Common::String &FileName) {
 	// Vectorgraphik laden
 	if (FileName.hasSuffix(SWF_EXTENSION)) {
 		// Pointer auf Package-Manager holen
-		PackageManager *pPackage = BS_Kernel::GetInstance()->GetPackage();
+		PackageManager *pPackage = Kernel::GetInstance()->GetPackage();
 		BS_ASSERT(pPackage);
 
 		// Datei laden
@@ -371,7 +371,7 @@ BS_Resource *OpenGLGfx::LoadResource(const Common::String &FileName) {
 
 	// Font laden
 	if (FileName.hasSuffix(FNT_EXTENSION)) {
-		FontResource *pResource = new FontResource(BS_Kernel::GetInstance(), FileName);
+		FontResource *pResource = new FontResource(Kernel::GetInstance(), FileName);
 		if (pResource->IsValid())
 			return pResource;
 		else {
@@ -407,7 +407,7 @@ void OpenGLGfx::DrawDebugLine(const Vertex &Start, const Vertex &End, unsigned i
 // PERSISTENZ
 // -----------------------------------------------------------------------------
 
-bool OpenGLGfx::Persist(BS_OutputPersistenceBlock &Writer) {
+bool OpenGLGfx::Persist(OutputPersistenceBlock &Writer) {
 	bool result = true;
 
 	result &= GraphicEngine::Persist(Writer);
@@ -418,7 +418,7 @@ bool OpenGLGfx::Persist(BS_OutputPersistenceBlock &Writer) {
 
 // -----------------------------------------------------------------------------
 
-bool OpenGLGfx::Unpersist(BS_InputPersistenceBlock &Reader) {
+bool OpenGLGfx::Unpersist(InputPersistenceBlock &Reader) {
 	bool result = true;
 
 	result &= GraphicEngine::Unpersist(Reader);
diff --git a/engines/sword25/gfx/opengl/openglgfx.h b/engines/sword25/gfx/opengl/openglgfx.h
index c96fa381d6..5b480491c5 100644
--- a/engines/sword25/gfx/opengl/openglgfx.h
+++ b/engines/sword25/gfx/opengl/openglgfx.h
@@ -49,9 +49,9 @@ namespace Sword25 {
 // FORWARD DECLARATIONS
 // -----------------------------------------------------------------------------
 
-class BS_Kernel;
-class BS_Service;
-class BS_Resource;
+class Kernel;
+class Service;
+class Resource;
 class Panel;
 class BS_Image;
 class RenderObjectManager;
@@ -63,7 +63,7 @@ class RenderObjectManager;
 
 class OpenGLGfx : public GraphicEngine {
 public:
-	OpenGLGfx(BS_Kernel *pKernel);
+	OpenGLGfx(Kernel *pKernel);
 	virtual ~OpenGLGfx();
 
 	// Interface
@@ -82,7 +82,7 @@ public:
 
 	// Resource-Managing Methoden
 	// --------------------------
-	virtual BS_Resource    *LoadResource(const Common::String &FileName);
+	virtual Resource    *LoadResource(const Common::String &FileName);
 	virtual bool            CanLoadResource(const Common::String &FileName);
 
 	// Debugging Methoden
@@ -91,8 +91,8 @@ public:
 
 	// Persistenz Methoden
 	// -------------------
-	virtual bool Persist(BS_OutputPersistenceBlock &Writer);
-	virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
+	virtual bool Persist(OutputPersistenceBlock &Writer);
+	virtual bool Unpersist(InputPersistenceBlock &Reader);
 
 private:
 	bool                m_GLspritesInitialized;
diff --git a/engines/sword25/gfx/opengl/swimage.cpp b/engines/sword25/gfx/opengl/swimage.cpp
index 1244cc3879..5fa579365b 100644
--- a/engines/sword25/gfx/opengl/swimage.cpp
+++ b/engines/sword25/gfx/opengl/swimage.cpp
@@ -56,7 +56,7 @@ SWImage::SWImage(const Common::String &Filename, bool &Result) :
 	m_Height(0) {
 	Result = false;
 
-	PackageManager *pPackage = static_cast<PackageManager *>(BS_Kernel::GetInstance()->GetService("package"));
+	PackageManager *pPackage = static_cast<PackageManager *>(Kernel::GetInstance()->GetService("package"));
 	BS_ASSERT(pPackage);
 
 	// Datei laden
diff --git a/engines/sword25/gfx/panel.cpp b/engines/sword25/gfx/panel.cpp
index c7c7f0b817..4f1d6ea546 100644
--- a/engines/sword25/gfx/panel.cpp
+++ b/engines/sword25/gfx/panel.cpp
@@ -76,7 +76,7 @@ Panel::Panel(RenderObjectPtr<RenderObject> ParentPtr, int Width, int Height, uns
 
 // -----------------------------------------------------------------------------
 
-Panel::Panel(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) :
+Panel::Panel(InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) :
 	RenderObject(ParentPtr, RenderObject::TYPE_PANEL, Handle) {
 	m_InitSuccess = Unpersist(Reader);
 }
@@ -94,7 +94,7 @@ bool Panel::DoRender() {
 	// Falls der Alphawert 0 ist, ist das Panel komplett durchsichtig und es muss nichts gezeichnet werden.
 	if (m_Color >> 24 == 0) return true;
 
-	GraphicEngine *GfxPtr = static_cast<GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
+	GraphicEngine *GfxPtr = static_cast<GraphicEngine *>(Kernel::GetInstance()->GetService("gfx"));
 	BS_ASSERT(GfxPtr);
 
 	return GfxPtr->Fill(&m_BBox, m_Color);
@@ -104,7 +104,7 @@ bool Panel::DoRender() {
 // Persistenz
 // -----------------------------------------------------------------------------
 
-bool Panel::Persist(BS_OutputPersistenceBlock &Writer) {
+bool Panel::Persist(OutputPersistenceBlock &Writer) {
 	bool Result = true;
 
 	Result &= RenderObject::Persist(Writer);
@@ -117,7 +117,7 @@ bool Panel::Persist(BS_OutputPersistenceBlock &Writer) {
 
 // -----------------------------------------------------------------------------
 
-bool Panel::Unpersist(BS_InputPersistenceBlock &Reader) {
+bool Panel::Unpersist(InputPersistenceBlock &Reader) {
 	bool Result = true;
 
 	Result &= RenderObject::Unpersist(Reader);
diff --git a/engines/sword25/gfx/panel.h b/engines/sword25/gfx/panel.h
index 4e318dd7b1..c9da50d72a 100644
--- a/engines/sword25/gfx/panel.h
+++ b/engines/sword25/gfx/panel.h
@@ -53,7 +53,7 @@ class Panel : public RenderObject {
 
 private:
 	Panel(RenderObjectPtr<RenderObject> ParentPtr, int Width, int Height, unsigned int Color);
-	Panel(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle);
+	Panel(InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle);
 
 public:
 	virtual ~Panel();
@@ -66,8 +66,8 @@ public:
 		ForceRefresh();
 	}
 
-	virtual bool Persist(BS_OutputPersistenceBlock &Writer);
-	virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
+	virtual bool Persist(OutputPersistenceBlock &Writer);
+	virtual bool Unpersist(InputPersistenceBlock &Reader);
 
 protected:
 	virtual bool DoRender();
diff --git a/engines/sword25/gfx/renderobject.cpp b/engines/sword25/gfx/renderobject.cpp
index af44117e70..e6b7e2eee9 100644
--- a/engines/sword25/gfx/renderobject.cpp
+++ b/engines/sword25/gfx/renderobject.cpp
@@ -383,7 +383,7 @@ RenderObjectPtr<Text> RenderObject::AddText(const Common::String &Font, const Co
 // Persistenz-Methoden
 // -------------------
 
-bool RenderObject::Persist(BS_OutputPersistenceBlock &Writer) {
+bool RenderObject::Persist(OutputPersistenceBlock &Writer) {
 	// Typ und Handle werden als erstes gespeichert, damit beim Laden ein Objekt vom richtigen Typ mit dem richtigen Handle erzeugt werden kann.
 	Writer.Write(static_cast<unsigned int>(m_Type));
 	Writer.Write(m_Handle);
@@ -419,7 +419,7 @@ bool RenderObject::Persist(BS_OutputPersistenceBlock &Writer) {
 
 // -----------------------------------------------------------------------------
 
-bool RenderObject::Unpersist(BS_InputPersistenceBlock &Reader) {
+bool RenderObject::Unpersist(InputPersistenceBlock &Reader) {
 	// Typ und Handle wurden schon von RecreatePersistedRenderObject() ausgelesen. Jetzt werden die restlichen Objekteigenschaften ausgelesen.
 	Reader.Read(m_X);
 	Reader.Read(m_Y);
@@ -456,7 +456,7 @@ bool RenderObject::Unpersist(BS_InputPersistenceBlock &Reader) {
 
 // -----------------------------------------------------------------------------
 
-bool RenderObject::PersistChildren(BS_OutputPersistenceBlock &Writer) {
+bool RenderObject::PersistChildren(OutputPersistenceBlock &Writer) {
 	bool Result = true;
 
 	// Kinderanzahl speichern.
@@ -474,7 +474,7 @@ bool RenderObject::PersistChildren(BS_OutputPersistenceBlock &Writer) {
 
 // -----------------------------------------------------------------------------
 
-bool RenderObject::UnpersistChildren(BS_InputPersistenceBlock &Reader) {
+bool RenderObject::UnpersistChildren(InputPersistenceBlock &Reader) {
 	bool Result = true;
 
 	// Kinderanzahl einlesen.
@@ -492,7 +492,7 @@ bool RenderObject::UnpersistChildren(BS_InputPersistenceBlock &Reader) {
 
 // -----------------------------------------------------------------------------
 
-RenderObjectPtr<RenderObject> RenderObject::RecreatePersistedRenderObject(BS_InputPersistenceBlock &Reader) {
+RenderObjectPtr<RenderObject> RenderObject::RecreatePersistedRenderObject(InputPersistenceBlock &Reader) {
 	RenderObjectPtr<RenderObject> Result;
 
 	// Typ und Handle auslesen.
diff --git a/engines/sword25/gfx/renderobject.h b/engines/sword25/gfx/renderobject.h
index 0007e157a0..3a824d9012 100644
--- a/engines/sword25/gfx/renderobject.h
+++ b/engines/sword25/gfx/renderobject.h
@@ -59,7 +59,7 @@ namespace Sword25 {
 // Forward Declarations
 // -----------------------------------------------------------------------------
 
-class BS_Kernel;
+class Kernel;
 class RenderObjectManager;
 class Bitmap;
 class Animation;
@@ -354,13 +354,13 @@ public:
 
 	// Persistenz-Methoden
 	// -------------------
-	virtual bool Persist(BS_OutputPersistenceBlock &Writer);
-	virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
+	virtual bool Persist(OutputPersistenceBlock &Writer);
+	virtual bool Unpersist(InputPersistenceBlock &Reader);
 	// TODO: Evtl. protected
-	bool PersistChildren(BS_OutputPersistenceBlock &Writer);
-	bool UnpersistChildren(BS_InputPersistenceBlock &Reader);
+	bool PersistChildren(OutputPersistenceBlock &Writer);
+	bool UnpersistChildren(InputPersistenceBlock &Reader);
 	// TODO: Evtl. private
-	RenderObjectPtr<RenderObject> RecreatePersistedRenderObject(BS_InputPersistenceBlock &Reader);
+	RenderObjectPtr<RenderObject> RecreatePersistedRenderObject(InputPersistenceBlock &Reader);
 
 protected:
 	// Typen
diff --git a/engines/sword25/gfx/renderobjectmanager.cpp b/engines/sword25/gfx/renderobjectmanager.cpp
index 5d1147ea88..72afd856c3 100644
--- a/engines/sword25/gfx/renderobjectmanager.cpp
+++ b/engines/sword25/gfx/renderobjectmanager.cpp
@@ -77,7 +77,7 @@ void RenderObjectManager::StartFrame() {
 	m_FrameStarted = true;
 
 	// Verstrichene Zeit bestimmen
-	int TimeElapsed = BS_Kernel::GetInstance()->GetGfx()->GetLastFrameDurationMicro();
+	int TimeElapsed = Kernel::GetInstance()->GetGfx()->GetLastFrameDurationMicro();
 
 	// Alle BS_TimedRenderObject Objekte über den Framestart und die verstrichene Zeit in Kenntnis setzen
 	RenderObjectList::iterator Iter = m_TimedRenderObjects.begin();
@@ -119,7 +119,7 @@ void RenderObjectManager::DetatchTimedRenderObject(RenderObjectPtr<TimedRenderOb
 // Persistenz
 // -----------------------------------------------------------------------------
 
-bool RenderObjectManager::Persist(BS_OutputPersistenceBlock &Writer) {
+bool RenderObjectManager::Persist(OutputPersistenceBlock &Writer) {
 	bool Result = true;
 
 	// Alle Kinder des Wurzelknotens speichern. Dadurch werden alle BS_RenderObjects gespeichert rekursiv gespeichert.
@@ -143,7 +143,7 @@ bool RenderObjectManager::Persist(BS_OutputPersistenceBlock &Writer) {
 
 // -----------------------------------------------------------------------------
 
-bool RenderObjectManager::Unpersist(BS_InputPersistenceBlock &Reader) {
+bool RenderObjectManager::Unpersist(InputPersistenceBlock &Reader) {
 	bool Result = true;
 
 	// Alle Kinder des Wurzelknotens löschen. Damit werden alle BS_RenderObjects gelöscht.
diff --git a/engines/sword25/gfx/renderobjectmanager.h b/engines/sword25/gfx/renderobjectmanager.h
index 71aa75a1a9..76bb4639ec 100644
--- a/engines/sword25/gfx/renderobjectmanager.h
+++ b/engines/sword25/gfx/renderobjectmanager.h
@@ -57,7 +57,7 @@
 namespace Sword25 {
 
 // Klassendefinition
-class BS_Kernel;
+class Kernel;
 class BS_Rect;
 class RenderObject;
 class TimedRenderObject;
@@ -68,7 +68,7 @@ class TimedRenderObject;
     Sie sorgt dafür, dass die BS_RenderObjects in der richtigen Reihenfolge gerendert werden und ermöglicht den Zugriff auf die
     BS_RenderObjects über einen String.
 */
-class RenderObjectManager : public BS_Persistable {
+class RenderObjectManager : public Persistable {
 public:
 	/**
 	    @brief Erzeugt ein neues BS_RenderObjectManager-Objekt.
@@ -115,8 +115,8 @@ public:
 	*/
 	void DetatchTimedRenderObject(RenderObjectPtr<TimedRenderObject> pRenderObject);
 
-	virtual bool Persist(BS_OutputPersistenceBlock &Writer);
-	virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
+	virtual bool Persist(OutputPersistenceBlock &Writer);
+	virtual bool Unpersist(InputPersistenceBlock &Reader);
 
 private:
 	bool m_FrameStarted;
diff --git a/engines/sword25/gfx/renderobjectregistry.h b/engines/sword25/gfx/renderobjectregistry.h
index c3a8ab3f29..ff2ba57316 100644
--- a/engines/sword25/gfx/renderobjectregistry.h
+++ b/engines/sword25/gfx/renderobjectregistry.h
@@ -58,7 +58,7 @@ class RenderObject;
 // Klassendeklaration
 // -----------------------------------------------------------------------------
 
-class RenderObjectRegistry : public BS_ObjectRegistry<RenderObject> {
+class RenderObjectRegistry : public ObjectRegistry<RenderObject> {
 public:
 	static RenderObjectRegistry &GetInstance() {
 		if (!m_InstancePtr.get()) m_InstancePtr.reset(new RenderObjectRegistry);
diff --git a/engines/sword25/gfx/rootrenderobject.h b/engines/sword25/gfx/rootrenderobject.h
index a4a78f24d9..76665c9444 100644
--- a/engines/sword25/gfx/rootrenderobject.h
+++ b/engines/sword25/gfx/rootrenderobject.h
@@ -45,7 +45,7 @@ namespace Sword25 {
 // Forward Declarations
 // -----------------------------------------------------------------------------
 
-class BS_Kernel;
+class Kernel;
 
 // Klassendefinition
 class RenderObjectManager;
diff --git a/engines/sword25/gfx/staticbitmap.cpp b/engines/sword25/gfx/staticbitmap.cpp
index 575adcd03b..b2d3678f57 100644
--- a/engines/sword25/gfx/staticbitmap.cpp
+++ b/engines/sword25/gfx/staticbitmap.cpp
@@ -64,7 +64,7 @@ StaticBitmap::StaticBitmap(RenderObjectPtr<RenderObject> ParentPtr, const Common
 
 // -----------------------------------------------------------------------------
 
-StaticBitmap::StaticBitmap(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) :
+StaticBitmap::StaticBitmap(InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) :
 	Bitmap(ParentPtr, TYPE_STATICBITMAP, Handle) {
 	m_InitSuccess = Unpersist(Reader);
 }
@@ -73,12 +73,12 @@ StaticBitmap::StaticBitmap(BS_InputPersistenceBlock &Reader, RenderObjectPtr<Ren
 
 bool StaticBitmap::InitBitmapResource(const Common::String &Filename) {
 	// Bild-Resource laden
-	BS_Resource *ResourcePtr = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(Filename);
+	Resource *ResourcePtr = Kernel::GetInstance()->GetResourceManager()->RequestResource(Filename);
 	if (!ResourcePtr) {
 		BS_LOG_ERRORLN("Could not request resource \"%s\".", Filename.c_str());
 		return false;
 	}
-	if (ResourcePtr->GetType() != BS_Resource::TYPE_BITMAP) {
+	if (ResourcePtr->GetType() != Resource::TYPE_BITMAP) {
 		BS_LOG_ERRORLN("Requested resource \"%s\" is not a bitmap.", Filename.c_str());
 		return false;
 	}
@@ -107,13 +107,13 @@ StaticBitmap::~StaticBitmap() {
 
 bool StaticBitmap::DoRender() {
 	// Bitmap holen
-	BS_Resource *ResourcePtr = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
+	Resource *ResourcePtr = Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
 	BS_ASSERT(ResourcePtr);
-	BS_ASSERT(ResourcePtr->GetType() == BS_Resource::TYPE_BITMAP);
+	BS_ASSERT(ResourcePtr->GetType() == Resource::TYPE_BITMAP);
 	BitmapResource *BitmapResourcePtr = static_cast<BitmapResource *>(ResourcePtr);
 
 	// Framebufferobjekt holen
-	GraphicEngine *GfxPtr = static_cast<GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
+	GraphicEngine *GfxPtr = static_cast<GraphicEngine *>(Kernel::GetInstance()->GetService("gfx"));
 	BS_ASSERT(GfxPtr);
 
 	// Bitmap zeichnen
@@ -142,8 +142,8 @@ unsigned int StaticBitmap::GetPixel(int X, int Y) const {
 	BS_ASSERT(X >= 0 && X < m_Width);
 	BS_ASSERT(Y >= 0 && Y < m_Height);
 
-	BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
-	BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP);
+	Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
+	BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
 	BitmapResource *pBitmapResource = static_cast<BitmapResource *>(pResource);
 	unsigned int Result = pBitmapResource->GetPixel(X, Y);
 	pResource->Release();
@@ -162,8 +162,8 @@ bool StaticBitmap::SetContent(const byte *Pixeldata, uint size, unsigned int Off
 // -----------------------------------------------------------------------------
 
 bool StaticBitmap::IsAlphaAllowed() const {
-	BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
-	BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP);
+	Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
+	BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
 	bool Result = static_cast<BitmapResource *>(pResource)->IsAlphaAllowed();
 	pResource->Release();
 	return Result;
@@ -172,8 +172,8 @@ bool StaticBitmap::IsAlphaAllowed() const {
 // -----------------------------------------------------------------------------
 
 bool StaticBitmap::IsColorModulationAllowed() const {
-	BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
-	BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP);
+	Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
+	BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
 	bool Result = static_cast<BitmapResource *>(pResource)->IsColorModulationAllowed();
 	pResource->Release();
 	return Result;
@@ -182,8 +182,8 @@ bool StaticBitmap::IsColorModulationAllowed() const {
 // -----------------------------------------------------------------------------
 
 bool StaticBitmap::IsScalingAllowed() const {
-	BS_Resource *pResource = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
-	BS_ASSERT(pResource->GetType() == BS_Resource::TYPE_BITMAP);
+	Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(m_ResourceFilename);
+	BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
 	bool Result = static_cast<BitmapResource *>(pResource)->IsScalingAllowed();
 	pResource->Release();
 	return Result;
@@ -193,7 +193,7 @@ bool StaticBitmap::IsScalingAllowed() const {
 // Persistenz
 // -----------------------------------------------------------------------------
 
-bool StaticBitmap::Persist(BS_OutputPersistenceBlock &Writer) {
+bool StaticBitmap::Persist(OutputPersistenceBlock &Writer) {
 	bool Result = true;
 
 	Result &= Bitmap::Persist(Writer);
@@ -204,7 +204,7 @@ bool StaticBitmap::Persist(BS_OutputPersistenceBlock &Writer) {
 	return Result;
 }
 
-bool StaticBitmap::Unpersist(BS_InputPersistenceBlock &Reader) {
+bool StaticBitmap::Unpersist(InputPersistenceBlock &Reader) {
 	bool Result = true;
 
 	Result &= Bitmap::Unpersist(Reader);
diff --git a/engines/sword25/gfx/staticbitmap.h b/engines/sword25/gfx/staticbitmap.h
index 77b29be9bf..d4f3f800c8 100644
--- a/engines/sword25/gfx/staticbitmap.h
+++ b/engines/sword25/gfx/staticbitmap.h
@@ -56,7 +56,7 @@ private:
 	    @remark Filename muss absoluter Pfad sein
 	*/
 	StaticBitmap(RenderObjectPtr<RenderObject> ParentPtr, const Common::String &Filename);
-	StaticBitmap(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle);
+	StaticBitmap(InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle);
 
 public:
 	virtual ~StaticBitmap();
@@ -72,8 +72,8 @@ public:
 		return false;
 	}
 
-	virtual bool    Persist(BS_OutputPersistenceBlock &Writer);
-	virtual bool    Unpersist(BS_InputPersistenceBlock &Reader);
+	virtual bool    Persist(OutputPersistenceBlock &Writer);
+	virtual bool    Unpersist(InputPersistenceBlock &Reader);
 
 protected:
 	virtual bool    DoRender();
diff --git a/engines/sword25/gfx/text.cpp b/engines/sword25/gfx/text.cpp
index d3e846abc5..6d568f1b43 100644
--- a/engines/sword25/gfx/text.cpp
+++ b/engines/sword25/gfx/text.cpp
@@ -74,7 +74,7 @@ Text::Text(RenderObjectPtr<RenderObject> ParentPtr) :
 
 // -----------------------------------------------------------------------------
 
-Text::Text(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) :
+Text::Text(InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle) :
 	RenderObject(ParentPtr, TYPE_TEXT, Handle) {
 	m_InitSuccess = Unpersist(Reader);
 }
@@ -152,15 +152,15 @@ bool Text::DoRender() {
 	if (!FontPtr) return false;
 
 	// Charactermap-Resource locken.
-	BS_ResourceManager *RMPtr = GetResourceManager();
+	ResourceManager *RMPtr = GetResourceManager();
 	BitmapResource *CharMapPtr;
 	{
-		BS_Resource *pResource = RMPtr->RequestResource(FontPtr->GetCharactermapFileName());
+		Resource *pResource = RMPtr->RequestResource(FontPtr->GetCharactermapFileName());
 		if (!pResource) {
 			BS_LOG_ERRORLN("Could not request resource \"%s\".", FontPtr->GetCharactermapFileName().c_str());
 			return false;
 		}
-		if (pResource->GetType() != BS_Resource::TYPE_BITMAP) {
+		if (pResource->GetType() != Resource::TYPE_BITMAP) {
 			BS_LOG_ERRORLN("Requested resource \"%s\" is not a bitmap.", FontPtr->GetCharactermapFileName().c_str());
 			return false;
 		}
@@ -169,7 +169,7 @@ bool Text::DoRender() {
 	}
 
 	// Framebufferobjekt holen.
-	GraphicEngine *GfxPtr = static_cast<GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
+	GraphicEngine *GfxPtr = static_cast<GraphicEngine *>(Kernel::GetInstance()->GetService("gfx"));
 	BS_ASSERT(GfxPtr);
 
 	bool Result = true;
@@ -207,25 +207,25 @@ bool Text::DoRender() {
 
 // -----------------------------------------------------------------------------
 
-BS_ResourceManager *Text::GetResourceManager() {
+ResourceManager *Text::GetResourceManager() {
 	// Pointer auf den Resource-Manager holen.
-	return BS_Kernel::GetInstance()->GetResourceManager();
+	return Kernel::GetInstance()->GetResourceManager();
 }
 
 // -----------------------------------------------------------------------------
 
 FontResource *Text::LockFontResource() {
-	BS_ResourceManager *RMPtr = GetResourceManager();
+	ResourceManager *RMPtr = GetResourceManager();
 
 	// Font-Resource locken.
 	FontResource *FontPtr;
 	{
-		BS_Resource *ResourcePtr = RMPtr->RequestResource(m_Font);
+		Resource *ResourcePtr = RMPtr->RequestResource(m_Font);
 		if (!ResourcePtr) {
 			BS_LOG_ERRORLN("Could not request resource \"%s\".", m_Font.c_str());
 			return NULL;
 		}
-		if (ResourcePtr->GetType() != BS_Resource::TYPE_FONT) {
+		if (ResourcePtr->GetType() != Resource::TYPE_FONT) {
 			BS_LOG_ERRORLN("Requested resource \"%s\" is not a font.", m_Font.c_str());
 			return NULL;
 		}
@@ -333,7 +333,7 @@ void Text::UpdateMetrics(FontResource &FontResource) {
 // Persistenz
 // -----------------------------------------------------------------------------
 
-bool Text::Persist(BS_OutputPersistenceBlock &Writer) {
+bool Text::Persist(OutputPersistenceBlock &Writer) {
 	bool Result = true;
 
 	Result &= RenderObject::Persist(Writer);
@@ -349,7 +349,7 @@ bool Text::Persist(BS_OutputPersistenceBlock &Writer) {
 	return Result;
 }
 
-bool Text::Unpersist(BS_InputPersistenceBlock &Reader) {
+bool Text::Unpersist(InputPersistenceBlock &Reader) {
 	bool Result = true;
 
 	Result &= RenderObject::Unpersist(Reader);
diff --git a/engines/sword25/gfx/text.h b/engines/sword25/gfx/text.h
index 399472571d..5e9d8d887f 100644
--- a/engines/sword25/gfx/text.h
+++ b/engines/sword25/gfx/text.h
@@ -53,9 +53,9 @@ namespace Sword25 {
 // Forward Declarations
 // -----------------------------------------------------------------------------
 
-class BS_Kernel;
+class Kernel;
 class FontResource;
-class BS_ResourceManager;
+class ResourceManager;
 
 // -----------------------------------------------------------------------------
 // Klassendefinition
@@ -151,15 +151,15 @@ public:
 		return m_AutoWrapThreshold;
 	}
 
-	virtual bool    Persist(BS_OutputPersistenceBlock &Writer);
-	virtual bool    Unpersist(BS_InputPersistenceBlock &Reader);
+	virtual bool    Persist(OutputPersistenceBlock &Writer);
+	virtual bool    Unpersist(InputPersistenceBlock &Reader);
 
 protected:
 	virtual bool DoRender();
 
 private:
 	Text(RenderObjectPtr<RenderObject> ParentPtr);
-	Text(BS_InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle);
+	Text(InputPersistenceBlock &Reader, RenderObjectPtr<RenderObject> ParentPtr, unsigned int Handle);
 
 	unsigned int    m_ModulationColor;
 	Common::String      m_Font;
@@ -176,7 +176,7 @@ private:
 
 	void UpdateFormat();
 	void UpdateMetrics(FontResource &FontResource);
-	BS_ResourceManager *GetResourceManager();
+	ResourceManager *GetResourceManager();
 	FontResource *LockFontResource();
 };