thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

SWORD25: Enforced code formatting rules in rest of the engine

Browse source 
svn-id: r53626
This commit is contained in:
Eugene Sandulenko 2010-10-19 21:03:33 +00:00
parent ae78107e2a
commit 6629efc676
54 changed files with 1520 additions and 1991 deletions
Download patch file Download diff file Expand all files Collapse all files

6
engines/sword25/fmv/movieplayer.cpp
View file

@ -65,11 +65,11 @@ MoviePlayer::~MoviePlayer() {
bool MoviePlayer::loadMovie(const Common::String &filename, uint z) {
// Get the file and load it into the decoder
Common::SeekableReadStream *in = Kernel::GetInstance()->GetPackage()->getStream(filename);
Common::SeekableReadStream *in = Kernel::getInstance()->getPackage()->getStream(filename);
_decoder.load(in);
// Ausgabebitmap erstellen
GraphicEngine *pGfx = Kernel::GetInstance()->GetGfx();
GraphicEngine *pGfx = Kernel::getInstance()->getGfx();
#if INDIRECTRENDERING
_outputBitmap = pGfx->getMainPanel()->addDynamicBitmap(_decoder.getWidth(), _decoder.getHeight());
@ -167,7 +167,7 @@ void MoviePlayer::setScaleFactor(float scaleFactor) {
_outputBitmap->setScaleFactor(scaleFactor);
// Ausgabebitmap auf dem Bildschirm zentrieren
GraphicEngine *gfxPtr = Kernel::GetInstance()->GetGfx();
GraphicEngine *gfxPtr = Kernel::getInstance()->getGfx();
_outputBitmap->setX((gfxPtr->getDisplayWidth() - _outputBitmap->getWidth()) / 2);
_outputBitmap->setY((gfxPtr->getDisplayHeight() - _outputBitmap->getHeight()) / 2);
}

22
engines/sword25/fmv/movieplayer_script.cpp
View file

@ -44,7 +44,7 @@
namespace Sword25 {
int loadMovie(lua_State *L) {
MoviePlayer *FMVPtr = Kernel::GetInstance()->GetFMV();
MoviePlayer *FMVPtr = Kernel::getInstance()->getFMV();
BS_ASSERT(FMVPtr);
lua_pushbooleancpp(L, FMVPtr->loadMovie(luaL_checkstring(L, 1), lua_gettop(L) == 2 ? static_cast<uint>(luaL_checknumber(L, 2)) : 10));
@ -53,7 +53,7 @@ int loadMovie(lua_State *L) {
}
int unloadMovie(lua_State *L) {
MoviePlayer *FMVPtr = Kernel::GetInstance()->GetFMV();
MoviePlayer *FMVPtr = Kernel::getInstance()->getFMV();
BS_ASSERT(FMVPtr);
lua_pushbooleancpp(L, FMVPtr->unloadMovie());
@ -62,7 +62,7 @@ int unloadMovie(lua_State *L) {
}
int play(lua_State *L) {
MoviePlayer *FMVPtr = Kernel::GetInstance()->GetFMV();
MoviePlayer *FMVPtr = Kernel::getInstance()->getFMV();
BS_ASSERT(FMVPtr);
lua_pushbooleancpp(L, FMVPtr->play());
@ -71,7 +71,7 @@ int play(lua_State *L) {
}
int pause(lua_State *L) {
MoviePlayer *FMVPtr = Kernel::GetInstance()->GetFMV();
MoviePlayer *FMVPtr = Kernel::getInstance()->getFMV();
BS_ASSERT(FMVPtr);
lua_pushbooleancpp(L, FMVPtr->pause());
@ -80,7 +80,7 @@ int pause(lua_State *L) {
}
int update(lua_State *L) {
MoviePlayer *FMVPtr = Kernel::GetInstance()->GetFMV();
MoviePlayer *FMVPtr = Kernel::getInstance()->getFMV();
BS_ASSERT(FMVPtr);
FMVPtr->update();
@ -89,7 +89,7 @@ int update(lua_State *L) {
}
int isMovieLoaded(lua_State *L) {
MoviePlayer *FMVPtr = Kernel::GetInstance()->GetFMV();
MoviePlayer *FMVPtr = Kernel::getInstance()->getFMV();
BS_ASSERT(FMVPtr);
lua_pushbooleancpp(L, FMVPtr->isMovieLoaded());
@ -98,7 +98,7 @@ int isMovieLoaded(lua_State *L) {
}
int isPaused(lua_State *L) {
MoviePlayer *FMVPtr = Kernel::GetInstance()->GetFMV();
MoviePlayer *FMVPtr = Kernel::getInstance()->getFMV();
BS_ASSERT(FMVPtr);
lua_pushbooleancpp(L, FMVPtr->isPaused());
@ -107,7 +107,7 @@ int isPaused(lua_State *L) {
}
int getScaleFactor(lua_State *L) {
MoviePlayer *FMVPtr = Kernel::GetInstance()->GetFMV();
MoviePlayer *FMVPtr = Kernel::getInstance()->getFMV();
BS_ASSERT(FMVPtr);
lua_pushnumber(L, FMVPtr->getScaleFactor());
@ -116,7 +116,7 @@ int getScaleFactor(lua_State *L) {
}
int setScaleFactor(lua_State *L) {
MoviePlayer *FMVPtr = Kernel::GetInstance()->GetFMV();
MoviePlayer *FMVPtr = Kernel::getInstance()->getFMV();
BS_ASSERT(FMVPtr);
FMVPtr->setScaleFactor(static_cast<float>(luaL_checknumber(L, 1)));
@ -125,7 +125,7 @@ int setScaleFactor(lua_State *L) {
}
int getTime(lua_State *L) {
MoviePlayer *FMVPtr = Kernel::GetInstance()->GetFMV();
MoviePlayer *FMVPtr = Kernel::getInstance()->getFMV();
BS_ASSERT(FMVPtr);
lua_pushnumber(L, FMVPtr->getTime());
@ -150,7 +150,7 @@ const luaL_reg LIBRARY_FUNCTIONS[] = {
};
bool MoviePlayer::registerScriptBindings() {
ScriptEngine *pScript = Kernel::GetInstance()->GetScript();
ScriptEngine *pScript = Kernel::getInstance()->getScript();
BS_ASSERT(pScript);
lua_State *L = static_cast<lua_State *>(pScript->getScriptObject());
BS_ASSERT(L);

28
engines/sword25/gfx/animation.cpp
View file

@ -99,8 +99,8 @@ Animation::Animation(InputPersistenceBlock &reader, RenderObjectPtr<RenderObject
void Animation::initializeAnimationResource(const Common::String &fileName) {
// Die Resource wird für die gesamte Lebensdauer des Animations-Objektes gelockt.
Resource *resourcePtr = Kernel::GetInstance()->GetResourceManager()->RequestResource(fileName);
if (resourcePtr && resourcePtr->GetType() == Resource::TYPE_ANIMATION)
Resource *resourcePtr = Kernel::getInstance()->getResourceManager()->requestResource(fileName);
if (resourcePtr && resourcePtr->getType() == Resource::TYPE_ANIMATION)
_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());
@ -182,13 +182,13 @@ bool Animation::doRender() {
BS_ASSERT(_currentFrame < animationDescriptionPtr->getFrameCount());
// Bitmap des aktuellen Frames holen
Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->getFrame(_currentFrame).fileName);
Resource *pResource = Kernel::getInstance()->getResourceManager()->requestResource(animationDescriptionPtr->getFrame(_currentFrame).fileName);
BS_ASSERT(pResource);
BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
BS_ASSERT(pResource->getType() == Resource::TYPE_BITMAP);
BitmapResource *pBitmapResource = static_cast<BitmapResource *>(pResource);
// Framebufferobjekt holen
GraphicEngine *pGfx = Kernel::GetInstance()->GetGfx();
GraphicEngine *pGfx = Kernel::getInstance()->getGfx();
BS_ASSERT(pGfx);
// Bitmap zeichnen
@ -315,9 +315,9 @@ void Animation::computeCurrentCharacteristics() {
BS_ASSERT(animationDescriptionPtr);
const AnimationResource::Frame &curFrame = animationDescriptionPtr->getFrame(_currentFrame);
Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(curFrame.fileName);
Resource *pResource = Kernel::getInstance()->getResourceManager()->requestResource(curFrame.fileName);
BS_ASSERT(pResource);
BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
BS_ASSERT(pResource->getType() == Resource::TYPE_BITMAP);
BitmapResource *pBitmap = static_cast<BitmapResource *>(pResource);
// Größe des Bitmaps auf die Animation übertragen
@ -338,7 +338,7 @@ bool Animation::lockAllFrames() {
AnimationDescription *animationDescriptionPtr = getAnimationDescription();
BS_ASSERT(animationDescriptionPtr);
for (uint i = 0; i < animationDescriptionPtr->getFrameCount(); ++i) {
if (!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;
}
@ -356,14 +356,14 @@ bool Animation::unlockAllFrames() {
BS_ASSERT(animationDescriptionPtr);
for (uint i = 0; i < animationDescriptionPtr->getFrameCount(); ++i) {
Resource *pResource;
if (!(pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(animationDescriptionPtr->getFrame(i).fileName))) {
if (!(pResource = Kernel::getInstance()->getResourceManager()->requestResource(animationDescriptionPtr->getFrame(i).fileName))) {
BS_LOG_ERRORLN("Could not unlock all animation frames.");
return false;
}
// Zwei mal freigeben um den Request von LockAllFrames() und den jetzigen Request aufzuheben
pResource->release();
if (pResource->GetLockCount())
if (pResource->getLockCount())
pResource->release();
}
@ -524,9 +524,9 @@ int Animation::computeXModifier() const {
BS_ASSERT(animationDescriptionPtr);
const AnimationResource::Frame &curFrame = animationDescriptionPtr->getFrame(_currentFrame);
Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(curFrame.fileName);
Resource *pResource = Kernel::getInstance()->getResourceManager()->requestResource(curFrame.fileName);
BS_ASSERT(pResource);
BS_ASSERT(pResource->GetType() == 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) * _scaleFactorX) :
@ -542,9 +542,9 @@ int Animation::computeYModifier() const {
BS_ASSERT(animationDescriptionPtr);
const AnimationResource::Frame &curFrame = animationDescriptionPtr->getFrame(_currentFrame);
Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(curFrame.fileName);
Resource *pResource = Kernel::getInstance()->getResourceManager()->requestResource(curFrame.fileName);
BS_ASSERT(pResource);
BS_ASSERT(pResource->GetType() == 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) * _scaleFactorY) :

6
engines/sword25/gfx/animationresource.cpp
View file

@ -54,7 +54,7 @@ AnimationResource::AnimationResource(const Common::String &filename) :
Common::XMLParser(),
_valid(false) {
// Get a pointer to the package manager
_pPackage = Kernel::GetInstance()->GetPackage();
_pPackage = Kernel::getInstance()->getPackage();
BS_ASSERT(_pPackage);
// Switch to the folder the specified Xml fiile is in
@ -211,7 +211,7 @@ AnimationResource::~AnimationResource() {
bool AnimationResource::precacheAllFrames() const {
Common::Array<Frame>::const_iterator iter = _frames.begin();
for (; iter != _frames.end(); ++iter) {
if (!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;
}
@ -232,7 +232,7 @@ bool AnimationResource::computeFeatures() {
Common::Array<Frame>::const_iterator iter = _frames.begin();
for (; iter != _frames.end(); ++iter) {
BitmapResource *pBitmap;
if (!(pBitmap = static_cast<BitmapResource *>(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;
}

4
engines/sword25/gfx/animationtemplate.cpp
View file

@ -125,9 +125,9 @@ AnimationTemplate::AnimationTemplate(InputPersistenceBlock &reader, uint handle)
}
AnimationResource *AnimationTemplate::requestSourceAnimation(const Common::String &sourceAnimation) const {
ResourceManager *RMPtr = Kernel::GetInstance()->GetResourceManager();
ResourceManager *RMPtr = Kernel::getInstance()->getResourceManager();
Resource *resourcePtr;
if (NULL == (resourcePtr = RMPtr->RequestResource(sourceAnimation)) || resourcePtr->GetType() != Resource::TYPE_ANIMATION) {
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;
}

2
engines/sword25/gfx/dynamicbitmap.cpp
View file

@ -77,7 +77,7 @@ uint DynamicBitmap::getPixel(int x, int y) const {
bool DynamicBitmap::doRender() {
// Framebufferobjekt holen
GraphicEngine *pGfx = Kernel::GetInstance()->GetGfx();
GraphicEngine *pGfx = Kernel::getInstance()->getGfx();
BS_ASSERT(pGfx);
// Bitmap zeichnen

6
engines/sword25/gfx/fontresource.cpp
View file

@ -55,7 +55,7 @@ FontResource::FontResource(Kernel *pKernel, const Common::String &fileName) :
// Get a pointer to the package manager
BS_ASSERT(_pKernel);
PackageManager *pPackage = _pKernel->GetPackage();
PackageManager *pPackage = _pKernel->getPackage();
BS_ASSERT(pPackage);
// Load the contents of the file
@ -93,7 +93,7 @@ bool FontResource::parserCallback_font(ParserNode *node) {
// Get a reference to the package manager
BS_ASSERT(_pKernel);
PackageManager *pPackage = _pKernel->GetPackage();
PackageManager *pPackage = _pKernel->getPackage();
BS_ASSERT(pPackage);
// Get the full path and filename for the bitmap resource
@ -104,7 +104,7 @@ bool FontResource::parserCallback_font(ParserNode *node) {
}
// Pre-cache the resource
if (!_pKernel->GetResourceManager()->PrecacheResource(_bitmapFileName)) {
if (!_pKernel->getResourceManager()->precacheResource(_bitmapFileName)) {
BS_LOG_ERRORLN("Could not precache \"%s\".", _bitmapFileName.c_str());
}

6
engines/sword25/gfx/graphicengine.cpp
View file

@ -306,7 +306,7 @@ Resource *GraphicEngine::loadResource(const Common::String &filename) {
debug(2, "VectorImage: %s", filename.c_str());
// Pointer auf Package-Manager holen
PackageManager *pPackage = Kernel::GetInstance()->GetPackage();
PackageManager *pPackage = Kernel::getInstance()->getPackage();
BS_ASSERT(pPackage);
// Datei laden
@ -349,7 +349,7 @@ Resource *GraphicEngine::loadResource(const Common::String &filename) {
// Load font
if (filename.hasSuffix("_fnt.xml")) {
FontResource *pResource = new FontResource(Kernel::GetInstance(), filename);
FontResource *pResource = new FontResource(Kernel::getInstance(), filename);
if (pResource->isValid())
return pResource;
else {
@ -383,7 +383,7 @@ void GraphicEngine::drawDebugLine(const Vertex &start, const Vertex &end, uint c
void GraphicEngine::updateLastFrameDuration() {
// Record current time
const uint currentTime = Kernel::GetInstance()->GetMilliTicks();
const uint currentTime = Kernel::getInstance()->getMilliTicks();
// Compute the elapsed time since the last frame and prevent too big ( > 250 msecs) time jumps.
// These can occur when loading save states, during debugging or due to hardware inaccuracies.

14
engines/sword25/gfx/graphicengine_script.cpp
View file

@ -209,9 +209,9 @@ static const luaL_reg ANIMATION_TEMPLATE_METHODS[] = {
};
static GraphicEngine *getGE() {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
GraphicEngine *pGE = pKernel->GetGfx();
GraphicEngine *pGE = pKernel->getGfx();
BS_ASSERT(pGE);
return pGE;
}
@ -1039,7 +1039,7 @@ static int a_isPlaying(lua_State *L) {
}
static bool animationLoopPointCallback(uint handle) {
lua_State *L = static_cast<lua_State *>(Kernel::GetInstance()->GetScript()->getScriptObject());
lua_State *L = static_cast<lua_State *>(Kernel::getInstance()->getScript()->getScriptObject());
loopPointCallbackPtr->invokeCallbackFunctions(L, handle);
return true;
@ -1071,7 +1071,7 @@ static bool animationActionCallback(uint Handle) {
RenderObjectPtr<Animation> animationPtr(Handle);
if (animationPtr.isValid()) {
actionCallbackPtr->Action = animationPtr->getCurrentAction();
lua_State *L = static_cast<lua_State *>(Kernel::GetInstance()->GetScript()->getScriptObject());
lua_State *L = static_cast<lua_State *>(Kernel::getInstance()->getScript()->getScriptObject());
actionCallbackPtr->invokeCallbackFunctions(L, animationPtr->getHandle());
}
@ -1101,7 +1101,7 @@ static int a_unregisterActionCallback(lua_State *L) {
}
static bool animationDeleteCallback(uint Handle) {
lua_State *L = static_cast<lua_State *>(Kernel::GetInstance()->GetScript()->getScriptObject());
lua_State *L = static_cast<lua_State *>(Kernel::getInstance()->getScript()->getScriptObject());
loopPointCallbackPtr->removeAllObjectCallbacks(L, Handle);
return true;
@ -1268,9 +1268,9 @@ static const luaL_reg TEXT_METHODS[] = {
};
bool GraphicEngine::registerScriptBindings() {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ScriptEngine *pScript = pKernel->GetScript();
ScriptEngine *pScript = pKernel->getScript();
BS_ASSERT(pScript);
lua_State *L = static_cast<lua_State *>(pScript->getScriptObject());
BS_ASSERT(L);

8
engines/sword25/gfx/image/renderedimage.cpp
View file

@ -56,10 +56,10 @@ RenderedImage::RenderedImage(const Common::String &filename, bool &result) :
_height(0) {
result = false;
PackageManager *pPackage = Kernel::GetInstance()->GetPackage();
PackageManager *pPackage = Kernel::getInstance()->getPackage();
BS_ASSERT(pPackage);
_backSurface = Kernel::GetInstance()->GetGfx()->getSurface();
_backSurface = Kernel::getInstance()->getGfx()->getSurface();
// Datei laden
byte *pFileData;
@ -103,7 +103,7 @@ RenderedImage::RenderedImage(uint width, uint height, bool &result) :
_data = new byte[width * height * 4];
Common::set_to(_data, &_data[width * height * 4], 0);
_backSurface = Kernel::GetInstance()->GetGfx()->getSurface();
_backSurface = Kernel::getInstance()->getGfx()->getSurface();
_doCleanup = true;
@ -112,7 +112,7 @@ RenderedImage::RenderedImage(uint width, uint height, bool &result) :
}
RenderedImage::RenderedImage() : _width(0), _height(0), _data(0) {
_backSurface = Kernel::GetInstance()->GetGfx()->getSurface();
_backSurface = Kernel::getInstance()->getGfx()->getSurface();
_doCleanup = false;

2
engines/sword25/gfx/image/swimage.cpp
View file

@ -47,7 +47,7 @@ SWImage::SWImage(const Common::String &filename, bool &result) :
_height(0) {
result = false;
PackageManager *pPackage = Kernel::GetInstance()->GetPackage();
PackageManager *pPackage = Kernel::getInstance()->getPackage();
BS_ASSERT(pPackage);
// Datei laden

2
engines/sword25/gfx/panel.cpp
View file

@ -77,7 +77,7 @@ bool Panel::doRender() {
if (_color >> 24 == 0)
return true;
GraphicEngine *gfxPtr = Kernel::GetInstance()->GetGfx();
GraphicEngine *gfxPtr = Kernel::getInstance()->getGfx();
BS_ASSERT(gfxPtr);
return gfxPtr->fill(&_bbox, _color);

2
engines/sword25/gfx/renderobjectmanager.cpp
View file

@ -63,7 +63,7 @@ void RenderObjectManager::startFrame() {
_frameStarted = true;
// Verstrichene Zeit bestimmen
int timeElapsed = 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 = _timedRenderObjects.begin();

26
engines/sword25/gfx/staticbitmap.cpp
View file

@ -58,12 +58,12 @@ StaticBitmap::StaticBitmap(InputPersistenceBlock &reader, RenderObjectPtr<Render
bool StaticBitmap::initBitmapResource(const Common::String &filename) {
// Bild-Resource laden
Resource *resourcePtr = 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() != Resource::TYPE_BITMAP) {
if (resourcePtr->getType() != Resource::TYPE_BITMAP) {
BS_LOG_ERRORLN("Requested resource \"%s\" is not a bitmap.", filename.c_str());
return false;
}
@ -88,13 +88,13 @@ StaticBitmap::~StaticBitmap() {
bool StaticBitmap::doRender() {
// Bitmap holen
Resource *resourcePtr = Kernel::GetInstance()->GetResourceManager()->RequestResource(_resourceFilename);
Resource *resourcePtr = Kernel::getInstance()->getResourceManager()->requestResource(_resourceFilename);
BS_ASSERT(resourcePtr);
BS_ASSERT(resourcePtr->GetType() == Resource::TYPE_BITMAP);
BS_ASSERT(resourcePtr->getType() == Resource::TYPE_BITMAP);
BitmapResource *bitmapResourcePtr = static_cast<BitmapResource *>(resourcePtr);
// Framebufferobjekt holen
GraphicEngine *gfxPtr = Kernel::GetInstance()->GetGfx();
GraphicEngine *gfxPtr = Kernel::getInstance()->getGfx();
BS_ASSERT(gfxPtr);
// Bitmap zeichnen
@ -121,8 +121,8 @@ uint StaticBitmap::getPixel(int x, int y) const {
BS_ASSERT(x >= 0 && x < _width);
BS_ASSERT(y >= 0 && y < _height);
Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(_resourceFilename);
BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
Resource *pResource = Kernel::getInstance()->getResourceManager()->requestResource(_resourceFilename);
BS_ASSERT(pResource->getType() == Resource::TYPE_BITMAP);
BitmapResource *pBitmapResource = static_cast<BitmapResource *>(pResource);
uint result = pBitmapResource->getPixel(x, y);
pResource->release();
@ -135,24 +135,24 @@ bool StaticBitmap::setContent(const byte *pixeldata, uint size, uint offset, uin
}
bool StaticBitmap::isAlphaAllowed() const {
Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(_resourceFilename);
BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
Resource *pResource = Kernel::getInstance()->getResourceManager()->requestResource(_resourceFilename);
BS_ASSERT(pResource->getType() == Resource::TYPE_BITMAP);
bool result = static_cast<BitmapResource *>(pResource)->isAlphaAllowed();
pResource->release();
return result;
}
bool StaticBitmap::isColorModulationAllowed() const {
Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(_resourceFilename);
BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
Resource *pResource = Kernel::getInstance()->getResourceManager()->requestResource(_resourceFilename);
BS_ASSERT(pResource->getType() == Resource::TYPE_BITMAP);
bool result = static_cast<BitmapResource *>(pResource)->isColorModulationAllowed();
pResource->release();
return result;
}
bool StaticBitmap::isScalingAllowed() const {
Resource *pResource = Kernel::GetInstance()->GetResourceManager()->RequestResource(_resourceFilename);
BS_ASSERT(pResource->GetType() == Resource::TYPE_BITMAP);
Resource *pResource = Kernel::getInstance()->getResourceManager()->requestResource(_resourceFilename);
BS_ASSERT(pResource->getType() == Resource::TYPE_BITMAP);
bool result = static_cast<BitmapResource *>(pResource)->isScalingAllowed();
pResource->release();
return result;

14
engines/sword25/gfx/text.cpp
View file

@ -73,7 +73,7 @@ Text::Text(InputPersistenceBlock &reader, RenderObjectPtr<RenderObject> parentPt
bool Text::setFont(const Common::String &font) {
// Font precachen.
if (getResourceManager()->PrecacheResource(font)) {
if (getResourceManager()->precacheResource(font)) {
_font = font;
updateFormat();
forceRefresh();
@ -134,12 +134,12 @@ bool Text::doRender() {
ResourceManager *rmPtr = getResourceManager();
BitmapResource *charMapPtr;
{
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() != 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;
}
@ -148,7 +148,7 @@ bool Text::doRender() {
}
// Framebufferobjekt holen.
GraphicEngine *gfxPtr = Kernel::GetInstance()->GetGfx();
GraphicEngine *gfxPtr = Kernel::getInstance()->getGfx();
BS_ASSERT(gfxPtr);
bool result = true;
@ -187,7 +187,7 @@ bool Text::doRender() {
ResourceManager *Text::getResourceManager() {
// Pointer auf den Resource-Manager holen.
return Kernel::GetInstance()->GetResourceManager();
return Kernel::getInstance()->getResourceManager();
}
FontResource *Text::lockFontResource() {
@ -196,12 +196,12 @@ FontResource *Text::lockFontResource() {
// Font-Resource locken.
FontResource *fontPtr;
{
Resource *resourcePtr = rmPtr->RequestResource(_font);
Resource *resourcePtr = rmPtr->requestResource(_font);
if (!resourcePtr) {
BS_LOG_ERRORLN("Could not request resource \"%s\".", _font.c_str());
return NULL;
}
if (resourcePtr->GetType() != Resource::TYPE_FONT) {
if (resourcePtr->getType() != Resource::TYPE_FONT) {
BS_LOG_ERRORLN("Requested resource \"%s\" is not a font.", _font.c_str());
return NULL;
}

296
engines/sword25/input/inputengine.cpp
View file

@ -51,24 +51,24 @@ namespace Sword25 {
InputEngine::InputEngine(Kernel *pKernel) :
Service(pKernel),
m_CurrentState(0),
m_LeftMouseDown(false),
m_RightMouseDown(false),
m_MouseX(0),
m_MouseY(0),
m_LeftDoubleClick(false),
m_DoubleClickTime(DOUBLE_CLICK_TIME),
m_DoubleClickRectWidth(DOUBLE_CLICK_RECT_SIZE),
m_DoubleClickRectHeight(DOUBLE_CLICK_RECT_SIZE),
m_LastLeftClickTime(0),
m_LastLeftClickMouseX(0),
m_LastLeftClickMouseY(0) {
memset(m_KeyboardState[0], 0, sizeof(m_KeyboardState[0]));
memset(m_KeyboardState[1], 0, sizeof(m_KeyboardState[1]));
m_LeftMouseState[0] = false;
m_LeftMouseState[1] = false;
m_RightMouseState[0] = false;
m_RightMouseState[1] = false;
_currentState(0),
_leftMouseDown(false),
_rightMouseDown(false),
_mouseX(0),
_mouseY(0),
_leftDoubleClick(false),
_doubleClickTime(DOUBLE_CLICK_TIME),
_doubleClickRectWidth(DOUBLE_CLICK_RECT_SIZE),
_doubleClickRectHeight(DOUBLE_CLICK_RECT_SIZE),
_lastLeftClickTime(0),
_lastLeftClickMouseX(0),
_lastLeftClickMouseY(0) {
memset(_keyboardState[0], 0, sizeof(_keyboardState[0]));
memset(_keyboardState[1], 0, sizeof(_keyboardState[1]));
_leftMouseState[0] = false;
_leftMouseState[1] = false;
_rightMouseState[0] = false;
_rightMouseState[1] = false;
if (!registerScriptBindings())
BS_LOG_ERRORLN("Script bindings could not be registered.");
@ -80,18 +80,14 @@ Service *InputEngine_CreateObject(Kernel *pKernel) {
return new InputEngine(pKernel);
}
// -----------------------------------------------------------------------------
bool InputEngine::Init() {
bool InputEngine::init() {
// No initialisation needed
return true;
}
// -----------------------------------------------------------------------------
void InputEngine::Update() {
void InputEngine::update() {
Common::Event event;
m_CurrentState ^= 1;
_currentState ^= 1;
// Loop through processing any pending events
bool handleEvents = true;
@ -99,31 +95,31 @@ void InputEngine::Update() {
switch (event.type) {
case Common::EVENT_LBUTTONDOWN:
case Common::EVENT_LBUTTONUP:
m_LeftMouseDown = event.type == Common::EVENT_LBUTTONDOWN;
m_MouseX = event.mouse.x;
m_MouseY = event.mouse.y;
_leftMouseDown = event.type == Common::EVENT_LBUTTONDOWN;
_mouseX = event.mouse.x;
_mouseY = event.mouse.y;
handleEvents = false;
break;
case Common::EVENT_RBUTTONDOWN:
case Common::EVENT_RBUTTONUP:
m_RightMouseDown = event.type == Common::EVENT_RBUTTONDOWN;
m_MouseX = event.mouse.x;
m_MouseY = event.mouse.y;
_rightMouseDown = event.type == Common::EVENT_RBUTTONDOWN;
_mouseX = event.mouse.x;
_mouseY = event.mouse.y;
handleEvents = false;
break;
case Common::EVENT_MOUSEMOVE:
m_MouseX = event.mouse.x;
m_MouseY = event.mouse.y;
_mouseX = event.mouse.x;
_mouseY = event.mouse.y;
break;
case Common::EVENT_KEYDOWN:
case Common::EVENT_KEYUP:
AlterKeyboardState(event.kbd.keycode, (event.type == Common::EVENT_KEYDOWN) ? 0x80 : 0);
alterKeyboardState(event.kbd.keycode, (event.type == Common::EVENT_KEYDOWN) ? 0x80 : 0);
break;
case Common::EVENT_QUIT:
Kernel::GetInstance()->GetWindow()->SetWindowAlive(false);
Kernel::getInstance()->getWindow()->setWindowAlive(false);
break;
default:
@ -131,125 +127,97 @@ void InputEngine::Update() {
}
}
m_LeftMouseState[m_CurrentState] = m_LeftMouseDown;
m_RightMouseState[m_CurrentState] = m_RightMouseDown;
_leftMouseState[_currentState] = _leftMouseDown;
_rightMouseState[_currentState] = _rightMouseDown;
TestForLeftDoubleClick();
testForLeftDoubleClick();
}
// -----------------------------------------------------------------------------
bool InputEngine::IsLeftMouseDown() {
return m_LeftMouseDown;
bool InputEngine::isLeftMouseDown() {
return _leftMouseDown;
}
// -----------------------------------------------------------------------------
bool InputEngine::IsRightMouseDown() {
return m_RightMouseDown;
bool InputEngine::isRightMouseDown() {
return _rightMouseDown;
}
// -----------------------------------------------------------------------------
void InputEngine::TestForLeftDoubleClick() {
m_LeftDoubleClick = false;
void InputEngine::testForLeftDoubleClick() {
_leftDoubleClick = false;
// Only bother checking for a double click if the left mouse button was clicked
if (WasLeftMouseDown()) {
if (wasLeftMouseDown()) {
// Get the time now
uint Now = Kernel::GetInstance()->GetMilliTicks();
uint now = Kernel::getInstance()->getMilliTicks();
// A double click is signalled if
// 1. The two clicks are close enough together
// 2. The mouse cursor hasn't moved much
if (Now - m_LastLeftClickTime <= m_DoubleClickTime &&
ABS(m_MouseX - m_LastLeftClickMouseX) <= m_DoubleClickRectWidth / 2 &&
ABS(m_MouseY - m_LastLeftClickMouseY) <= m_DoubleClickRectHeight / 2) {
m_LeftDoubleClick = true;
if (now - _lastLeftClickTime <= _doubleClickTime &&
ABS(_mouseX - _lastLeftClickMouseX) <= _doubleClickRectWidth / 2 &&
ABS(_mouseY - _lastLeftClickMouseY) <= _doubleClickRectHeight / 2) {
_leftDoubleClick = true;
// Reset the time and position of the last click, so that clicking is not
// interpreted as the first click of a further double-click
m_LastLeftClickTime = 0;
m_LastLeftClickMouseX = 0;
m_LastLeftClickMouseY = 0;
_lastLeftClickTime = 0;
_lastLeftClickMouseX = 0;
_lastLeftClickMouseY = 0;
} else {
// There is no double click. Remember the position and time of the click,
// in case it's the first click of a double-click sequence
m_LastLeftClickTime = Now;
m_LastLeftClickMouseX = m_MouseX;
m_LastLeftClickMouseY = m_MouseY;
_lastLeftClickTime = now;
_lastLeftClickMouseX = _mouseX;
_lastLeftClickMouseY = _mouseY;
}
}
}
// -----------------------------------------------------------------------------
void InputEngine::AlterKeyboardState(int keycode, byte newState) {
m_KeyboardState[m_CurrentState][keycode] = newState;
void InputEngine::alterKeyboardState(int keycode, byte newState) {
_keyboardState[_currentState][keycode] = newState;
}
// -----------------------------------------------------------------------------
bool InputEngine::IsLeftDoubleClick() {
return m_LeftDoubleClick;
bool InputEngine::isLeftDoubleClick() {
return _leftDoubleClick;
}
// -----------------------------------------------------------------------------
bool InputEngine::WasLeftMouseDown() {
return (m_LeftMouseState[m_CurrentState] == false) && (m_LeftMouseState[m_CurrentState ^ 1] == true);
bool InputEngine::wasLeftMouseDown() {
return (_leftMouseState[_currentState] == false) && (_leftMouseState[_currentState ^ 1] == true);
}
// -----------------------------------------------------------------------------
bool InputEngine::WasRightMouseDown() {
return (m_RightMouseState[m_CurrentState] == false) && (m_RightMouseState[m_CurrentState ^ 1] == true);
bool InputEngine::wasRightMouseDown() {
return (_rightMouseState[_currentState] == false) && (_rightMouseState[_currentState ^ 1] == true);
}
// -----------------------------------------------------------------------------
int InputEngine::GetMouseX() {
return m_MouseX;
int InputEngine::getMouseX() {
return _mouseX;
}
// -----------------------------------------------------------------------------
int InputEngine::GetMouseY() {
return m_MouseY;
int InputEngine::getMouseY() {
return _mouseY;
}
// -----------------------------------------------------------------------------
bool InputEngine::IsKeyDown(uint KeyCode) {
return (m_KeyboardState[m_CurrentState][KeyCode] & 0x80) != 0;
bool InputEngine::isKeyDown(uint keyCode) {
return (_keyboardState[_currentState][keyCode] & 0x80) != 0;
}
// -----------------------------------------------------------------------------
bool InputEngine::WasKeyDown(uint KeyCode) {
return ((m_KeyboardState[m_CurrentState][KeyCode] & 0x80) == 0) &&
((m_KeyboardState[m_CurrentState ^ 1][KeyCode] & 0x80) != 0);
bool InputEngine::wasKeyDown(uint keyCode) {
return ((_keyboardState[_currentState][keyCode] & 0x80) == 0) &&
((_keyboardState[_currentState ^ 1][keyCode] & 0x80) != 0);
}
// -----------------------------------------------------------------------------
void InputEngine::SetMouseX(int PosX) {
m_MouseX = PosX;
g_system->warpMouse(m_MouseX, m_MouseY);
void InputEngine::setMouseX(int posX) {
_mouseX = posX;
g_system->warpMouse(_mouseX, _mouseY);
}
// -----------------------------------------------------------------------------
void InputEngine::SetMouseY(int PosY) {
m_MouseY = PosY;
g_system->warpMouse(m_MouseX, m_MouseY);
void InputEngine::setMouseY(int posY) {
_mouseY = posY;
g_system->warpMouse(_mouseX, _mouseY);
}
// -----------------------------------------------------------------------------
bool InputEngine::RegisterCharacterCallback(CharacterCallback Callback) {
if (Common::find(m_CharacterCallbacks.begin(), m_CharacterCallbacks.end(), Callback) == m_CharacterCallbacks.end()) {
m_CharacterCallbacks.push_back(Callback);
bool InputEngine::registerCharacterCallback(CharacterCallback callback) {
if (Common::find(_characterCallbacks.begin(), _characterCallbacks.end(), callback) == _characterCallbacks.end()) {
_characterCallbacks.push_back(callback);
return true;
} else {
BS_LOG_WARNINGLN("Tried to register an CharacterCallback that was already registered.");
@ -257,13 +225,11 @@ bool InputEngine::RegisterCharacterCallback(CharacterCallback Callback) {
}
}
// -----------------------------------------------------------------------------
bool InputEngine::UnregisterCharacterCallback(CharacterCallback Callback) {
Common::List<CharacterCallback>::iterator CallbackIter = Common::find(m_CharacterCallbacks.begin(),
m_CharacterCallbacks.end(), Callback);
if (CallbackIter != m_CharacterCallbacks.end()) {
m_CharacterCallbacks.erase(CallbackIter);
bool InputEngine::unregisterCharacterCallback(CharacterCallback callback) {
Common::List<CharacterCallback>::iterator callbackIter = Common::find(_characterCallbacks.begin(),
_characterCallbacks.end(), callback);
if (callbackIter != _characterCallbacks.end()) {
_characterCallbacks.erase(callbackIter);
return true;
} else {
BS_LOG_WARNINGLN("Tried to unregister an CharacterCallback that was not previously registered.");
@ -271,11 +237,9 @@ bool InputEngine::UnregisterCharacterCallback(CharacterCallback Callback) {
}
}
// -----------------------------------------------------------------------------
bool InputEngine::RegisterCommandCallback(CommandCallback Callback) {
if (Common::find(m_CommandCallbacks.begin(), m_CommandCallbacks.end(), Callback) == m_CommandCallbacks.end()) {
m_CommandCallbacks.push_back(Callback);
bool InputEngine::registerCommandCallback(CommandCallback callback) {
if (Common::find(_commandCallbacks.begin(), _commandCallbacks.end(), callback) == _commandCallbacks.end()) {
_commandCallbacks.push_back(callback);
return true;
} else {
BS_LOG_WARNINGLN("Tried to register an CommandCallback that was already registered.");
@ -283,13 +247,11 @@ bool InputEngine::RegisterCommandCallback(CommandCallback Callback) {
}
}
// -----------------------------------------------------------------------------
bool InputEngine::UnregisterCommandCallback(CommandCallback Callback) {
Common::List<CommandCallback>::iterator CallbackIter =
Common::find(m_CommandCallbacks.begin(), m_CommandCallbacks.end(), Callback);
if (CallbackIter != m_CommandCallbacks.end()) {
m_CommandCallbacks.erase(CallbackIter);
bool InputEngine::unregisterCommandCallback(CommandCallback callback) {
Common::List<CommandCallback>::iterator callbackIter =
Common::find(_commandCallbacks.begin(), _commandCallbacks.end(), callback);
if (callbackIter != _commandCallbacks.end()) {
_commandCallbacks.erase(callbackIter);
return true;
} else {
BS_LOG_WARNINGLN("Tried to unregister an CommandCallback that was not previously registered.");
@ -297,60 +259,52 @@ bool InputEngine::UnregisterCommandCallback(CommandCallback Callback) {
}
}
// -----------------------------------------------------------------------------
void InputEngine::ReportCharacter(byte Character) {
Common::List<CharacterCallback>::const_iterator CallbackIter = m_CharacterCallbacks.begin();
while (CallbackIter != m_CharacterCallbacks.end()) {
void InputEngine::reportCharacter(byte character) {
Common::List<CharacterCallback>::const_iterator callbackIter = _characterCallbacks.begin();
while (callbackIter != _characterCallbacks.end()) {
// Iterator vor dem Aufruf erhöhen und im Folgendem auf einer Kopie arbeiten.
// Dieses Vorgehen ist notwendig da der Iterator möglicherweise von der Callbackfunktion durch das Deregistrieren des Callbacks
// invalidiert wird.
Common::List<CharacterCallback>::const_iterator CurCallbackIter = CallbackIter;
++CallbackIter;
Common::List<CharacterCallback>::const_iterator curCallbackIter = callbackIter;
++callbackIter;
(*CurCallbackIter)(Character);
(*curCallbackIter)(character);
}
}
// -----------------------------------------------------------------------------
void InputEngine::ReportCommand(KEY_COMMANDS Command) {
Common::List<CommandCallback>::const_iterator CallbackIter = m_CommandCallbacks.begin();
while (CallbackIter != m_CommandCallbacks.end()) {
void InputEngine::reportCommand(KEY_COMMANDS command) {
Common::List<CommandCallback>::const_iterator callbackIter = _commandCallbacks.begin();
while (callbackIter != _commandCallbacks.end()) {
// Iterator vor dem Aufruf erhöhen und im Folgendem auf einer Kopie arbeiten.
// Dieses Vorgehen ist notwendig da der Iterator möglicherweise von der Callbackfunktion durch das Deregistrieren des Callbacks
// invalidiert wird.
Common::List<CommandCallback>::const_iterator CurCallbackIter = CallbackIter;
++CallbackIter;
Common::List<CommandCallback>::const_iterator curCallbackIter = callbackIter;
++callbackIter;
(*CurCallbackIter)(Command);
(*curCallbackIter)(command);
}
}
// -----------------------------------------------------------------------------
// Persistenz
// -----------------------------------------------------------------------------
bool InputEngine::persist(OutputPersistenceBlock &writer) {
// Anzahl an Command-Callbacks persistieren.
writer.write(m_CommandCallbacks.size());
writer.write(_commandCallbacks.size());
// Alle Command-Callbacks einzeln persistieren.
{
Common::List<CommandCallback>::const_iterator It = m_CommandCallbacks.begin();
while (It != m_CommandCallbacks.end()) {
Common::List<CommandCallback>::const_iterator It = _commandCallbacks.begin();
while (It != _commandCallbacks.end()) {
writer.write(CallbackRegistry::instance().resolveCallbackPointer(*It));
++It;
}
}
// Anzahl an Character-Callbacks persistieren.
writer.write(m_CharacterCallbacks.size());
writer.write(_characterCallbacks.size());
// Alle Character-Callbacks einzeln persistieren.
{
Common::List<CharacterCallback>::const_iterator It = m_CharacterCallbacks.begin();
while (It != m_CharacterCallbacks.end()) {
Common::List<CharacterCallback>::const_iterator It = _characterCallbacks.begin();
while (It != _characterCallbacks.end()) {
writer.write(CallbackRegistry::instance().resolveCallbackPointer(*It));
++It;
}
@ -359,38 +313,36 @@ bool InputEngine::persist(OutputPersistenceBlock &writer) {
return true;
}
// -----------------------------------------------------------------------------
bool InputEngine::unpersist(InputPersistenceBlock &reader) {
// Command-Callbackliste leeren.
m_CommandCallbacks.clear();
_commandCallbacks.clear();
// Anzahl an Command-Callbacks lesen.
uint CommandCallbackCount;
reader.read(CommandCallbackCount);
uint commandCallbackCount;
reader.read(commandCallbackCount);
// Alle Command-Callbacks wieder herstellen.
for (uint i = 0; i < CommandCallbackCount; ++i) {
Common::String CallbackFunctionName;
reader.read(CallbackFunctionName);
for (uint i = 0; i < commandCallbackCount; ++i) {
Common::String callbackFunctionName;
reader.read(callbackFunctionName);
m_CommandCallbacks.push_back(reinterpret_cast<CommandCallback>(
CallbackRegistry::instance().resolveCallbackFunction(CallbackFunctionName)));
_commandCallbacks.push_back(reinterpret_cast<CommandCallback>(
CallbackRegistry::instance().resolveCallbackFunction(callbackFunctionName)));
}
// Character-Callbackliste leeren.
m_CharacterCallbacks.clear();
_characterCallbacks.clear();
// Anzahl an Character-Callbacks lesen.
uint CharacterCallbackCount;
reader.read(CharacterCallbackCount);
uint characterCallbackCount;
reader.read(characterCallbackCount);
// Alle Character-Callbacks wieder herstellen.
for (uint i = 0; i < CharacterCallbackCount; ++i) {
Common::String CallbackFunctionName;
reader.read(CallbackFunctionName);
for (uint i = 0; i < characterCallbackCount; ++i) {
Common::String callbackFunctionName;
reader.read(callbackFunctionName);
m_CharacterCallbacks.push_back(reinterpret_cast<CharacterCallback>(CallbackRegistry::instance().resolveCallbackFunction(CallbackFunctionName)));
_characterCallbacks.push_back(reinterpret_cast<CharacterCallback>(CallbackRegistry::instance().resolveCallbackFunction(callbackFunctionName)));
}
return reader.isGood();

77
engines/sword25/input/inputengine.h
View file

@ -45,7 +45,6 @@
#ifndef SWORD25_INPUTENGINE_H
#define SWORD25_INPUTENGINE_H
/// Includes
#include "sword25/kernel/common.h"
#include "sword25/kernel/service.h"
#include "sword25/kernel/persistable.h"
@ -176,7 +175,7 @@ public:
* Initialises the input engine
* @return Returns a true on success, otherwise false.
*/
bool Init();
bool init();
/**
* Performs a "tick" of the input engine.
@ -185,17 +184,17 @@ public:
* of the input engine that are not running in their own thread, or to perform
* additional administrative tasks that are needed.
*/
void Update();
void update();
/**
* Returns true if the left mouse button is pressed
*/
bool IsLeftMouseDown();
bool isLeftMouseDown();
/**
* Returns true if the right mouse button is pressed.
*/
bool IsRightMouseDown();
bool isRightMouseDown();
/**
* Returns true if the left mouse button was pressed and released.
@ -203,7 +202,7 @@ public:
* The difference between this and IsLeftMouseDown() is that this only returns
* true when the left mouse button is released.
*/
bool WasLeftMouseDown();
bool wasLeftMouseDown();
/**
* Returns true if the right mouse button was pressed and released.
@ -211,39 +210,39 @@ public:
* The difference between this and IsRightMouseDown() is that this only returns
* true when the right mouse button is released.
*/
bool WasRightMouseDown();
bool wasRightMouseDown();
/**
* Returns true if the left mouse button double click was done
*/
bool IsLeftDoubleClick();
bool isLeftDoubleClick();
/**
* Returns the X position of the cursor in pixels
*/
int GetMouseX();
int getMouseX();
/**
* Returns the Y position of the cursor in pixels
*/
int GetMouseY();
int getMouseY();
/**
* Sets the X position of the cursor in pixels
*/
void SetMouseX(int PosX);
void setMouseX(int posX);
/**
* Sets the Y position of the cursor in pixels
*/
void SetMouseY(int PosY);
void setMouseY(int posY);
/**
* Returns true if a given key was pressed
* @param KeyCode The key code to be checked
* @return Returns true if the given key is done, otherwise false.
*/
bool IsKeyDown(uint KeyCode);
bool isKeyDown(uint keyCode);
/**
* Returns true if a certain key was pushed and released.
@ -253,7 +252,7 @@ public:
* strings that users type.
* @param KeyCode The key code to be checked
*/
bool WasKeyDown(uint KeyCode);
bool wasKeyDown(uint keyCode);
typedef CallbackPtr CharacterCallback;
@ -269,13 +268,13 @@ public:
* The input of strings by the user through use of callbacks should be implemented.
* @return Returns true if the function was registered, otherwise false.
*/
bool RegisterCharacterCallback(CallbackPtr Callback);
bool registerCharacterCallback(CallbackPtr callback);
/**
* De-registeres a previously registered callback function.
* @return Returns true if the function could be de-registered, otherwise false.
*/
bool UnregisterCharacterCallback(CallbackPtr Callback);
bool unregisterCharacterCallback(CallbackPtr callback);
typedef CallbackPtr CommandCallback;
@ -288,16 +287,16 @@ public:
* The input of strings by the user through the use of callbacks should be implemented.
* @return Returns true if the function was registered, otherwise false.
*/
bool RegisterCommandCallback(CallbackPtr Callback);
bool registerCommandCallback(CallbackPtr callback);
/**
* Un-register a callback function for the input of commands that can have an influence on the string input.
* @return Returns true if the function could be de-registered, otherwise false.
*/
bool UnregisterCommandCallback(CommandCallback Callback);
bool unregisterCommandCallback(CommandCallback callback);
void ReportCharacter(byte Character);
void ReportCommand(KEY_COMMANDS Command);
void reportCharacter(byte character);
void reportCommand(KEY_COMMANDS command);
bool persist(OutputPersistenceBlock &writer);
bool unpersist(InputPersistenceBlock &reader);
@ -306,26 +305,26 @@ private:
bool registerScriptBindings();
private:
void TestForLeftDoubleClick();
void AlterKeyboardState(int keycode, byte newState);
void testForLeftDoubleClick();
void alterKeyboardState(int keycode, byte newState);
byte m_KeyboardState[2][256];
bool m_LeftMouseState[2];
bool m_RightMouseState[2];
uint m_CurrentState;
int m_MouseX;
int m_MouseY;
bool m_LeftMouseDown;
bool m_RightMouseDown;
bool m_LeftDoubleClick;
uint m_DoubleClickTime;
int m_DoubleClickRectWidth;
int m_DoubleClickRectHeight;
uint m_LastLeftClickTime;
int m_LastLeftClickMouseX;
int m_LastLeftClickMouseY;
Common::List<CommandCallback> m_CommandCallbacks;
Common::List<CharacterCallback> m_CharacterCallbacks;
byte _keyboardState[2][256];
bool _leftMouseState[2];
bool _rightMouseState[2];
uint _currentState;
int _mouseX;
int _mouseY;
bool _leftMouseDown;
bool _rightMouseDown;
bool _leftDoubleClick;
uint _doubleClickTime;
int _doubleClickRectWidth;
int _doubleClickRectHeight;
uint _lastLeftClickTime;
int _lastLeftClickMouseX;
int _lastLeftClickMouseY;
Common::List<CommandCallback> _commandCallbacks;
Common::List<CharacterCallback> _characterCallbacks;
};
} // End of namespace Sword25

248
engines/sword25/input/inputengine_script.cpp
View file

@ -32,10 +32,6 @@
*
*/
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "common/ptr.h"
#include "common/str.h"
#include "sword25/kernel/common.h"
@ -51,268 +47,218 @@
namespace Sword25 {
// -----------------------------------------------------------------------------
// Callback-Objekte
// -----------------------------------------------------------------------------
static void TheCharacterCallback(int Character);
static void TheCommandCallback(int Command);
static void theCharacterCallback(int character);
static void theCommandCallback(int command);
namespace {
class CharacterCallbackClass : public LuaCallback {
public:
CharacterCallbackClass(lua_State *L) : LuaCallback(L) {}
Common::String Character;
Common::String _character;
protected:
int PreFunctionInvokation(lua_State *L) {
lua_pushstring(L, Character.c_str());
lua_pushstring(L, _character.c_str());
return 1;
}
};
Common::SharedPtr<CharacterCallbackClass> CharacterCallbackPtr;
// -----------------------------------------------------------------------------
Common::SharedPtr<CharacterCallbackClass> characterCallbackPtr;
class CommandCallbackClass : public LuaCallback {
public:
CommandCallbackClass(lua_State *L) : LuaCallback(L) {
Command = InputEngine::KEY_COMMAND_BACKSPACE;
_command = InputEngine::KEY_COMMAND_BACKSPACE;
}
InputEngine::KEY_COMMANDS Command;
InputEngine::KEY_COMMANDS _command;
protected:
int PreFunctionInvokation(lua_State *L) {
lua_pushnumber(L, Command);
int preFunctionInvokation(lua_State *L) {
lua_pushnumber(L, _command);
return 1;
}
};
Common::SharedPtr<CommandCallbackClass> CommandCallbackPtr;
// -------------------------------------------------------------------------
Common::SharedPtr<CommandCallbackClass> commandCallbackPtr;
struct CallbackfunctionRegisterer {
CallbackfunctionRegisterer() {
CallbackRegistry::instance().registerCallbackFunction("LuaCommandCB", TheCommandCallback);
CallbackRegistry::instance().registerCallbackFunction("LuaCharacterCB", TheCharacterCallback);
CallbackRegistry::instance().registerCallbackFunction("LuaCommandCB", theCommandCallback);
CallbackRegistry::instance().registerCallbackFunction("LuaCharacterCB", theCharacterCallback);
}
};
static CallbackfunctionRegisterer Instance;
static CallbackfunctionRegisterer instance;
}
// -----------------------------------------------------------------------------
static InputEngine *GetIE() {
Kernel *pKernel = Kernel::GetInstance();
static InputEngine *getIE() {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
InputEngine *pIE = pKernel->GetInput();
InputEngine *pIE = pKernel->getInput();
BS_ASSERT(pIE);
return pIE;
}
// -----------------------------------------------------------------------------
static int init(lua_State *L) {
InputEngine *pIE = getIE();
static int Init(lua_State *L) {
InputEngine *pIE = GetIE();
lua_pushbooleancpp(L, pIE->Init());
lua_pushbooleancpp(L, pIE->init());
return 1;
}
// -----------------------------------------------------------------------------
static int Update(lua_State *L) {
InputEngine *pIE = GetIE();
static int update(lua_State *L) {
InputEngine *pIE = getIE();
// Beim ersten Aufruf der Update()-Methode werden die beiden Callbacks am Input-Objekt registriert.
// Dieses kann nicht in _RegisterScriptBindings() passieren, da diese Funktion vom Konstruktor der abstrakten Basisklasse aufgerufen wird und die
// Register...()-Methoden abstrakt sind, im Konstruktor der Basisklasse also nicht aufgerufen werden können.
static bool FirstCall = true;
if (FirstCall) {
FirstCall = false;
pIE->RegisterCharacterCallback(TheCharacterCallback);
pIE->RegisterCommandCallback(TheCommandCallback);
static bool firstCall = true;
if (firstCall) {
firstCall = false;
pIE->registerCharacterCallback(theCharacterCallback);
pIE->registerCommandCallback(theCommandCallback);
}
pIE->Update();
pIE->update();
return 0;
}
// -----------------------------------------------------------------------------
static int isLeftMouseDown(lua_State *L) {
InputEngine *pIE = getIE();
static int IsLeftMouseDown(lua_State *L) {
InputEngine *pIE = GetIE();
lua_pushbooleancpp(L, pIE->IsLeftMouseDown());
lua_pushbooleancpp(L, pIE->isLeftMouseDown());
return 1;
}
// -----------------------------------------------------------------------------
static int isRightMouseDown(lua_State *L) {
InputEngine *pIE = getIE();
static int IsRightMouseDown(lua_State *L) {
InputEngine *pIE = GetIE();
lua_pushbooleancpp(L, pIE->IsRightMouseDown());
lua_pushbooleancpp(L, pIE->isRightMouseDown());
return 1;
}
// -----------------------------------------------------------------------------
static int wasLeftMouseDown(lua_State *L) {
InputEngine *pIE = getIE();
static int WasLeftMouseDown(lua_State *L) {
InputEngine *pIE = GetIE();
lua_pushbooleancpp(L, pIE->WasLeftMouseDown());
lua_pushbooleancpp(L, pIE->wasLeftMouseDown());
return 1;
}
// -----------------------------------------------------------------------------
static int wasRightMouseDown(lua_State *L) {
InputEngine *pIE = getIE();
static int WasRightMouseDown(lua_State *L) {
InputEngine *pIE = GetIE();
lua_pushbooleancpp(L, pIE->WasRightMouseDown());
lua_pushbooleancpp(L, pIE->wasRightMouseDown());
return 1;
}
// -----------------------------------------------------------------------------
static int isLeftDoubleClick(lua_State *L) {
InputEngine *pIE = getIE();
static int IsLeftDoubleClick(lua_State *L) {
InputEngine *pIE = GetIE();
lua_pushbooleancpp(L, pIE->IsLeftDoubleClick());
lua_pushbooleancpp(L, pIE->isLeftDoubleClick());
return 1;
}
// -----------------------------------------------------------------------------
static int getMouseX(lua_State *L) {
InputEngine *pIE = getIE();
static int GetMouseX(lua_State *L) {
InputEngine *pIE = GetIE();
lua_pushnumber(L, pIE->GetMouseX());
lua_pushnumber(L, pIE->getMouseX());
return 1;
}
// -----------------------------------------------------------------------------
static int getMouseY(lua_State *L) {
InputEngine *pIE = getIE();
static int GetMouseY(lua_State *L) {
InputEngine *pIE = GetIE();
lua_pushnumber(L, pIE->GetMouseY());
lua_pushnumber(L, pIE->getMouseY());
return 1;
}
// -----------------------------------------------------------------------------
static int isKeyDown(lua_State *L) {
InputEngine *pIE = getIE();
static int IsKeyDown(lua_State *L) {
InputEngine *pIE = GetIE();
lua_pushbooleancpp(L, pIE->IsKeyDown((uint) luaL_checknumber(L, 1)));
lua_pushbooleancpp(L, pIE->isKeyDown((uint)luaL_checknumber(L, 1)));
return 1;
}
// -----------------------------------------------------------------------------
static int wasKeyDown(lua_State *L) {
InputEngine *pIE = getIE();
static int WasKeyDown(lua_State *L) {
InputEngine *pIE = GetIE();
lua_pushbooleancpp(L, pIE->WasKeyDown((uint) luaL_checknumber(L, 1)));
lua_pushbooleancpp(L, pIE->wasKeyDown((uint)luaL_checknumber(L, 1)));
return 1;
}
// -----------------------------------------------------------------------------
static int setMouseX(lua_State *L) {
InputEngine *pIE = getIE();
static int SetMouseX(lua_State *L) {
InputEngine *pIE = GetIE();
pIE->SetMouseX((int) luaL_checknumber(L, 1));
pIE->setMouseX((int)luaL_checknumber(L, 1));
return 0;
}
// -----------------------------------------------------------------------------
static int setMouseY(lua_State *L) {
InputEngine *pIE = getIE();
static int SetMouseY(lua_State *L) {
InputEngine *pIE = GetIE();
pIE->SetMouseY((int) luaL_checknumber(L, 1));
pIE->setMouseY((int)luaL_checknumber(L, 1));
return 0;
}
// -----------------------------------------------------------------------------
static void TheCharacterCallback(int Character) {
CharacterCallbackPtr->Character = static_cast<byte>(Character);
lua_State *L = static_cast<lua_State *>(Kernel::GetInstance()->GetScript()->getScriptObject());
CharacterCallbackPtr->invokeCallbackFunctions(L, 1);
static void theCharacterCallback(int character) {
characterCallbackPtr->_character = static_cast<byte>(character);
lua_State *L = static_cast<lua_State *>(Kernel::getInstance()->getScript()->getScriptObject());
characterCallbackPtr->invokeCallbackFunctions(L, 1);
}
// -----------------------------------------------------------------------------
static int RegisterCharacterCallback(lua_State *L) {
static int registerCharacterCallback(lua_State *L) {
luaL_checktype(L, 1, LUA_TFUNCTION);
CharacterCallbackPtr->registerCallbackFunction(L, 1);
characterCallbackPtr->registerCallbackFunction(L, 1);
return 0;
}
// -----------------------------------------------------------------------------
static int UnregisterCharacterCallback(lua_State *L) {
static int unregisterCharacterCallback(lua_State *L) {
luaL_checktype(L, 1, LUA_TFUNCTION);
CharacterCallbackPtr->unregisterCallbackFunction(L, 1);
characterCallbackPtr->unregisterCallbackFunction(L, 1);
return 0;
}
// -----------------------------------------------------------------------------
static void TheCommandCallback(int Command) {
CommandCallbackPtr->Command = static_cast<InputEngine::KEY_COMMANDS>(Command);
lua_State *L = static_cast<lua_State *>(Kernel::GetInstance()->GetScript()->getScriptObject());
CommandCallbackPtr->invokeCallbackFunctions(L, 1);
static void theCommandCallback(int command) {
commandCallbackPtr->_command = static_cast<InputEngine::KEY_COMMANDS>(command);
lua_State *L = static_cast<lua_State *>(Kernel::getInstance()->getScript()->getScriptObject());
commandCallbackPtr->invokeCallbackFunctions(L, 1);
}
// -----------------------------------------------------------------------------
static int RegisterCommandCallback(lua_State *L) {
static int registerCommandCallback(lua_State *L) {
luaL_checktype(L, 1, LUA_TFUNCTION);
CommandCallbackPtr->registerCallbackFunction(L, 1);
commandCallbackPtr->registerCallbackFunction(L, 1);
return 0;
}
// -----------------------------------------------------------------------------
static int UnregisterCommandCallback(lua_State *L) {
static int unregisterCommandCallback(lua_State *L) {
luaL_checktype(L, 1, LUA_TFUNCTION);
CommandCallbackPtr->unregisterCallbackFunction(L, 1);
commandCallbackPtr->unregisterCallbackFunction(L, 1);
return 0;
}
// -----------------------------------------------------------------------------
static const char *PACKAGE_LIBRARY_NAME = "Input";
static const luaL_reg PACKAGE_FUNCTIONS[] = {
{"Init", Init},
{"Update", Update},
{"IsLeftMouseDown", IsLeftMouseDown},
{"IsRightMouseDown", IsRightMouseDown},
{"WasLeftMouseDown", WasLeftMouseDown},
{"WasRightMouseDown", WasRightMouseDown},
{"IsLeftDoubleClick", IsLeftDoubleClick},
{"GetMouseX", GetMouseX},
{"GetMouseY", GetMouseY},
{"SetMouseX", SetMouseX},
{"SetMouseY", SetMouseY},
{"IsKeyDown", IsKeyDown},
{"WasKeyDown", WasKeyDown},
{"RegisterCharacterCallback", RegisterCharacterCallback},
{"UnregisterCharacterCallback", UnregisterCharacterCallback},
{"RegisterCommandCallback", RegisterCommandCallback},
{"UnregisterCommandCallback", UnregisterCommandCallback},
{"Init", init},
{"Update", update},
{"IsLeftMouseDown", isLeftMouseDown},
{"IsRightMouseDown", isRightMouseDown},
{"WasLeftMouseDown", wasLeftMouseDown},
{"WasRightMouseDown", wasRightMouseDown},
{"IsLeftDoubleClick", isLeftDoubleClick},
{"GetMouseX", getMouseX},
{"GetMouseY", getMouseY},
{"SetMouseX", setMouseX},
{"SetMouseY", setMouseY},
{"IsKeyDown", isKeyDown},
{"WasKeyDown", wasKeyDown},
{"RegisterCharacterCallback", registerCharacterCallback},
{"UnregisterCharacterCallback", unregisterCharacterCallback},
{"RegisterCommandCallback", registerCommandCallback},
{"UnregisterCommandCallback", unregisterCommandCallback},
{0, 0}
};
@ -334,9 +280,9 @@ static const lua_constant_reg PACKAGE_CONSTANTS[] = {
// -----------------------------------------------------------------------------
bool InputEngine::registerScriptBindings() {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ScriptEngine *pScript = pKernel->GetScript();
ScriptEngine *pScript = pKernel->getScript();
BS_ASSERT(pScript);
lua_State *L = static_cast<lua_State *>(pScript->getScriptObject());
BS_ASSERT(L);
@ -344,8 +290,8 @@ bool InputEngine::registerScriptBindings() {
if (!LuaBindhelper::addFunctionsToLib(L, PACKAGE_LIBRARY_NAME, PACKAGE_FUNCTIONS)) return false;
if (!LuaBindhelper::addConstantsToLib(L, PACKAGE_LIBRARY_NAME, PACKAGE_CONSTANTS)) return false;
CharacterCallbackPtr = Common::SharedPtr<CharacterCallbackClass>(new CharacterCallbackClass(L));
CommandCallbackPtr = Common::SharedPtr<CommandCallbackClass>(new CommandCallbackClass(L));
characterCallbackPtr = Common::SharedPtr<CharacterCallbackClass>(new CharacterCallbackClass(L));
commandCallbackPtr = Common::SharedPtr<CommandCallbackClass>(new CommandCallbackClass(L));
return true;
}

20
engines/sword25/kernel/callbackregistry.cpp
View file

@ -44,22 +44,12 @@
// Pointer gespeichert war, stürtzt das Programm beim Äufrufen dieser Callbackfunktion ab. Durch das Auflösungverfahren wird beim Laden der
// Callbackbezeichner in den neuen Funktionspointer umgewandelt und der Aufruf kann erfolgen.
// -----------------------------------------------------------------------------
// Logging
// -----------------------------------------------------------------------------
#define BS_LOG_PREFIX "CALLBACKREGISTRY"
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "sword25/kernel/callbackregistry.h"
namespace Sword25 {
// -----------------------------------------------------------------------------
bool CallbackRegistry::registerCallbackFunction(const Common::String &name, CallbackPtr ptr) {
if (name == "") {
BS_LOG_ERRORLN("The empty string is not allowed as a callback function name.");
@ -80,8 +70,6 @@ bool CallbackRegistry::registerCallbackFunction(const Common::String &name, Call
return true;
}
// -----------------------------------------------------------------------------
CallbackPtr CallbackRegistry::resolveCallbackFunction(const Common::String &name) const {
CallbackPtr result = findPtrByName(name);
@ -92,8 +80,6 @@ CallbackPtr CallbackRegistry::resolveCallbackFunction(const Common::String &name
return result;
}
// -----------------------------------------------------------------------------
Common::String CallbackRegistry::resolveCallbackPointer(CallbackPtr ptr) const {
const Common::String &result = findNameByPtr(ptr);
@ -104,24 +90,18 @@ Common::String CallbackRegistry::resolveCallbackPointer(CallbackPtr ptr) const {
return result;
}
// -----------------------------------------------------------------------------
CallbackPtr CallbackRegistry::findPtrByName(const Common::String &name) const {
// Eintrag in der Map finden und den Pointer zurückgeben.
NameToPtrMap::const_iterator it = _nameToPtrMap.find(name);
return it == _nameToPtrMap.end() ? 0 : it->_value;
}
// -----------------------------------------------------------------------------
Common::String CallbackRegistry::findNameByPtr(CallbackPtr ptr) const {
// Eintrag in der Map finden und den Namen zurückgeben.
PtrToNameMap::const_iterator it = _ptrToNameMap.find(ptr);
return it == _ptrToNameMap.end() ? "" : it->_value;
}
// -----------------------------------------------------------------------------
void CallbackRegistry::storeCallbackFunction(const Common::String &name, CallbackPtr ptr) {
// Callback-Funktion in beide Maps eintragen.
_nameToPtrMap[name] = ptr;

20
engines/sword25/kernel/callbackregistry.h
View file

@ -35,10 +35,6 @@
#ifndef SWORD25_CALLBACK_REGISTRY_H
#define SWORD25_CALLBACK_REGISTRY_H
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "common/scummsys.h"
#include "common/str.h"
#include "common/hash-str.h"
@ -47,10 +43,6 @@
namespace Sword25 {
// -----------------------------------------------------------------------------
// Klassendeklaration
// -----------------------------------------------------------------------------
typedef void (*CallbackPtr)(int command);
class CallbackRegistry {
@ -60,9 +52,9 @@ public:
return _instance;
}
bool registerCallbackFunction(const Common::String &name, CallbackPtr ptr);
CallbackPtr resolveCallbackFunction(const Common::String &name) const;
Common::String resolveCallbackPointer(CallbackPtr ptr) const;
bool registerCallbackFunction(const Common::String &name, CallbackPtr ptr);
CallbackPtr resolveCallbackFunction(const Common::String &name) const;
Common::String resolveCallbackPointer(CallbackPtr ptr) const;
private:
typedef Common::HashMap<Common::String, CallbackPtr, Common::CaseSensitiveString_Hash, Common::CaseSensitiveString_EqualTo> NameToPtrMap;
@ -82,9 +74,9 @@ private:
typedef Common::HashMap<CallbackPtr, Common::String, CallbackPtr_Hash, CallbackPtr_EqualTo> PtrToNameMap;
PtrToNameMap _ptrToNameMap;
CallbackPtr findPtrByName(const Common::String &name) const;
Common::String findNameByPtr(CallbackPtr ptr) const;
void storeCallbackFunction(const Common::String &name, CallbackPtr ptr);
CallbackPtr findPtrByName(const Common::String &name) const;
Common::String findNameByPtr(CallbackPtr ptr) const;
void storeCallbackFunction(const Common::String &name, CallbackPtr ptr);
};
} // End of namespace Sword25

56
engines/sword25/kernel/filesystemutil.cpp
View file

@ -32,10 +32,6 @@
*
*/
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "common/config-manager.h"
#include "common/fs.h"
#include "common/savefile.h"
@ -47,12 +43,8 @@ namespace Sword25 {
#define BS_LOG_PREFIX "FILESYSTEMUTIL"
// -----------------------------------------------------------------------------
// Constants and utility functions
// -----------------------------------------------------------------------------
Common::String GetAbsolutePath(const Common::String &Path) {
Common::FSNode node(Path);
Common::String getAbsolutePath(const Common::String &path) {
Common::FSNode node(path);
if (!node.exists()) {
// An error has occurred finding the node
@ -65,13 +57,9 @@ Common::String GetAbsolutePath(const Common::String &Path) {
return node.getPath();
}
// -----------------------------------------------------------------------------
// Class definitions
// -----------------------------------------------------------------------------
class BS_FileSystemUtilScummVM : public FileSystemUtil {
public:
virtual Common::String GetUserdataDirectory() {
virtual Common::String getUserdataDirectory() {
Common::String path = ConfMan.get("savepath");
if (path.empty()) {
@ -83,12 +71,12 @@ public:
return path;
}
virtual Common::String GetPathSeparator() {
virtual Common::String getPathSeparator() {
return Common::String("/");
}
virtual int32 GetFileSize(const Common::String &Filename) {
Common::FSNode node(Filename);
virtual int32 getFileSize(const Common::String &filename) {
Common::FSNode node(filename);
// If the file does not exist, return -1 as a result
if (!node.exists())
@ -103,7 +91,7 @@ public:
return size;
}
virtual TimeDate GetFileTime(const Common::String &Filename) {
virtual TimeDate getFileTime(const Common::String &filename) {
// TODO: There isn't any way in ScummVM to get a file's modified date/time. We will need to check
// what code makes use of it. If it's only the save game code, for example, we may be able to
// encode the date/time inside the savegame files themselves.
@ -112,41 +100,37 @@ public:
return result;
}
virtual bool FileExists(const Common::String &Filename) {
virtual bool fileExists(const Common::String &filename) {
Common::File f;
if (f.exists(Filename))
if (f.exists(filename))
return true;
// Check if the file exists in the save folder
Common::FSNode folder(PersistenceService::GetSavegameDirectory());
Common::FSNode fileNode = folder.getChild(FileSystemUtil::GetInstance().GetPathFilename(Filename));
Common::FSNode folder(PersistenceService::getSavegameDirectory());
Common::FSNode fileNode = folder.getChild(FileSystemUtil::getInstance().getPathFilename(filename));
return fileNode.exists();
}
virtual bool CreateDirectory(const Common::String &DirectoryName) {
virtual bool createDirectory(const Common::String &sirectoryName) {
// ScummVM doesn't support creating folders, so this is only a stub
BS_LOG_ERRORLN("CreateDirectory method called");
return false;
}
virtual Common::String GetPathFilename(const Common::String &Path) {
for (int i = Path.size() - 1; i >= 0; --i) {
if ((Path[i] == '/') || (Path[i] == '\\')) {
return Common::String(&Path.c_str()[i + 1]);
virtual Common::String getPathFilename(const Common::String &path) {
for (int i = path.size() - 1; i >= 0; --i) {
if ((path[i] == '/') || (path[i] == '\\')) {
return Common::String(&path.c_str()[i + 1]);
}
}
return Path;
return path;
}
};
// -----------------------------------------------------------------------------
// Singleton method of parent class
// -----------------------------------------------------------------------------
FileSystemUtil &FileSystemUtil::GetInstance() {
static BS_FileSystemUtilScummVM Instance;
return Instance;
FileSystemUtil &FileSystemUtil::getInstance() {
static BS_FileSystemUtilScummVM instance;
return instance;
}
} // End of namespace Sword25

16
engines/sword25/kernel/filesystemutil.h
View file

@ -61,7 +61,7 @@ namespace Sword25 {
class FileSystemUtil {
public:
static FileSystemUtil &GetInstance();
static FileSystemUtil &getInstance();
virtual ~FileSystemUtil() {}
/**
@ -70,27 +70,27 @@ public:
* These are for example Screenshots, game saves, configuration files, log files, ...
* @return Returns the name of the directory for user data.
*/
virtual Common::String GetUserdataDirectory() = 0;
virtual Common::String getUserdataDirectory() = 0;
/**
* @return Returns the path seperator
*/
virtual Common::String GetPathSeparator() = 0;
virtual Common::String getPathSeparator() = 0;
/**
* @param Filename The path to a file.
* @return Returns the size of the specified file. If the size could not be
* determined, or the file does not exist, returns -1
*/
virtual int32 GetFileSize(const Common::String &Filename) = 0;
virtual int32 getFileSize(const Common::String &filename) = 0;
/**
* @param Filename The path to a file.
* @return Returns the timestamp of the specified file.
*/
virtual TimeDate GetFileTime(const Common::String &Filename) = 0;
virtual TimeDate getFileTime(const Common::String &filename) = 0;
/**
* @param Filename The path to a file.
* @return Returns true if the file exists.
*/
virtual bool FileExists(const Common::String &Filename) = 0;
virtual bool fileExists(const Common::String &filename) = 0;
/**
* This function creates a directory
*
@ -99,13 +99,13 @@ public:
* @param DirectoryName The name of the directory to be created
* @return Returns true if the folder(s) could be created, otherwise false.
*/
virtual bool CreateDirectory(const Common::String &DirectoryName) = 0;
virtual bool createDirectory(const Common::String &directoryName) = 0;
/**
* Gets the filename from a path and filename
* @param Filename The full path and filename
* @return Returns just the filename
*/
virtual Common::String GetPathFilename(const Common::String &Path) = 0;
virtual Common::String getPathFilename(const Common::String &path) = 0;
};
} // End of namespace Sword25

144
engines/sword25/kernel/inputpersistenceblock.cpp
View file

@ -34,146 +34,116 @@
#define BS_LOG_PREFIX "INPUTPERSISTENCEBLOCK"
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "sword25/kernel/inputpersistenceblock.h"
namespace Sword25 {
// -----------------------------------------------------------------------------
// Constructor / Destructor
// -----------------------------------------------------------------------------
InputPersistenceBlock::InputPersistenceBlock(const void *Data, uint DataLength) :
m_Data(static_cast<const byte *>(Data), DataLength),
m_ErrorState(NONE) {
m_Iter = m_Data.begin();
InputPersistenceBlock::InputPersistenceBlock(const void *data, uint dataLength) :
_data(static_cast<const byte *>(data), dataLength),
_errorState(NONE) {
_iter = _data.begin();
}
// -----------------------------------------------------------------------------
InputPersistenceBlock::~InputPersistenceBlock() {
if (m_Iter != m_Data.end()) BS_LOG_WARNINGLN("Persistence block was not read to the end.");
if (_iter != _data.end())
BS_LOG_WARNINGLN("Persistence block was not read to the end.");
}
// -----------------------------------------------------------------------------
// Reading
// -----------------------------------------------------------------------------
void InputPersistenceBlock::read(int16 &Value) {
void InputPersistenceBlock::read(int16 &value) {
signed int v;
read(v);
Value = static_cast<int16>(v);
value = static_cast<int16>(v);
}
// -----------------------------------------------------------------------------
void InputPersistenceBlock::read(signed int &Value) {
if (CheckMarker(SINT_MARKER)) {
RawRead(&Value, sizeof(signed int));
Value = ConvertEndianessFromStorageToSystem(Value);
void InputPersistenceBlock::read(signed int &value) {
if (checkMarker(SINT_MARKER)) {
rawRead(&value, sizeof(signed int));
value = convertEndianessFromStorageToSystem(value);
} else {
Value = 0;
value = 0;
}
}
// -----------------------------------------------------------------------------
void InputPersistenceBlock::read(uint &Value) {
if (CheckMarker(UINT_MARKER)) {
RawRead(&Value, sizeof(uint));
Value = ConvertEndianessFromStorageToSystem(Value);
void InputPersistenceBlock::read(uint &value) {
if (checkMarker(UINT_MARKER)) {
rawRead(&value, sizeof(uint));
value = convertEndianessFromStorageToSystem(value);
} else {
Value = 0;
value = 0;
}
}
// -----------------------------------------------------------------------------
void InputPersistenceBlock::read(float &Value) {
if (CheckMarker(FLOAT_MARKER)) {
RawRead(&Value, sizeof(float));
Value = ConvertEndianessFromStorageToSystem(Value);
void InputPersistenceBlock::read(float &value) {
if (checkMarker(FLOAT_MARKER)) {
rawRead(&value, sizeof(float));
value = convertEndianessFromStorageToSystem(value);
} else {
Value = 0.0f;
value = 0.0f;
}
}
// -----------------------------------------------------------------------------
void InputPersistenceBlock::read(bool &Value) {
if (CheckMarker(BOOL_MARKER)) {
uint UIntBool;
RawRead(&UIntBool, sizeof(float));
UIntBool = ConvertEndianessFromStorageToSystem(UIntBool);
Value = UIntBool == 0 ? false : true;
void InputPersistenceBlock::read(bool &value) {
if (checkMarker(BOOL_MARKER)) {
uint uintBool;
rawRead(&uintBool, sizeof(float));
uintBool = convertEndianessFromStorageToSystem(uintBool);
value = uintBool == 0 ? false : true;
} else {
Value = 0.0f;
value = 0.0f;
}
}
// -----------------------------------------------------------------------------
void InputPersistenceBlock::read(Common::String &value) {
value = "";
void InputPersistenceBlock::read(Common::String &Value) {
Value = "";
if (checkMarker(STRING_MARKER)) {
uint size;
read(size);
if (CheckMarker(STRING_MARKER)) {
uint Size;
read(Size);
if (CheckBlockSize(Size)) {
Value = Common::String(reinterpret_cast<const char *>(&*m_Iter), Size);
m_Iter += Size;
if (checkBlockSize(size)) {
value = Common::String(reinterpret_cast<const char *>(&*_iter), size);
_iter += size;
}
}
}
// -----------------------------------------------------------------------------
void InputPersistenceBlock::read(Common::Array<byte> &value) {
if (checkMarker(BLOCK_MARKER)) {
uint size;
read(size);
void InputPersistenceBlock::read(Common::Array<byte> &Value) {
if (CheckMarker(BLOCK_MARKER)) {
uint Size;
read(Size);
if (CheckBlockSize(Size)) {
Value = Common::Array<byte>(m_Iter, Size);
m_Iter += Size;
if (checkBlockSize(size)) {
value = Common::Array<byte>(_iter, size);
_iter += size;
}
}
}
// -----------------------------------------------------------------------------
void InputPersistenceBlock::RawRead(void *DestPtr, size_t Size) {
if (CheckBlockSize(Size)) {
memcpy(DestPtr, &*m_Iter, Size);
m_Iter += Size;
void InputPersistenceBlock::rawRead(void *destPtr, size_t size) {
if (checkBlockSize(size)) {
memcpy(destPtr, &*_iter, size);
_iter += size;
}
}
// -----------------------------------------------------------------------------
bool InputPersistenceBlock::CheckBlockSize(int Size) {
if (m_Data.end() - m_Iter >= Size) {
bool InputPersistenceBlock::checkBlockSize(int size) {
if (_data.end() - _iter >= size) {
return true;
} else {
m_ErrorState = END_OF_DATA;
_errorState = END_OF_DATA;
BS_LOG_ERRORLN("Unexpected end of persistence block.");
return false;
}
}
// -----------------------------------------------------------------------------
bool InputPersistenceBlock::checkMarker(byte marker) {
if (!isGood() || !checkBlockSize(1))
return false;
bool InputPersistenceBlock::CheckMarker(byte Marker) {
if (!isGood() || !CheckBlockSize(1)) return false;
if (*m_Iter++ == Marker) {
if (*_iter++ == marker) {
return true;
} else {
m_ErrorState = OUT_OF_SYNC;
_errorState = OUT_OF_SYNC;
BS_LOG_ERRORLN("Wrong type marker found in persistence block.");
return false;
}

42
engines/sword25/kernel/inputpersistenceblock.h
View file

@ -35,20 +35,12 @@
#ifndef SWORD25_INPUTPERSISTENCEBLOCK_H
#define SWORD25_INPUTPERSISTENCEBLOCK_H
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "common/array.h"
#include "sword25/kernel/common.h"
#include "sword25/kernel/persistenceblock.h"
namespace Sword25 {
// -----------------------------------------------------------------------------
// Class declaration
// -----------------------------------------------------------------------------
class InputPersistenceBlock : public PersistenceBlock {
public:
enum ErrorState {
@ -57,32 +49,32 @@ public:
OUT_OF_SYNC
};
InputPersistenceBlock(const void *Data, uint DataLength);
InputPersistenceBlock(const void *data, uint dataLength);
virtual ~InputPersistenceBlock();
void read(int16 &Value);
void read(signed int &Value);
void read(uint &Value);
void read(float &Value);
void read(bool &Value);
void read(Common::String &Value);
void read(Common::Array<byte> &Value);
void read(int16 &value);
void read(signed int &value);
void read(uint &value);
void read(float &value);
void read(bool &value);
void read(Common::String &value);
void read(Common::Array<byte> &value);
bool isGood() const {
return m_ErrorState == NONE;
return _errorState == NONE;
}
ErrorState GetErrorState() const {
return m_ErrorState;
ErrorState getErrorState() const {
return _errorState;
}
private:
bool CheckMarker(byte Marker);
bool CheckBlockSize(int Size);
void RawRead(void *DestPtr, size_t Size);
bool checkMarker(byte marker);
bool checkBlockSize(int size);
void rawRead(void *destPtr, size_t size);
Common::Array<byte> m_Data;
Common::Array<byte>::const_iterator m_Iter;
ErrorState m_ErrorState;
Common::Array<byte> _data;
Common::Array<byte>::const_iterator _iter;
ErrorState _errorState;
};
} // End of namespace Sword25

234
engines/sword25/kernel/kernel.cpp
View file

@ -47,14 +47,13 @@ namespace Sword25 {
#define BS_LOG_PREFIX "KERNEL"
Kernel *Kernel::_Instance = 0;
Kernel *Kernel::_instance = 0;
Kernel::Kernel() :
_pWindow(NULL),
_Running(false),
_running(false),
_pResourceManager(NULL),
_InitSuccess(false) {
_initSuccess(false) {
// Log that the kernel is beign created
BS_LOGLN("created.");
@ -63,10 +62,10 @@ Kernel::Kernel() :
for (uint i = 0; i < ARRAYSIZE(BS_SERVICE_TABLE); i++) {
// Is the superclass already registered?
Superclass *pCurSuperclass = NULL;
Common::Array<Superclass *>::iterator Iter;
for (Iter = _superclasses.begin(); Iter != _superclasses.end(); ++Iter)
if ((*Iter)->GetIdentifier() == BS_SERVICE_TABLE[i].superclassId) {
pCurSuperclass = *Iter;
Common::Array<Superclass *>::iterator iter;
for (iter = _superclasses.begin(); iter != _superclasses.end(); ++iter)
if ((*iter)->getIdentifier() == BS_SERVICE_TABLE[i].superclassId) {
pCurSuperclass = *iter;
break;
}
@ -76,7 +75,7 @@ Kernel::Kernel() :
}
// Create window object
_pWindow = Window::CreateBSWindow(0, 0, 0, 0, false);
_pWindow = Window::createBSWindow(0, 0, 0, 0, false);
if (!_pWindow) {
BS_LOG_ERRORLN("Failed to create the window.");
} else
@ -86,29 +85,30 @@ Kernel::Kernel() :
_pResourceManager = new ResourceManager(this);
// Initialise the script engine
ScriptEngine *pScript = static_cast<ScriptEngine *>(NewService("script", "lua"));
ScriptEngine *pScript = static_cast<ScriptEngine *>(newService("script", "lua"));
if (!pScript || !pScript->init()) {
_InitSuccess = false;
_initSuccess = false;
return;
}
// Register kernel script bindings
if (!_RegisterScriptBindings()) {
if (!registerScriptBindings()) {
BS_LOG_ERRORLN("Script bindings could not be registered.");
_InitSuccess = false;
_initSuccess = false;
return;
}
BS_LOGLN("Script bindings registered.");
_InitSuccess = true;
_initSuccess = true;
}
Kernel::~Kernel() {
// Services are de-registered in reverse order of creation
while (!_ServiceCreationOrder.empty()) {
Superclass *superclass = GetSuperclassByIdentifier(_ServiceCreationOrder.top());
if (superclass) superclass->DisconnectService();
_ServiceCreationOrder.pop();
while (!_serviceCreationOrder.empty()) {
Superclass *superclass = getSuperclassByIdentifier(_serviceCreationOrder.top());
if (superclass)
superclass->disconnectService();
_serviceCreationOrder.pop();
}
// Empty the Superclass list
@ -127,21 +127,18 @@ Kernel::~Kernel() {
BS_LOGLN("destroyed.");
}
// Service Methoden
// ----------------
Kernel::Superclass::Superclass(Kernel *pKernel, const Common::String &Identifier) :
Kernel::Superclass::Superclass(Kernel *pKernel, const Common::String &identifier) :
_pKernel(pKernel),
_Identifier(Identifier),
_ServiceCount(0),
_ActiveService(NULL) {
_identifier(identifier),
_serviceCount(0),
_activeService(NULL) {
for (uint i = 0; i < ARRAYSIZE(BS_SERVICE_TABLE); i++)
if (BS_SERVICE_TABLE[i].superclassId == _Identifier)
_ServiceCount++;
if (BS_SERVICE_TABLE[i].superclassId == _identifier)
_serviceCount++;
}
Kernel::Superclass::~Superclass() {
DisconnectService();
disconnectService();
}
/**
@ -153,16 +150,17 @@ Kernel::Superclass::~Superclass() {
* Hierbei ist zu beachten, dass der erste Service die Nummer 0 erhält. Number muss also eine Zahl zwischen
* 0 und GetServiceCount() - 1 sein.
*/
Common::String Kernel::Superclass::GetServiceIdentifier(uint Number) {
if (Number > _ServiceCount) return NULL;
Common::String Kernel::Superclass::getServiceIdentifier(uint number) {
if (number > _serviceCount)
return NULL;
uint CurServiceOrd = 0;
uint curServiceOrd = 0;
for (uint i = 0; i < ARRAYSIZE(BS_SERVICE_TABLE); i++) {
if (BS_SERVICE_TABLE[i].superclassId == _Identifier) {
if (Number == CurServiceOrd)
if (BS_SERVICE_TABLE[i].superclassId == _identifier) {
if (number == curServiceOrd)
return BS_SERVICE_TABLE[i].serviceId;
else
CurServiceOrd++;
curServiceOrd++;
}
}
@ -178,25 +176,25 @@ Common::String Kernel::Superclass::GetServiceIdentifier(uint Number) {
* @param serviceId The name of the service
* For the superclass "sfx" an example could be "Fmod" or "directsound"
*/
Service *Kernel::Superclass::NewService(const Common::String &serviceId) {
Service *Kernel::Superclass::newService(const Common::String &serviceId) {
for (uint i = 0; i < ARRAYSIZE(BS_SERVICE_TABLE); i++)
if (BS_SERVICE_TABLE[i].superclassId == _Identifier &&
if (BS_SERVICE_TABLE[i].superclassId == _identifier &&
BS_SERVICE_TABLE[i].serviceId == serviceId) {
Service *newService = BS_SERVICE_TABLE[i].create(_pKernel);
Service *newService_ = BS_SERVICE_TABLE[i].create(_pKernel);
if (newService) {
DisconnectService();
BS_LOGLN("Service '%s' created from superclass '%s'.", serviceId.c_str(), _Identifier.c_str());
_ActiveService = newService;
_ActiveServiceName = BS_SERVICE_TABLE[i].serviceId;
return _ActiveService;
if (newService_) {
disconnectService();
BS_LOGLN("Service '%s' created from superclass '%s'.", serviceId.c_str(), _identifier.c_str());
_activeService = newService_;
_activeServiceName = BS_SERVICE_TABLE[i].serviceId;
return _activeService;
} else {
BS_LOG_ERRORLN("Failed to create service '%s' from superclass '%s'.", serviceId.c_str(), _Identifier.c_str());
BS_LOG_ERRORLN("Failed to create service '%s' from superclass '%s'.", serviceId.c_str(), _identifier.c_str());
return NULL;
}
}
BS_LOG_ERRORLN("Service '%s' is not avaliable from superclass '%s'.", serviceId.c_str(), _Identifier.c_str());
BS_LOG_ERRORLN("Service '%s' is not avaliable from superclass '%s'.", serviceId.c_str(), _identifier.c_str());
return NULL;
}
@ -206,32 +204,32 @@ Service *Kernel::Superclass::NewService(const Common::String &serviceId) {
* @param superclassId The name of the superclass which is to be disconnected
* e.g.: "sfx", "gfx", "package" ...
*/
bool Kernel::Superclass::DisconnectService() {
if (_ActiveService) {
delete _ActiveService;
_ActiveService = 0;
BS_LOGLN("Active service '%s' disconnected from superclass '%s'.", _ActiveServiceName.c_str(), _Identifier.c_str());
bool Kernel::Superclass::disconnectService() {
if (_activeService) {
delete _activeService;
_activeService = 0;
BS_LOGLN("Active service '%s' disconnected from superclass '%s'.", _activeServiceName.c_str(), _identifier.c_str());
return true;
}
return false;
}
Kernel::Superclass *Kernel::GetSuperclassByIdentifier(const Common::String &Identifier) const {
Common::Array<Superclass *>::const_iterator Iter;
for (Iter = _superclasses.begin(); Iter != _superclasses.end(); ++Iter) {
if ((*Iter)->GetIdentifier() == Identifier)
return *Iter;
Kernel::Superclass *Kernel::getSuperclassByIdentifier(const Common::String &identifier) const {
Common::Array<Superclass *>::const_iterator iter;
for (iter = _superclasses.begin(); iter != _superclasses.end(); ++iter) {
if ((*iter)->getIdentifier() == identifier)
return *iter;
}
// BS_LOG_ERRORLN("Superclass '%s' does not exist.", Identifier.c_str());
// BS_LOG_ERRORLN("Superclass '%s' does not exist.", identifier.c_str());
return NULL;
}
/**
* Returns the number of register superclasses
*/
uint Kernel::GetSuperclassCount() const {
uint Kernel::getSuperclassCount() const {
return _superclasses.size();
}
@ -241,17 +239,17 @@ uint Kernel::GetSuperclassCount() const {
* @param Number The number of the superclass to return the identifier for.
* It should be noted that the number should be between 0 und GetSuperclassCount() - 1.
*/
Common::String Kernel::GetSuperclassIdentifier(uint Number) const {
if (Number > _superclasses.size())
Common::String Kernel::getSuperclassIdentifier(uint number) const {
if (number > _superclasses.size())
return NULL;
uint CurSuperclassOrd = 0;
Common::Array<Superclass *>::const_iterator Iter;
for (Iter = _superclasses.begin(); Iter != _superclasses.end(); ++Iter) {
if (CurSuperclassOrd == Number)
return ((*Iter)->GetIdentifier());
uint curSuperclassOrd = 0;
Common::Array<Superclass *>::const_iterator iter;
for (iter = _superclasses.begin(); iter != _superclasses.end(); ++iter) {
if (curSuperclassOrd == number)
return ((*iter)->getIdentifier());
CurSuperclassOrd++;
curSuperclassOrd++;
}
return Common::String();
@ -262,12 +260,12 @@ Common::String Kernel::GetSuperclassIdentifier(uint Number) const {
* @param superclassId The name of the superclass
* e.g.: "sfx", "gfx", "package" ...
*/
uint Kernel::GetServiceCount(const Common::String &superclassId) const {
Superclass *pSuperclass = GetSuperclassByIdentifier(superclassId);
uint Kernel::getServiceCount(const Common::String &superclassId) const {
Superclass *pSuperclass = getSuperclassByIdentifier(superclassId);
if (!pSuperclass)
return 0;
return pSuperclass->GetServiceCount();
return pSuperclass->getServiceCount();
}
@ -280,12 +278,12 @@ uint Kernel::GetServiceCount(const Common::String &superclassId) const {
* Hierbei ist zu beachten, dass der erste Service die Nummer 0 erhält. Number muss also eine Zahl zwischen
* 0 und GetServiceCount() - 1 sein.
*/
Common::String Kernel::GetServiceIdentifier(const Common::String &superclassId, uint Number) const {
Superclass *pSuperclass = GetSuperclassByIdentifier(superclassId);
Common::String Kernel::getServiceIdentifier(const Common::String &superclassId, uint number) const {
Superclass *pSuperclass = getSuperclassByIdentifier(superclassId);
if (!pSuperclass)
return NULL;
return (pSuperclass->GetServiceIdentifier(Number));
return (pSuperclass->getServiceIdentifier(number));
}
/**
@ -297,15 +295,15 @@ Common::String Kernel::GetServiceIdentifier(const Common::String &superclassId,
* @param serviceId The name of the service
* For the superclass "sfx" an example could be "Fmod" or "directsound"
*/
Service *Kernel::NewService(const Common::String &superclassId, const Common::String &serviceId) {
Superclass *pSuperclass = GetSuperclassByIdentifier(superclassId);
Service *Kernel::newService(const Common::String &superclassId, const Common::String &serviceId) {
Superclass *pSuperclass = getSuperclassByIdentifier(superclassId);
if (!pSuperclass)
return NULL;
// Die Reihenfolge merken, in der Services erstellt werden, damit sie später in umgekehrter Reihenfolge entladen werden können.
_ServiceCreationOrder.push(superclassId);
_serviceCreationOrder.push(superclassId);
return pSuperclass->NewService(serviceId);
return pSuperclass->newService(serviceId);
}
/**
@ -314,12 +312,12 @@ Service *Kernel::NewService(const Common::String &superclassId, const Common::St
* e.g.: "sfx", "gfx", "package" ...
* @return true on success, and false if the superclass does not exist or if not service was active.
*/
bool Kernel::DisconnectService(const Common::String &superclassId) {
Superclass *pSuperclass = GetSuperclassByIdentifier(superclassId);
bool Kernel::disconnectService(const Common::String &superclassId) {
Superclass *pSuperclass = getSuperclassByIdentifier(superclassId);
if (!pSuperclass)
return false;
return pSuperclass->DisconnectService();
return pSuperclass->disconnectService();
}
/**
@ -327,12 +325,12 @@ bool Kernel::DisconnectService(const Common::String &superclassId) {
* @param superclassId The name of the superclass
* e.g.: "sfx", "gfx", "package" ...
*/
Service *Kernel::GetService(const Common::String &superclassId) {
Superclass *pSuperclass = GetSuperclassByIdentifier(superclassId);
Service *Kernel::getService(const Common::String &superclassId) {
Superclass *pSuperclass = getSuperclassByIdentifier(superclassId);
if (!pSuperclass)
return NULL;
return (pSuperclass->GetActiveService());
return (pSuperclass->getActiveService());
}
/**
@ -341,113 +339,83 @@ Service *Kernel::GetService(const Common::String &superclassId) {
* @param superclassId The name of the superclass
* e.g.: "sfx", "gfx", "package" ...
*/
Common::String Kernel::GetActiveServiceIdentifier(const Common::String &superclassId) {
Superclass *pSuperclass = GetSuperclassByIdentifier(superclassId);
Common::String Kernel::getActiveServiceIdentifier(const Common::String &superclassId) {
Superclass *pSuperclass = getSuperclassByIdentifier(superclassId);
if (!pSuperclass)
return Common::String();
return pSuperclass->GetActiveServiceName();
return pSuperclass->getActiveServiceName();
}
// -----------------------------------------------------------------------------
/**
* Returns a random number
* @param Min The minimum allowed value
* @param Max The maximum allowed value
*/
int Kernel::GetRandomNumber(int Min, int Max) {
BS_ASSERT(Min <= Max);
int Kernel::getRandomNumber(int min, int max) {
BS_ASSERT(min <= max);
return Min + _rnd.getRandomNumber(Max - Min + 1);
return min + _rnd.getRandomNumber(max - min + 1);
}
/**
* Returns the elapsed time since startup in milliseconds
*/
uint Kernel::GetMilliTicks() {
uint Kernel::getMilliTicks() {
return g_system->getMillis();
}
// Other methods
// -----------------
/**
* Returns how much memory is being used
*/
size_t Kernel::GetUsedMemory() {
size_t Kernel::getUsedMemory() {
return 0;
#ifdef SCUMMVM_DISABLED_CODE
PROCESS_MEMORY_COUNTERS pmc;
pmc.cb = sizeof(pmc);
if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc))) {
return pmc.WorkingSetSize;
} else {
BS_LOG_ERRORLN("Call to GetProcessMemoryInfo() failed. Error code: %d", GetLastError());
return 0;
}
#endif
}
// -----------------------------------------------------------------------------
/**
* Returns a pointer to the active Gfx Service, or NULL if no Gfx service is active.
*/
GraphicEngine *Kernel::GetGfx() {
return static_cast<GraphicEngine *>(GetService("gfx"));
GraphicEngine *Kernel::getGfx() {
return static_cast<GraphicEngine *>(getService("gfx"));
}
// -----------------------------------------------------------------------------
/**
* Returns a pointer to the active Sfx Service, or NULL if no Sfx service is active.
*/
SoundEngine *Kernel::GetSfx() {
return static_cast<SoundEngine *>(GetService("sfx"));
SoundEngine *Kernel::getSfx() {
return static_cast<SoundEngine *>(getService("sfx"));
}
// -----------------------------------------------------------------------------
/**
* Returns a pointer to the active input service, or NULL if no input service is active.
*/
InputEngine *Kernel::GetInput() {
return static_cast<InputEngine *>(GetService("input"));
InputEngine *Kernel::getInput() {
return static_cast<InputEngine *>(getService("input"));
}
// -----------------------------------------------------------------------------
/**
* Returns a pointer to the active package manager, or NULL if no manager is active.
*/
PackageManager *Kernel::GetPackage() {
return static_cast<PackageManager *>(GetService("package"));
PackageManager *Kernel::getPackage() {
return static_cast<PackageManager *>(getService("package"));
}
// -----------------------------------------------------------------------------
/**
* Returns a pointer to the script engine, or NULL if it is not active.
*/
ScriptEngine *Kernel::GetScript() {
return static_cast<ScriptEngine *>(GetService("script"));
ScriptEngine *Kernel::getScript() {
return static_cast<ScriptEngine *>(getService("script"));
}
// -----------------------------------------------------------------------------
/**
* Returns a pointer to the movie player, or NULL if it is not active.
*/
MoviePlayer *Kernel::GetFMV() {
return static_cast<MoviePlayer *>(GetService("fmv"));
MoviePlayer *Kernel::getFMV() {
return static_cast<MoviePlayer *>(getService("fmv"));
}
// -----------------------------------------------------------------------------
void Kernel::Sleep(uint Msecs) const {
g_system->delayMillis(Msecs);
void Kernel::sleep(uint msecs) const {
g_system->delayMillis(msecs);
}
} // End of namespace Sword25

131
engines/sword25/kernel/kernel.h
View file

@ -45,7 +45,6 @@
#ifndef SWORD25_KERNEL_H
#define SWORD25_KERNEL_H
// Includes
#include "common/scummsys.h"
#include "common/random.h"
#include "common/stack.h"
@ -81,7 +80,7 @@ public:
/**
* Returns a pointer to the window object
*/
Window *GetWindow() {
Window *getWindow() {
return _pWindow;
}
@ -97,7 +96,7 @@ public:
* @param ServiceIdentifier The name of the service
* For the superclass "sfx" an example could be "Fmod" or "directsound"
*/
Service *NewService(const Common::String &SuperclassIdentifier, const Common::String &ServiceIdentifier);
Service *newService(const Common::String &superclassIdentifier, const Common::String &serviceIdentifier);
/**
* Ends the current service of a superclass. Returns true on success, and false if the superclass
@ -105,14 +104,14 @@ public:
* @param SuperclassIdentfier The name of the superclass which is to be disconnected
* z.B: "sfx", "gfx", "package" ...
*/
bool DisconnectService(const Common::String &SuperclassIdentifier);
bool disconnectService(const Common::String &superclassIdentifier);
/**
* Returns a pointer to the currently active service object of a superclass
* @param SuperclassIdentfier The name of the superclass
* z.B: "sfx", "gfx", "package" ...
*/
Service *GetService(const Common::String &SuperclassIdentifier);
Service *getService(const Common::String &superclassIdentifier);
/**
* Returns the name of the currentl active service object of a superclass.
@ -120,12 +119,12 @@ public:
* @param SuperclassIdentfier The name of the superclass
* z.B: "sfx", "gfx", "package" ...
*/
Common::String GetActiveServiceIdentifier(const Common::String &SuperclassIdentifier);
Common::String getActiveServiceIdentifier(const Common::String &superclassIdentifier);
/**
* Returns the number of register superclasses
*/
uint GetSuperclassCount() const;
uint getSuperclassCount() const;
/**
* Returns the name of a superclass with the specified index.
@ -133,14 +132,14 @@ public:
* @param Number The number of the superclass to return the identifier for.
* It should be noted that the number should be between 0 und GetSuperclassCount() - 1.
*/
Common::String GetSuperclassIdentifier(uint Number) const;
Common::String getSuperclassIdentifier(uint number) const;
/**
* Returns the number of services registered with a given superclass
* @param SuperclassIdentifier The name of the superclass
* z.B: "sfx", "gfx", "package" ...
*/
uint GetServiceCount(const Common::String &SuperclassIdentifier) const;
uint getServiceCount(const Common::String &superclassIdentifier) const;
/**
* Gets the identifier of a service with a given superclass.
@ -151,73 +150,74 @@ public:
* Hierbei ist zu beachten, dass der erste Service die Nummer 0 erhält. Number muss also eine Zahl zwischen
* 0 und GetServiceCount() - 1 sein.
*/
Common::String GetServiceIdentifier(const Common::String &SuperclassIdentifier, uint Number) const;
Common::String getServiceIdentifier(const Common::String &superclassIdentifier, uint number) const;
/**
* Returns the elapsed time since startup in milliseconds
*/
uint GetMilliTicks();
uint getMilliTicks();
/**
* Specifies whether the kernel was successfully initialised
*/
bool GetInitSuccess() const {
return _InitSuccess;
bool getInitSuccess() const {
return _initSuccess;
}
/**
* Returns a pointer to the BS_ResourceManager
*/
ResourceManager *GetResourceManager() {
ResourceManager *getResourceManager() {
return _pResourceManager;
}
/**
* Returns how much memory is being used
*/
size_t GetUsedMemory();
size_t getUsedMemory();
/**
* Returns a random number
* @param Min The minimum allowed value
* @param Max The maximum allowed value
*/
int GetRandomNumber(int Min, int Max);
int getRandomNumber(int min, int max);
/**
* Returns a pointer to the active Gfx Service, or NULL if no Gfx service is active
*/
GraphicEngine *GetGfx();
GraphicEngine *getGfx();
/**
* Returns a pointer to the active Sfx Service, or NULL if no Sfx service is active
*/
SoundEngine *GetSfx();
SoundEngine *getSfx();
/**
* Returns a pointer to the active input service, or NULL if no input service is active
*/
InputEngine *GetInput();
InputEngine *getInput();
/**
* Returns a pointer to the active package manager, or NULL if no manager is active
*/
PackageManager *GetPackage();
PackageManager *getPackage();
/**
* Returns a pointer to the script engine, or NULL if it is not active
*/
ScriptEngine *GetScript();
ScriptEngine *getScript();
/**
* Returns a pointer to the movie player, or NULL if it is not active
*/
MoviePlayer *GetFMV();
MoviePlayer *getFMV();
/**
* Pauses for the specified amount of time
* @param Msecs The amount of time in milliseconds
*/
void Sleep(uint Msecs) const;
void sleep(uint msecs) const;
/**
* Returns the singleton instance for the kernel
*/
static Kernel *GetInstance() {
if (!_Instance) _Instance = new Kernel();
return _Instance;
static Kernel *getInstance() {
if (!_instance)
_instance = new Kernel();
return _instance;
}
/**
@ -225,18 +225,18 @@ public:
* This method should only be called when the game is ended. No subsequent calls to any kernel
* methods should be done after calling this method.
*/
static void DeleteInstance() {
if (_Instance) {
delete _Instance;
_Instance = NULL;
static void deleteInstance() {
if (_instance) {
delete _instance;
_instance = NULL;
}
}
/**
* Raises an error. This method is used in crashing testing.
*/
void Crash() const {
error("BS_Kernel::Crash");
void crash() const {
error("Kernel::Crash");
}
private:
@ -251,45 +251,45 @@ private:
// -----------------------------------------------------------------------------
// Singleton instance
// -----------------------------------------------------------------------------
static Kernel *_Instance;
static Kernel *_instance;
// Superclass class
// ----------------
class Superclass {
private:
Kernel *_pKernel;
uint _ServiceCount;
Common::String _Identifier;
Service *_ActiveService;
Common::String _ActiveServiceName;
uint _serviceCount;
Common::String _identifier;
Service *_activeService;
Common::String _activeServiceName;
public:
Superclass(Kernel *pKernel, const Common::String &Identifier);
Superclass(Kernel *pKernel, const Common::String &identifier);
~Superclass();
uint GetServiceCount() const {
return _ServiceCount;
uint getServiceCount() const {
return _serviceCount;
}
Common::String GetIdentifier() const {
return _Identifier;
Common::String getIdentifier() const {
return _identifier;
}
Service *GetActiveService() const {
return _ActiveService;
Service *getActiveService() const {
return _activeService;
}
Common::String GetActiveServiceName() const {
return _ActiveServiceName;
Common::String getActiveServiceName() const {
return _activeServiceName;
}
Common::String GetServiceIdentifier(uint Number);
Service *NewService(const Common::String &ServiceIdentifier);
bool DisconnectService();
Common::String getServiceIdentifier(uint number);
Service *newService(const Common::String &serviceIdentifier);
bool disconnectService();
};
Common::Array<Superclass *> _superclasses;
Common::Stack<Common::String> _ServiceCreationOrder;
Superclass *GetSuperclassByIdentifier(const Common::String &Identifier) const;
Common::Stack<Common::String> _serviceCreationOrder;
Superclass *getSuperclassByIdentifier(const Common::String &identifier) const;
bool _InitSuccess; // Specifies whether the engine was set up correctly
bool _Running; // Specifies whether the application should keep running on the next main loop iteration
bool _initSuccess; // Specifies whether the engine was set up correctly
bool _running; // Specifies whether the application should keep running on the next main loop iteration
// Active window
// -------------
@ -299,34 +299,11 @@ private:
// -----------------------
Common::RandomSource _rnd;
/*
// Features variables and methods
// ----------------------------------
enum _CPU_FEATURES_BITMASKS
{
_MMX_BITMASK = (1 << 23),
_SSE_BITMASK = (1 << 25),
_SSE2_BITMASK = (1 << 26),
_3DNOW_BITMASK = (1 << 30),
_3DNOWEXT_BITMASK = (1 << 31)
};
bool _DetectCPU();
bool _MMXPresent;
bool _SSEPresent;
bool _SSE2Present;
bool _3DNowPresent;
bool _3DNowExtPresent;
CPU_TYPES _CPUType;
Common::String _CPUVendorID;
*/
// Resourcemanager
// ---------------
ResourceManager *_pResourceManager;
bool _RegisterScriptBindings();
bool registerScriptBindings();
};
} // End of namespace Sword25

585
engines/sword25/kernel/kernel_script.cpp
View file

@ -32,10 +32,6 @@
*
*/
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "sword25/kernel/common.h"
#include "sword25/kernel/kernel.h"
#include "sword25/kernel/filesystemutil.h"
@ -47,131 +43,107 @@
namespace Sword25 {
// -----------------------------------------------------------------------------
static int DisconnectService(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int disconnectService(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
lua_pushboolean(L, pKernel->DisconnectService(luaL_checkstring(L, 1)));
lua_pushboolean(L, pKernel->disconnectService(luaL_checkstring(L, 1)));
return 1;
}
// -----------------------------------------------------------------------------
static int GetActiveServiceIdentifier(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getActiveServiceIdentifier(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
lua_pushstring(L, pKernel->GetActiveServiceIdentifier(luaL_checkstring(L, 1)).c_str());
lua_pushstring(L, pKernel->getActiveServiceIdentifier(luaL_checkstring(L, 1)).c_str());
return 1;
}
// -----------------------------------------------------------------------------
static int GetSuperclassCount(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getSuperclassCount(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
lua_pushnumber(L, pKernel->GetSuperclassCount());
lua_pushnumber(L, pKernel->getSuperclassCount());
return 1;
}
// -----------------------------------------------------------------------------
static int GetSuperclassIdentifier(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getSuperclassIdentifier(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
lua_pushstring(L, pKernel->GetSuperclassIdentifier(
lua_pushstring(L, pKernel->getSuperclassIdentifier(
static_cast<uint>(luaL_checknumber(L, 1))).c_str());
return 1;
}
// -----------------------------------------------------------------------------
static int GetServiceCount(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getServiceCount(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
lua_pushnumber(L, pKernel->GetServiceCount(luaL_checkstring(L, 1)));
lua_pushnumber(L, pKernel->getServiceCount(luaL_checkstring(L, 1)));
return 1;
}
// -----------------------------------------------------------------------------
static int GetServiceIdentifier(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getServiceIdentifier(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
lua_pushstring(L, pKernel->GetServiceIdentifier(luaL_checkstring(L, 1),
lua_pushstring(L, pKernel->getServiceIdentifier(luaL_checkstring(L, 1),
static_cast<uint>(luaL_checknumber(L, 2))).c_str());
return 1;
}
// -----------------------------------------------------------------------------
static int GetMilliTicks(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getMilliTicks(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
lua_pushnumber(L, pKernel->GetMilliTicks());
lua_pushnumber(L, pKernel->getMilliTicks());
return 1;
}
// -----------------------------------------------------------------------------
static int GetTimer(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getTimer(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
lua_pushnumber(L, static_cast<lua_Number>(pKernel->GetMilliTicks()) / 1000.0);
lua_pushnumber(L, static_cast<lua_Number>(pKernel->getMilliTicks()) / 1000.0);
return 1;
}
// -----------------------------------------------------------------------------
static int StartService(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int startService(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
lua_pushbooleancpp(L, pKernel->NewService(luaL_checkstring(L, 1), luaL_checkstring(L, 2)) != NULL);
lua_pushbooleancpp(L, pKernel->newService(luaL_checkstring(L, 1), luaL_checkstring(L, 2)) != NULL);
return 1;
}
// -----------------------------------------------------------------------------
static int Sleep(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int sleep(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
pKernel->Sleep(static_cast<uint>(luaL_checknumber(L, 1) * 1000));
pKernel->sleep(static_cast<uint>(luaL_checknumber(L, 1) * 1000));
return 0;
}
// -----------------------------------------------------------------------------
static int Crash(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int crash(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
pKernel->Crash();
pKernel->crash();
return 0;
}
// -----------------------------------------------------------------------------
static int ExecuteFile(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int executeFile(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ScriptEngine *pSE = pKernel->GetScript();
ScriptEngine *pSE = pKernel->getScript();
BS_ASSERT(pSE);
lua_pushbooleancpp(L, pSE->executeFile(luaL_checkstring(L, 1)));
@ -179,551 +151,456 @@ static int ExecuteFile(lua_State *L) {
return 0;
}
// -----------------------------------------------------------------------------
static int GetUserdataDirectory(lua_State *L) {
lua_pushstring(L, FileSystemUtil::GetInstance().GetUserdataDirectory().c_str());
static int getUserdataDirectory(lua_State *L) {
lua_pushstring(L, FileSystemUtil::getInstance().getUserdataDirectory().c_str());
return 1;
}
// -----------------------------------------------------------------------------
static int GetPathSeparator(lua_State *L) {
lua_pushstring(L, FileSystemUtil::GetInstance().GetPathSeparator().c_str());
static int getPathSeparator(lua_State *L) {
lua_pushstring(L, FileSystemUtil::getInstance().getPathSeparator().c_str());
return 1;
}
// -----------------------------------------------------------------------------
static int FileExists(lua_State *L) {
lua_pushbooleancpp(L, FileSystemUtil::GetInstance().FileExists(luaL_checkstring(L, 1)));
static int fileExists(lua_State *L) {
lua_pushbooleancpp(L, FileSystemUtil::getInstance().fileExists(luaL_checkstring(L, 1)));
return 1;
}
// -----------------------------------------------------------------------------
static int CreateDirectory(lua_State *L) {
lua_pushbooleancpp(L, FileSystemUtil::GetInstance().CreateDirectory(luaL_checkstring(L, 1)));
static int createDirectory(lua_State *L) {
lua_pushbooleancpp(L, FileSystemUtil::getInstance().createDirectory(luaL_checkstring(L, 1)));
return 1;
}
// -----------------------------------------------------------------------------
static int GetWinCode(lua_State *L) {
static int getWinCode(lua_State *L) {
lua_pushstring(L, "ScummVM");
return 1;
}
// -----------------------------------------------------------------------------
static int GetSubversionRevision(lua_State *L) {
static int getSubversionRevision(lua_State *L) {
// ScummVM is 1337
lua_pushnumber(L, 1337);
return 1;
}
// -----------------------------------------------------------------------------
static int GetUsedMemory(lua_State *L) {
lua_pushnumber(L, Kernel::GetInstance()->GetUsedMemory());
static int getUsedMemory(lua_State *L) {
lua_pushnumber(L, Kernel::getInstance()->getUsedMemory());
return 1;
}
// -----------------------------------------------------------------------------
static const char *KERNEL_LIBRARY_NAME = "Kernel";
static const luaL_reg KERNEL_FUNCTIONS[] = {
{"DisconnectService", DisconnectService},
{"GetActiveServiceIdentifier", GetActiveServiceIdentifier},
{"GetSuperclassCount", GetSuperclassCount},
{"GetSuperclassIdentifier", GetSuperclassIdentifier},
{"GetServiceCount", GetServiceCount},
{"GetServiceIdentifier", GetServiceIdentifier},
{"GetMilliTicks", GetMilliTicks},
{"GetTimer", GetTimer},
{"StartService", StartService},
{"Sleep", Sleep},
{"Crash", Crash},
{"ExecuteFile", ExecuteFile},
{"GetUserdataDirectory", GetUserdataDirectory},
{"GetPathSeparator", GetPathSeparator},
{"FileExists", FileExists},
{"CreateDirectory", CreateDirectory},
{"GetWinCode", GetWinCode},
{"GetSubversionRevision", GetSubversionRevision},
{"GetUsedMemory", GetUsedMemory},
{"DisconnectService", disconnectService},
{"GetActiveServiceIdentifier", getActiveServiceIdentifier},
{"GetSuperclassCount", getSuperclassCount},
{"GetSuperclassIdentifier", getSuperclassIdentifier},
{"GetServiceCount", getServiceCount},
{"GetServiceIdentifier", getServiceIdentifier},
{"GetMilliTicks", getMilliTicks},
{"GetTimer", getTimer},
{"StartService", startService},
{"Sleep", sleep},
{"Crash", crash},
{"ExecuteFile", executeFile},
{"GetUserdataDirectory", getUserdataDirectory},
{"GetPathSeparator", getPathSeparator},
{"FileExists", fileExists},
{"CreateDirectory", createDirectory},
{"GetWinCode", getWinCode},
{"GetSubversionRevision", getSubversionRevision},
{"GetUsedMemory", getUsedMemory},
{0, 0}
};
// -----------------------------------------------------------------------------
static int IsVisible(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int isVisible(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
lua_pushbooleancpp(L, pWindow->IsVisible());
lua_pushbooleancpp(L, pWindow->isVisible());
return 1;
}
// -----------------------------------------------------------------------------
static int SetVisible(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int setVisible(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
pWindow->SetVisible(lua_tobooleancpp(L, 1));
pWindow->setVisible(lua_tobooleancpp(L, 1));
return 0;
}
// -----------------------------------------------------------------------------
static int GetX(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getX(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
lua_pushnumber(L, pWindow->GetX());
lua_pushnumber(L, pWindow->getX());
return 1;
}
// -----------------------------------------------------------------------------
static int GetY(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getY(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
lua_pushnumber(L, pWindow->GetY());
lua_pushnumber(L, pWindow->getY());
return 1;
}
// -----------------------------------------------------------------------------
static int SetX(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int setX(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
pWindow->SetX(static_cast<int>(luaL_checknumber(L, 1)));
pWindow->setX(static_cast<int>(luaL_checknumber(L, 1)));
return 0;
}
// -----------------------------------------------------------------------------
static int SetY(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int setY(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
pWindow->SetY(static_cast<int>(luaL_checknumber(L, 1)));
pWindow->setY(static_cast<int>(luaL_checknumber(L, 1)));
return 0;
}
// -----------------------------------------------------------------------------
static int GetClientX(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getClientX(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
lua_pushnumber(L, pWindow->GetClientX());
lua_pushnumber(L, pWindow->getClientX());
return 1;
}
// -----------------------------------------------------------------------------
static int GetClientY(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getClientY(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
lua_pushnumber(L, pWindow->GetClientY());
lua_pushnumber(L, pWindow->getClientY());
return 1;
}
// -----------------------------------------------------------------------------
static int GetWidth(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getWidth(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
lua_pushnumber(L, pWindow->GetWidth());
lua_pushnumber(L, pWindow->getWidth());
return 1;
}
// -----------------------------------------------------------------------------
static int GetHeight(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getHeight(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
lua_pushnumber(L, pWindow->GetHeight());
lua_pushnumber(L, pWindow->getHeight());
return 1;
}
// -----------------------------------------------------------------------------
static int SetWidth(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int setWidth(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
pWindow->SetWidth(static_cast<int>(luaL_checknumber(L, 1)));
pWindow->setWidth(static_cast<int>(luaL_checknumber(L, 1)));
return 0;
}
// -----------------------------------------------------------------------------
static int SetHeight(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int setHeight(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
pWindow->SetHeight(static_cast<int>(luaL_checknumber(L, 1)));
pWindow->setHeight(static_cast<int>(luaL_checknumber(L, 1)));
return 0;
}
// -----------------------------------------------------------------------------
static int GetTitle(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getTitle(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
lua_pushstring(L, pWindow->GetTitle().c_str());
lua_pushstring(L, pWindow->getTitle().c_str());
return 1;
}
// -----------------------------------------------------------------------------
static int SetTitle(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int setTitle(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
pWindow->SetTitle(luaL_checkstring(L, 1));
pWindow->setTitle(luaL_checkstring(L, 1));
return 0;
}
// -----------------------------------------------------------------------------
static int ProcessMessages(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int processMessages(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
lua_pushbooleancpp(L, pWindow->ProcessMessages());
lua_pushbooleancpp(L, pWindow->processMessages());
return 1;
}
// -----------------------------------------------------------------------------
static int CloseWanted(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int closeWanted(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
lua_pushbooleancpp(L, pWindow->CloseWanted());
lua_pushbooleancpp(L, pWindow->closeWanted());
return 1;
}
// -----------------------------------------------------------------------------
static int WaitForFocus(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int waitForFocus(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
lua_pushbooleancpp(L, pWindow->WaitForFocus());
lua_pushbooleancpp(L, pWindow->waitForFocus());
return 1;
}
// -----------------------------------------------------------------------------
static int HasFocus(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int hasFocus(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
Window *pWindow = pKernel->GetWindow();
Window *pWindow = pKernel->getWindow();
BS_ASSERT(pWindow);
lua_pushbooleancpp(L, pWindow->HasFocus());
lua_pushbooleancpp(L, pWindow->hasFocus());
return 1;
}
// -----------------------------------------------------------------------------
static const char *WINDOW_LIBRARY_NAME = "Window";
static const luaL_reg WINDOW_FUNCTIONS[] = {
{"IsVisible", IsVisible},
{"SetVisible", SetVisible},
{"GetX", GetX},
{"SetX", SetX},
{"GetY", GetY},
{"SetY", SetY},
{"GetClientX", GetClientX},
{"GetClientY", GetClientY},
{"GetWidth", GetWidth},
{"GetHeight", GetHeight},
{"SetWidth", SetWidth},
{"SetHeight", SetHeight},
{"GetTitle", GetTitle},
{"SetTitle", SetTitle},
{"ProcessMessages", ProcessMessages},
{"CloseWanted", CloseWanted},
{"WaitForFocus", WaitForFocus},
{"HasFocus", HasFocus},
{"IsVisible", isVisible},
{"SetVisible", setVisible},
{"GetX", getX},
{"SetX", setX},
{"GetY", getY},
{"SetY", setY},
{"GetClientX", getClientX},
{"GetClientY", getClientY},
{"GetWidth", getWidth},
{"GetHeight", getHeight},
{"SetWidth", setWidth},
{"SetHeight", setHeight},
{"GetTitle", getTitle},
{"SetTitle", setTitle},
{"ProcessMessages", processMessages},
{"CloseWanted", closeWanted},
{"WaitForFocus", waitForFocus},
{"HasFocus", hasFocus},
{0, 0}
};
// -----------------------------------------------------------------------------
static int PrecacheResource(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int precacheResource(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ResourceManager *pResource = pKernel->GetResourceManager();
ResourceManager *pResource = pKernel->getResourceManager();
BS_ASSERT(pResource);
lua_pushbooleancpp(L, pResource->PrecacheResource(luaL_checkstring(L, 1)));
lua_pushbooleancpp(L, pResource->precacheResource(luaL_checkstring(L, 1)));
return 1;
}
// -----------------------------------------------------------------------------
static int ForcePrecacheResource(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int forcePrecacheResource(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ResourceManager *pResource = pKernel->GetResourceManager();
ResourceManager *pResource = pKernel->getResourceManager();
BS_ASSERT(pResource);
lua_pushbooleancpp(L, pResource->PrecacheResource(luaL_checkstring(L, 1), true));
lua_pushbooleancpp(L, pResource->precacheResource(luaL_checkstring(L, 1), true));
return 1;
}
// -----------------------------------------------------------------------------
static int GetMaxMemoryUsage(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int getMaxMemoryUsage(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ResourceManager *pResource = pKernel->GetResourceManager();
ResourceManager *pResource = pKernel->getResourceManager();
BS_ASSERT(pResource);
lua_pushnumber(L, pResource->GetMaxMemoryUsage());
lua_pushnumber(L, pResource->getMaxMemoryUsage());
return 1;
}
// -----------------------------------------------------------------------------
static int SetMaxMemoryUsage(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int setMaxMemoryUsage(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ResourceManager *pResource = pKernel->GetResourceManager();
ResourceManager *pResource = pKernel->getResourceManager();
BS_ASSERT(pResource);
pResource->SetMaxMemoryUsage(static_cast<uint>(lua_tonumber(L, 1)));
pResource->setMaxMemoryUsage(static_cast<uint>(lua_tonumber(L, 1)));
return 0;
}
// -----------------------------------------------------------------------------
static int EmptyCache(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int emptyCache(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ResourceManager *pResource = pKernel->GetResourceManager();
ResourceManager *pResource = pKernel->getResourceManager();
BS_ASSERT(pResource);
pResource->EmptyCache();
pResource->emptyCache();
return 0;
}
// -----------------------------------------------------------------------------
static int IsLogCacheMiss(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int isLogCacheMiss(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ResourceManager *pResource = pKernel->GetResourceManager();
ResourceManager *pResource = pKernel->getResourceManager();
BS_ASSERT(pResource);
lua_pushbooleancpp(L, pResource->IsLogCacheMiss());
lua_pushbooleancpp(L, pResource->isLogCacheMiss());
return 1;
}
// -----------------------------------------------------------------------------
static int SetLogCacheMiss(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int setLogCacheMiss(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ResourceManager *pResource = pKernel->GetResourceManager();
ResourceManager *pResource = pKernel->getResourceManager();
BS_ASSERT(pResource);
pResource->SetLogCacheMiss(lua_tobooleancpp(L, 1));
pResource->setLogCacheMiss(lua_tobooleancpp(L, 1));
return 0;
}
// -----------------------------------------------------------------------------
static int DumpLockedResources(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
static int dumpLockedResources(lua_State *L) {
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ResourceManager *pResource = pKernel->GetResourceManager();
ResourceManager *pResource = pKernel->getResourceManager();
BS_ASSERT(pResource);
pResource->DumpLockedResources();
pResource->dumpLockedResources();
return 0;
}
// -----------------------------------------------------------------------------
static const char *RESOURCE_LIBRARY_NAME = "Resource";
static const luaL_reg RESOURCE_FUNCTIONS[] = {
{"PrecacheResource", PrecacheResource},
{"ForcePrecacheResource", ForcePrecacheResource},
{"GetMaxMemoryUsage", GetMaxMemoryUsage},
{"SetMaxMemoryUsage", SetMaxMemoryUsage},
{"EmptyCache", EmptyCache},
{"IsLogCacheMiss", IsLogCacheMiss},
{"SetLogCacheMiss", SetLogCacheMiss},
{"DumpLockedResources", DumpLockedResources},
{"PrecacheResource", precacheResource},
{"ForcePrecacheResource", forcePrecacheResource},
{"GetMaxMemoryUsage", getMaxMemoryUsage},
{"SetMaxMemoryUsage", setMaxMemoryUsage},
{"EmptyCache", emptyCache},
{"IsLogCacheMiss", isLogCacheMiss},
{"SetLogCacheMiss", setLogCacheMiss},
{"DumpLockedResources", dumpLockedResources},
{0, 0}
};
// -----------------------------------------------------------------------------
static int ReloadSlots(lua_State *L) {
PersistenceService::GetInstance().ReloadSlots();
static int reloadSlots(lua_State *L) {
PersistenceService::getInstance().reloadSlots();
lua_pushnil(L);
return 1;
}
// -----------------------------------------------------------------------------
static int GetSlotCount(lua_State *L) {
lua_pushnumber(L, PersistenceService::GetInstance().GetSlotCount());
static int getSlotCount(lua_State *L) {
lua_pushnumber(L, PersistenceService::getInstance().getSlotCount());
return 1;
}
// -----------------------------------------------------------------------------
static int isSlotOccupied(lua_State *L) {
lua_pushbooleancpp(L, PersistenceService::getInstance().isSlotOccupied(static_cast<uint>(luaL_checknumber(L, 1)) - 1));
return 1;
}
static int IsSlotOccupied(lua_State *L) {
lua_pushbooleancpp(L, PersistenceService::GetInstance().IsSlotOccupied(
static int getSavegameDirectory(lua_State *L) {
lua_pushstring(L, PersistenceService::getInstance().getSavegameDirectory().c_str());
return 1;
}
static int isSavegameCompatible(lua_State *L) {
lua_pushbooleancpp(L, PersistenceService::getInstance().isSavegameCompatible(
static_cast<uint>(luaL_checknumber(L, 1)) - 1));
return 1;
}
// -----------------------------------------------------------------------------
static int GetSavegameDirectory(lua_State *L) {
lua_pushstring(L, PersistenceService::GetInstance().GetSavegameDirectory().c_str());
return 1;
}
// -----------------------------------------------------------------------------
static int IsSavegameCompatible(lua_State *L) {
lua_pushbooleancpp(L, PersistenceService::GetInstance().IsSavegameCompatible(
static_cast<uint>(luaL_checknumber(L, 1)) - 1));
return 1;
}
// -----------------------------------------------------------------------------
static int GetSavegameDescription(lua_State *L) {
lua_pushstring(L, PersistenceService::GetInstance().GetSavegameDescription(
static int getSavegameDescription(lua_State *L) {
lua_pushstring(L, PersistenceService::getInstance().getSavegameDescription(
static_cast<uint>(luaL_checknumber(L, 1)) - 1).c_str());
return 1;
}
// -----------------------------------------------------------------------------
static int GetSavegameFilename(lua_State *L) {
lua_pushstring(L, PersistenceService::GetInstance().GetSavegameFilename(static_cast<uint>(luaL_checknumber(L, 1)) - 1).c_str());
static int getSavegameFilename(lua_State *L) {
lua_pushstring(L, PersistenceService::getInstance().getSavegameFilename(static_cast<uint>(luaL_checknumber(L, 1)) - 1).c_str());
return 1;
}
// -----------------------------------------------------------------------------
static int LoadGame(lua_State *L) {
lua_pushbooleancpp(L, PersistenceService::GetInstance().LoadGame(static_cast<uint>(luaL_checknumber(L, 1)) - 1));
static int loadGame(lua_State *L) {
lua_pushbooleancpp(L, PersistenceService::getInstance().loadGame(static_cast<uint>(luaL_checknumber(L, 1)) - 1));
return 1;
}
// -----------------------------------------------------------------------------
static int SaveGame(lua_State *L) {
lua_pushbooleancpp(L, PersistenceService::GetInstance().SaveGame(static_cast<uint>(luaL_checknumber(L, 1)) - 1, luaL_checkstring(L, 2)));
static int saveGame(lua_State *L) {
lua_pushbooleancpp(L, PersistenceService::getInstance().saveGame(static_cast<uint>(luaL_checknumber(L, 1)) - 1, luaL_checkstring(L, 2)));
return 1;
}
// -----------------------------------------------------------------------------
static const char *PERSISTENCE_LIBRARY_NAME = "Persistence";
static const luaL_reg PERSISTENCE_FUNCTIONS[] = {
{"ReloadSlots", ReloadSlots},
{"GetSlotCount", GetSlotCount},
{"IsSlotOccupied", IsSlotOccupied},
{"GetSavegameDirectory", GetSavegameDirectory},
{"IsSavegameCompatible", IsSavegameCompatible},
{"GetSavegameDescription", GetSavegameDescription},
{"GetSavegameFilename", GetSavegameFilename},
{"LoadGame", LoadGame},
{"SaveGame", SaveGame},
{"ReloadSlots", reloadSlots},
{"GetSlotCount", getSlotCount},
{"IsSlotOccupied", isSlotOccupied},
{"GetSavegameDirectory", getSavegameDirectory},
{"IsSavegameCompatible", isSavegameCompatible},
{"GetSavegameDescription", getSavegameDescription},
{"GetSavegameFilename", getSavegameFilename},
{"LoadGame", loadGame},
{"SaveGame", saveGame},
{0, 0}
};
// -----------------------------------------------------------------------------
bool Kernel::_RegisterScriptBindings() {
ScriptEngine *pScript = GetScript();
bool Kernel::registerScriptBindings() {
ScriptEngine *pScript = getScript();
BS_ASSERT(pScript);
lua_State *L = static_cast<lua_State *>(pScript->getScriptObject());
BS_ASSERT(L);

176
engines/sword25/kernel/log.cpp
View file

@ -39,32 +39,31 @@
namespace Sword25 {
// Constants
static const char *BF_LOG_FILENAME = "log.txt";
static const size_t LOG_BUFFERSIZE = 1024 * 16;
// Logging will take place only when it's activated
#ifdef BS_ACTIVATE_LOGGING
Common::WriteStream *BS_Log::_LogFile = NULL;
bool BS_Log::_LineBegin = true;
const char *BS_Log::_Prefix = NULL;
const char *BS_Log::_File = NULL;
int BS_Log::_Line = 0;
bool BS_Log::_AutoNewline = false;
Common::WriteStream *BS_Log::_logFile = NULL;
bool BS_Log::_lineBegin = true;
const char *BS_Log::_prefix = NULL;
const char *BS_Log::_file = NULL;
int BS_Log::_line = 0;
bool BS_Log::_autoNewline = false;
bool BS_Log::_CreateLog() {
bool BS_Log::createLog() {
// Open the log file
Common::FSNode dataDir(ConfMan.get("path"));
Common::FSNode file = dataDir.getChild(BF_LOG_FILENAME);
// Open the file for saving
_LogFile = file.createWriteStream();
_logFile = file.createWriteStream();
if (_LogFile) {
if (_logFile) {
// Add a title into the log file
Log("Broken Sword 2.5 Engine - Build: %s - %s - VersionID: %s\n", __DATE__, __TIME__, gScummVMFullVersion);
Log("-----------------------------------------------------------------------------------------------------\n");
log("Broken Sword 2.5 Engine - Build: %s - %s - VersionID: %s\n", __DATE__, __TIME__, gScummVMFullVersion);
log("-----------------------------------------------------------------------------------------------------\n");
return true;
}
@ -73,141 +72,142 @@ bool BS_Log::_CreateLog() {
return false;
}
void BS_Log::_CloseLog() {
delete _LogFile;
_LogFile = NULL;
void BS_Log::closeLog() {
delete _logFile;
_logFile = NULL;
}
void BS_Log::Log(const char *Format, ...) {
char Message[LOG_BUFFERSIZE];
void BS_Log::log(const char *format, ...) {
char message[LOG_BUFFERSIZE];
// Create the message
va_list ArgList;
va_start(ArgList, Format);
vsnprintf(Message, sizeof(Message), Format, ArgList);
va_list argList;
va_start(argList, format);
vsnprintf(message, sizeof(message), format, argList);
// Log the message
_WriteLog(Message);
writeLog(message);
_FlushLog();
flushLog();
}
void BS_Log::LogPrefix(const char *Prefix, const char *Format, ...) {
char Message[LOG_BUFFERSIZE];
char ExtFormat[LOG_BUFFERSIZE];
void BS_Log::logPrefix(const char *prefix, const char *format, ...) {
char message[LOG_BUFFERSIZE];
char extFormat[LOG_BUFFERSIZE];
// If the issue has ceased at the beginning of a new line, the new issue to begin with the prefix
ExtFormat[0] = 0;
if (_LineBegin) {
snprintf(ExtFormat, sizeof(ExtFormat), "%s: ", Prefix);
_LineBegin = false;
extFormat[0] = 0;
if (_lineBegin) {
snprintf(extFormat, sizeof(extFormat), "%s: ", prefix);
_lineBegin = false;
}
// Format String pass line by line and each line with the initial prefix
for (;;) {
const char *NextLine = strstr(Format, "\n");
if (!NextLine || *(NextLine + strlen("\n")) == 0) {
Common::strlcat(ExtFormat, Format, sizeof(ExtFormat));
if (NextLine) _LineBegin = true;
const char *nextLine = strstr(format, "\n");
if (!nextLine || *(nextLine + strlen("\n")) == 0) {
Common::strlcat(extFormat, format, sizeof(extFormat));
if (nextLine)
_lineBegin = true;
break;
} else {
strncat(ExtFormat, Format, (NextLine - Format) + strlen("\n"));
Common::strlcat(ExtFormat, Prefix, sizeof(ExtFormat));
Common::strlcat(ExtFormat, ": ", sizeof(ExtFormat));
strncat(extFormat, format, (nextLine - format) + strlen("\n"));
Common::strlcat(extFormat, prefix, sizeof(extFormat));
Common::strlcat(extFormat, ": ", sizeof(extFormat));
}
Format = NextLine + strlen("\n");
format = nextLine + strlen("\n");
}
// Create message
va_list ArgList;
va_start(ArgList, Format);
vsnprintf(Message, sizeof(Message), ExtFormat, ArgList);
va_list argList;
va_start(argList, format);
vsnprintf(message, sizeof(message), extFormat, argList);
// Log the message
_WriteLog(Message);
writeLog(message);
_FlushLog();
flushLog();
}
void BS_Log::LogDecorated(const char *Format, ...) {
void BS_Log::logDecorated(const char *format, ...) {
// Nachricht erzeugen
char Message[LOG_BUFFERSIZE];
va_list ArgList;
va_start(ArgList, Format);
vsnprintf(Message, sizeof(Message), Format, ArgList);
char message[LOG_BUFFERSIZE];
va_list argList;
va_start(argList, format);
vsnprintf(message, sizeof(message), format, argList);
// Zweiten Prefix erzeugen, falls gewünscht
char SecondaryPrefix[1024];
if (_File && _Line)
snprintf(SecondaryPrefix, sizeof(SecondaryPrefix), "(file: %s, line: %d) - ", _File, _Line);
// Zweiten prefix erzeugen, falls gewünscht
char secondaryPrefix[1024];
if (_file && _line)
snprintf(secondaryPrefix, sizeof(secondaryPrefix), "(file: %s, line: %d) - ", _file, _line);
// Nachricht zeilenweise ausgeben und an jeden Zeilenanfang das Präfix setzen
char *MessageWalker = Message;
char *messageWalker = message;
for (;;) {
char *NextLine = strstr(MessageWalker, "\n");
if (NextLine) {
*NextLine = 0;
if (_LineBegin) {
_WriteLog(_Prefix);
if (_File && _Line)
_WriteLog(SecondaryPrefix);
char *nextLine = strstr(messageWalker, "\n");
if (nextLine) {
*nextLine = 0;
if (_lineBegin) {
writeLog(_prefix);
if (_file && _line)
writeLog(secondaryPrefix);
}
_WriteLog(MessageWalker);
_WriteLog("\n");
MessageWalker = NextLine + sizeof("\n") - 1;
_LineBegin = true;
writeLog(messageWalker);
writeLog("\n");
messageWalker = nextLine + sizeof("\n") - 1;
_lineBegin = true;
} else {
if (_LineBegin) {
_WriteLog(_Prefix);
if (_File && _Line)
_WriteLog(SecondaryPrefix);
if (_lineBegin) {
writeLog(_prefix);
if (_file && _line)
writeLog(secondaryPrefix);
}
_WriteLog(MessageWalker);
_LineBegin = false;
writeLog(messageWalker);
_lineBegin = false;
break;
}
}
// Falls gewünscht, wird ans Ende der Nachricht automatisch ein Newline angehängt.
if (_AutoNewline) {
_WriteLog("\n");
_LineBegin = true;
if (_autoNewline) {
writeLog("\n");
_lineBegin = true;
}
// Pseudoparameter zurücksetzen
_Prefix = NULL;
_File = 0;
_Line = 0;
_AutoNewline = false;
_prefix = NULL;
_file = 0;
_line = 0;
_autoNewline = false;
_FlushLog();
flushLog();
}
int BS_Log::_WriteLog(const char *Message) {
if (!_LogFile && !_CreateLog())
int BS_Log::writeLog(const char *message) {
if (!_logFile && !createLog())
return false;
debugN(0, "%s", Message);
debugN(0, "%s", message);
_LogFile->writeString(Message);
_logFile->writeString(message);
return true;
}
void BS_Log::_FlushLog() {
if (_LogFile)
_LogFile->flush();
void BS_Log::flushLog() {
if (_logFile)
_logFile->flush();
}
void (*BS_LogPtr)(const char *, ...) = BS_Log::Log;
void (*BS_LogPtr)(const char *, ...) = BS_Log::log;
void BS_Log_C(const char *Message) {
BS_LogPtr(Message);
void BS_Log_C(const char *message) {
BS_LogPtr(message);
}
#else
void BS_Log_C(const char *Message) {};
void BS_Log_C(const char *message) {};
#endif

76
engines/sword25/kernel/log.h
View file

@ -46,50 +46,50 @@ namespace Sword25 {
#ifdef BS_ACTIVATE_LOGGING
// Logging-Makros
#define BS_LOG BS_Log::SetPrefix(BS_LOG_PREFIX ": "), BS_Log::LogDecorated
#define BS_LOGLN BS_Log::SetPrefix(BS_LOG_PREFIX ": "), BS_Log::SetAutoNewline(true), BS_Log::LogDecorated
#define BS_LOG_WARNING BS_Log::SetPrefix(BS_LOG_PREFIX ": WARNING - "), BS_Log::LogDecorated
#define BS_LOG_WARNINGLN BS_Log::SetPrefix(BS_LOG_PREFIX ": WARNING - "), BS_Log::SetAutoNewline(true), BS_Log::LogDecorated
#define BS_LOG_ERROR BS_Log::SetPrefix(BS_LOG_PREFIX ": ERROR - "), BS_Log::LogDecorated
#define BS_LOG_ERRORLN BS_Log::SetPrefix(BS_LOG_PREFIX ": ERROR - "), BS_Log::SetAutoNewline(true), BS_Log::LogDecorated
#define BS_LOG_EXTERROR BS_Log::SetPrefix(BS_LOG_PREFIX ": ERROR "), BS_Log::SetFile(__FILE__), BS_Log::SetLine(__LINE__), BS_Log::LogDecorated
#define BS_LOG_EXTERRORLN BS_Log::SetPrefix(BS_LOG_PREFIX ": ERROR "), BS_Log::SetFile(__FILE__), BS_Log::SetLine(__LINE__), BS_Log::SetAutoNewline(true), BS_Log::LogDecorated
#define BS_LOG BS_Log::setPrefix(BS_LOG_PREFIX ": "), BS_Log::logDecorated
#define BS_LOGLN BS_Log::setPrefix(BS_LOG_PREFIX ": "), BS_Log::setAutoNewline(true), BS_Log::logDecorated
#define BS_LOG_WARNING BS_Log::setPrefix(BS_LOG_PREFIX ": WARNING - "), BS_Log::logDecorated
#define BS_LOG_WARNINGLN BS_Log::setPrefix(BS_LOG_PREFIX ": WARNING - "), BS_Log::setAutoNewline(true), BS_Log::logDecorated
#define BS_LOG_ERROR BS_Log::setPrefix(BS_LOG_PREFIX ": ERROR - "), BS_Log::logDecorated
#define BS_LOG_ERRORLN BS_Log::setPrefix(BS_LOG_PREFIX ": ERROR - "), BS_Log::setAutoNewline(true), BS_Log::logDecorated
#define BS_LOG_EXTERROR BS_Log::setPrefix(BS_LOG_PREFIX ": ERROR "), BS_Log::setFile(__FILE__), BS_Log::setLine(__LINE__), BS_Log::logDecorated
#define BS_LOG_EXTERRORLN BS_Log::setPrefix(BS_LOG_PREFIX ": ERROR "), BS_Log::setFile(__FILE__), BS_Log::setLine(__LINE__), BS_Log::setAutoNewline(true), BS_Log::logDecorated
// Die Version der Logging-Klasse mit aktiviertem Logging
class BS_Log {
public:
static void Clear();
static void Log(const char *Format, ...);
static void LogPrefix(const char *Prefix, const char *Format, ...);
static void LogDecorated(const char *Format, ...);
static void clear();
static void log(const char *format, ...);
static void logPrefix(const char *prefix, const char *format, ...);
static void logDecorated(const char *format, ...);
static void SetPrefix(const char *Prefix) {
_Prefix = Prefix;
static void setPrefix(const char *prefix) {
_prefix = prefix;
}
static void SetFile(const char *File) {
_File = File;
static void setFile(const char *file) {
_file = file;
}
static void SetLine(int Line) {
_Line = Line;
static void setLine(int line) {
_line = line;
}
static void SetAutoNewline(bool AutoNewline) {
_AutoNewline = AutoNewline;
static void setAutoNewline(bool autoNewline) {
_autoNewline = autoNewline;
}
static void _CloseLog();
static void closeLog();
private:
static Common::WriteStream *_LogFile;
static bool _LineBegin;
static const char *_Prefix;
static const char *_File;
static int _Line;
static bool _AutoNewline;
static Common::WriteStream *_logFile;
static bool _lineBegin;
static const char *_prefix;
static const char *_file;
static int _line;
static bool _autoNewline;
static bool _CreateLog();
static bool createLog();
static int _WriteLog(const char *Message);
static void _FlushLog();
static int writeLog(const char *message);
static void flushLog();
};
// Auxiliary function that allows to log C functions (needed for Lua).
@ -112,17 +112,17 @@ private:
class BS_Log {
public:
// This version implements all the various methods as empty stubs
static void Log(const char *Text, ...) {};
static void LogPrefix(const char *Prefix, const char *Format, ...) {};
static void LogDecorated(const char *Format, ...) {};
static void log(const char *text, ...) {};
static void logPrefix(const char *prefix, const char *format, ...) {};
static void logDecorated(const char *format, ...) {};
static void SetPrefix(const char *Prefix) {};
static void SetFile(const char *File) {};
static void SetLine(int Line) {};
static void SetAutoNewline(bool AutoNewline) {};
static void setPrefix(const char *prefix) {};
static void setFile(const char *file) {};
static void setLine(int line) {};
static void setAutoNewline(bool autoNewline) {};
typedef void (*LOG_LISTENER_CALLBACK)(const char *);
static void RegisterLogListener(LOG_LISTENER_CALLBACK Callback) {};
static void registerLogListener(LOG_LISTENER_CALLBACK callback) {};
};
#define BS_Log_C error

96
engines/sword25/kernel/outputpersistenceblock.cpp
View file

@ -34,97 +34,67 @@
#define BS_LOG_PREFIX "OUTPUTPERSISTENCEBLOCK"
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "sword25/kernel/outputpersistenceblock.h"
// -----------------------------------------------------------------------------
// Constants
// -----------------------------------------------------------------------------
namespace {
const uint INITIAL_BUFFER_SIZE = 1024 * 64;
}
namespace Sword25 {
// -----------------------------------------------------------------------------
// Construction / Destruction
// -----------------------------------------------------------------------------
OutputPersistenceBlock::OutputPersistenceBlock() {
m_Data.reserve(INITIAL_BUFFER_SIZE);
_data.reserve(INITIAL_BUFFER_SIZE);
}
// -----------------------------------------------------------------------------
// Writing
// -----------------------------------------------------------------------------
void OutputPersistenceBlock::write(signed int Value) {
WriteMarker(SINT_MARKER);
Value = ConvertEndianessFromSystemToStorage(Value);
RawWrite(&Value, sizeof(Value));
void OutputPersistenceBlock::write(signed int value) {
writeMarker(SINT_MARKER);
value = convertEndianessFromSystemToStorage(value);
rawWrite(&value, sizeof(value));
}
// -----------------------------------------------------------------------------
void OutputPersistenceBlock::write(uint Value) {
WriteMarker(UINT_MARKER);
Value = ConvertEndianessFromSystemToStorage(Value);
RawWrite(&Value, sizeof(Value));
void OutputPersistenceBlock::write(uint value) {
writeMarker(UINT_MARKER);
value = convertEndianessFromSystemToStorage(value);
rawWrite(&value, sizeof(value));
}
// -----------------------------------------------------------------------------
void OutputPersistenceBlock::write(float Value) {
WriteMarker(FLOAT_MARKER);
Value = ConvertEndianessFromSystemToStorage(Value);
RawWrite(&Value, sizeof(Value));
void OutputPersistenceBlock::write(float value) {
writeMarker(FLOAT_MARKER);
value = convertEndianessFromSystemToStorage(value);
rawWrite(&value, sizeof(value));
}
// -----------------------------------------------------------------------------
void OutputPersistenceBlock::write(bool value) {
writeMarker(BOOL_MARKER);
void OutputPersistenceBlock::write(bool Value) {
WriteMarker(BOOL_MARKER);
uint UIntBool = Value ? 1 : 0;
UIntBool = ConvertEndianessFromSystemToStorage(UIntBool);
RawWrite(&UIntBool, sizeof(UIntBool));
uint uintBool = value ? 1 : 0;
uintBool = convertEndianessFromSystemToStorage(uintBool);
rawWrite(&uintBool, sizeof(uintBool));
}
// -----------------------------------------------------------------------------
void OutputPersistenceBlock::write(const Common::String &string) {
writeMarker(STRING_MARKER);
void OutputPersistenceBlock::write(const Common::String &String) {
WriteMarker(STRING_MARKER);
write(String.size());
RawWrite(String.c_str(), String.size());
write(string.size());
rawWrite(string.c_str(), string.size());
}
// -----------------------------------------------------------------------------
void OutputPersistenceBlock::write(const void *bufferPtr, size_t size) {
writeMarker(BLOCK_MARKER);
void OutputPersistenceBlock::write(const void *BufferPtr, size_t Size) {
WriteMarker(BLOCK_MARKER);
write((int) Size);
RawWrite(BufferPtr, Size);
write((int)size);
rawWrite(bufferPtr, size);
}
// -----------------------------------------------------------------------------
void OutputPersistenceBlock::WriteMarker(byte Marker) {
m_Data.push_back(Marker);
void OutputPersistenceBlock::writeMarker(byte marker) {
_data.push_back(marker);
}
// -----------------------------------------------------------------------------
void OutputPersistenceBlock::RawWrite(const void *DataPtr, size_t Size) {
if (Size > 0) {
uint OldSize = m_Data.size();
m_Data.resize(OldSize + Size);
memcpy(&m_Data[OldSize], DataPtr, Size);
void OutputPersistenceBlock::rawWrite(const void *dataPtr, size_t size) {
if (size > 0) {
uint oldSize = _data.size();
_data.resize(oldSize + size);
memcpy(&_data[oldSize], dataPtr, size);
}
}

34
engines/sword25/kernel/outputpersistenceblock.h
View file

@ -35,42 +35,34 @@
#ifndef SWORD25_OUTPUTPERSISTENCEBLOCK_H
#define SWORD25_OUTPUTPERSISTENCEBLOCK_H
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "sword25/kernel/common.h"
#include "sword25/kernel/persistenceblock.h"
namespace Sword25 {
// -----------------------------------------------------------------------------
// Class declaration
// -----------------------------------------------------------------------------
class OutputPersistenceBlock : public PersistenceBlock {
public:
OutputPersistenceBlock();
void write(signed int Value);
void write(uint Value);
void write(float Value);
void write(bool Value);
void write(const Common::String &String);
void write(const void *BufferPtr, size_t Size);
void write(signed int value);
void write(uint value);
void write(float value);
void write(bool value);
void write(const Common::String &string);
void write(const void *bufferPtr, size_t size);
const void *GetData() const {
return &m_Data[0];
const void *getData() const {
return &_data[0];
}
uint GetDataSize() const {
return m_Data.size();
uint getDataSize() const {
return _data.size();
}
private:
void WriteMarker(byte Marker);
void RawWrite(const void *DataPtr, size_t Size);
void writeMarker(byte marker);
void rawWrite(const void *dataPtr, size_t size);
Common::Array<byte> m_Data;
Common::Array<byte> _data;
};
} // End of namespace Sword25

62
engines/sword25/kernel/persistenceblock.h
View file

@ -35,34 +35,26 @@
#ifndef SWORD25_PERSISTENCEBLOCK_H
#define SWORD25_PERSISTENCEBLOCK_H
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "sword25/kernel/common.h"
namespace Sword25 {
// -----------------------------------------------------------------------------
// Class definition
// -----------------------------------------------------------------------------
class PersistenceBlock {
public:
static uint GetSInt32Size() {
static uint getSInt32Size() {
return sizeof(signed int) + sizeof(byte);
}
static uint GetUInt32Size() {
static uint getUInt32Size() {
return sizeof(uint) + sizeof(byte);
}
static uint GetFloat32Size() {
static uint getFloat32Size() {
return sizeof(float) + sizeof(byte);
}
static uint GetBoolSize() {
static uint getBoolSize() {
return sizeof(byte) + sizeof(byte);
}
static uint GetStringSize(const Common::String &String) {
return static_cast<uint>(sizeof(uint) + String.size() + sizeof(byte));
static uint getStringSize(const Common::String &string) {
return static_cast<uint>(sizeof(uint) + string.size() + sizeof(byte));
}
protected:
@ -84,43 +76,41 @@ protected:
//
template<typename T>
static T ConvertEndianessFromSystemToStorage(T Value) {
if (IsBigEndian()) ReverseByteOrder(&Value);
return Value;
static T convertEndianessFromSystemToStorage(T value) {
if (isBigEndian())
reverseByteOrder(&value);
return value;
}
template<typename T>
static T ConvertEndianessFromStorageToSystem(T Value) {
if (IsBigEndian()) ReverseByteOrder(&Value);
return Value;
static T convertEndianessFromStorageToSystem(T value) {
if (isBigEndian())
reverseByteOrder(&value);
return value;
}
private:
static bool IsBigEndian() {
uint Dummy = 1;
byte *DummyPtr = reinterpret_cast<byte *>(&Dummy);
return DummyPtr[0] == 0;
static bool isBigEndian() {
uint dummy = 1;
byte *dummyPtr = reinterpret_cast<byte *>(&dummy);
return dummyPtr[0] == 0;
}
template<typename T>
static void Swap(T &One, T &Two) {
T Temp = One;
One = Two;
Two = Temp;
static void swap(T &one, T &two) {
T temp = one;
one = two;
two = temp;
}
static void ReverseByteOrder(void *Ptr) {
static void reverseByteOrder(void *ptr) {
// Reverses the byte order of the 32-bit word pointed to by Ptr
byte *CharPtr = static_cast<byte *>(Ptr);
Swap(CharPtr[0], CharPtr[3]);
Swap(CharPtr[1], CharPtr[2]);
byte *charPtr = static_cast<byte *>(ptr);
swap(charPtr[0], charPtr[3]);
swap(charPtr[1], charPtr[2]);
}
};
// -----------------------------------------------------------------------------
// Compile time asserts
// -----------------------------------------------------------------------------
#define CTASSERT(ex) typedef char ctassert_type[(ex) ? 1 : -1]
CTASSERT(sizeof(byte) == 1);
CTASSERT(sizeof(signed int) == 4);

387
engines/sword25/kernel/persistenceservice.cpp
View file

@ -32,10 +32,6 @@
*
*/
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "common/fs.h"
#include "common/savefile.h"
#include "sword25/kernel/kernel.h"
@ -52,37 +48,27 @@
#define BS_LOG_PREFIX "PERSISTENCESERVICE"
// -----------------------------------------------------------------------------
// Constants and utility functions
// -----------------------------------------------------------------------------
namespace Sword25 {
const char *SAVEGAME_EXTENSION = ".b25s";
const char *SAVEGAME_DIRECTORY = "saves";
const char *FILE_MARKER = "BS25SAVEGAME";
const char *SAVEGAME_EXTENSION = ".b25s";
const char *SAVEGAME_DIRECTORY = "saves";
const char *FILE_MARKER = "BS25SAVEGAME";
const uint SLOT_COUNT = 18;
const uint FILE_COPY_BUFFER_SIZE = 1024 * 10;
const char *VERSIONID = "SCUMMVM1";
// -------------------------------------------------------------------------
Common::String GenerateSavegameFilename(uint slotID) {
Common::String generateSavegameFilename(uint slotID) {
char buffer[10];
sprintf(buffer, "%d%s", slotID, SAVEGAME_EXTENSION);
return Common::String(buffer);
}
// -------------------------------------------------------------------------
Common::String GenerateSavegamePath(uint SlotID) {
Common::FSNode folder(PersistenceService::GetSavegameDirectory());
Common::String generateSavegamePath(uint slotID) {
Common::FSNode folder(PersistenceService::getSavegameDirectory());
return folder.getChild(GenerateSavegameFilename(SlotID)).getPath();
return folder.getChild(generateSavegameFilename(slotID)).getPath();
}
// -------------------------------------------------------------------------
Common::String FormatTimestamp(TimeDate Time) {
Common::String formatTimestamp(TimeDate time) {
// In the original BS2.5 engine, this used a local object to show the date/time as as a string.
// For now in ScummVM it's being hardcoded to 'dd-MON-yyyy hh:mm:ss'
Common::String monthList[12] = {
@ -90,157 +76,132 @@ Common::String FormatTimestamp(TimeDate Time) {
};
char buffer[100];
snprintf(buffer, 100, "%.2d-%s-%.4d %.2d:%.2d:%.2d",
Time.tm_mday, monthList[Time.tm_mon].c_str(), 1900 + Time.tm_year,
Time.tm_hour, Time.tm_min, Time.tm_sec
time.tm_mday, monthList[time.tm_mon].c_str(), 1900 + time.tm_year,
time.tm_hour, time.tm_min, time.tm_sec
);
return Common::String(buffer);
}
// -------------------------------------------------------------------------
Common::String loadString(Common::InSaveFile *in, uint maxSize = 999) {
Common::String result;
Common::String LoadString(Common::InSaveFile *In, uint MaxSize = 999) {
Common::String Result;
char ch = (char)In->readByte();
char ch = (char)in->readByte();
while ((ch != '\0') && (ch != ' ')) {
Result += ch;
if (Result.size() >= MaxSize) break;
ch = (char)In->readByte();
result += ch;
if (result.size() >= maxSize)
break;
ch = (char)in->readByte();
}
return Result;
return result;
}
}
namespace Sword25 {
// -----------------------------------------------------------------------------
// Private Implementation
// -----------------------------------------------------------------------------
struct SavegameInformation {
bool IsOccupied;
bool IsCompatible;
Common::String Description;
Common::String Filename;
uint GamedataLength;
uint GamedataOffset;
uint GamedataUncompressedLength;
bool isOccupied;
bool isCompatible;
Common::String description;
Common::String filename;
uint gamedataLength;
uint gamedataOffset;
uint gamedataUncompressedLength;
SavegameInformation() {
Clear();
clear();
}
void Clear() {
IsOccupied = false;
IsCompatible = false;
Description = "";
Filename = "";
GamedataLength = 0;
GamedataOffset = 0;
GamedataUncompressedLength = 0;
void clear() {
isOccupied = false;
isCompatible = false;
description = "";
filename = "";
gamedataLength = 0;
gamedataOffset = 0;
gamedataUncompressedLength = 0;
}
};
struct PersistenceService::Impl {
SavegameInformation m_SavegameInformations[SLOT_COUNT];
// -----------------------------------------------------------------------------
SavegameInformation _savegameInformations[SLOT_COUNT];
Impl() {
ReloadSlots();
reloadSlots();
}
// -----------------------------------------------------------------------------
void ReloadSlots() {
void reloadSlots() {
// Über alle Spielstanddateien iterieren und deren Infos einlesen.
for (uint i = 0; i < SLOT_COUNT; ++i) {
ReadSlotSavegameInformation(i);
readSlotSavegameInformation(i);
}
}
void ReadSlotSavegameInformation(uint SlotID) {
void readSlotSavegameInformation(uint slotID) {
// Aktuelle Slotinformationen in den Ausgangszustand versetzen, er wird im Folgenden neu gefüllt.
SavegameInformation &CurSavegameInfo = m_SavegameInformations[SlotID];
CurSavegameInfo.Clear();
SavegameInformation &curSavegameInfo = _savegameInformations[slotID];
curSavegameInfo.clear();
// Den Dateinamen für den Spielstand des Slots generieren.
Common::String Filename = GenerateSavegameFilename(SlotID);
Common::String filename = generateSavegameFilename(slotID);
// Try to open the savegame for loading
Common::SaveFileManager *sfm = g_system->getSavefileManager();
Common::InSaveFile *File = sfm->openForLoading(Filename);
Common::InSaveFile *file = sfm->openForLoading(filename);
if (File) {
if (file) {
// Read in the header
Common::String StoredMarker = LoadString(File);
Common::String StoredVersionID = LoadString(File);
Common::String gameDataLength = LoadString(File);
CurSavegameInfo.GamedataLength = atoi(gameDataLength.c_str());
Common::String gamedataUncompressedLength = LoadString(File);
CurSavegameInfo.GamedataUncompressedLength = atoi(gamedataUncompressedLength.c_str());
Common::String storedMarker = loadString(file);
Common::String storedVersionID = loadString(file);
Common::String gameDataLength = loadString(file);
curSavegameInfo.gamedataLength = atoi(gameDataLength.c_str());
Common::String gamedataUncompressedLength = loadString(file);
curSavegameInfo.gamedataUncompressedLength = atoi(gamedataUncompressedLength.c_str());
// If the header can be read in and is detected to be valid, we will have a valid file
if (StoredMarker == FILE_MARKER) {
if (storedMarker == FILE_MARKER) {
// Der Slot wird als belegt markiert.
CurSavegameInfo.IsOccupied = true;
curSavegameInfo.isOccupied = true;
// Speichern, ob der Spielstand kompatibel mit der aktuellen Engine-Version ist.
CurSavegameInfo.IsCompatible = (StoredVersionID == Common::String(VERSIONID));
curSavegameInfo.isCompatible = (storedVersionID == Common::String(VERSIONID));
// Dateinamen des Spielstandes speichern.
CurSavegameInfo.Filename = GenerateSavegameFilename(SlotID);
curSavegameInfo.filename = generateSavegameFilename(slotID);
// Die Beschreibung des Spielstandes besteht aus einer textuellen Darstellung des Änderungsdatums der Spielstanddatei.
CurSavegameInfo.Description = FormatTimestamp(FileSystemUtil::GetInstance().GetFileTime(Filename));
curSavegameInfo.description = formatTimestamp(FileSystemUtil::getInstance().getFileTime(filename));
// Den Offset zu den gespeicherten Spieldaten innerhalb der Datei speichern.
// Dieses entspricht der aktuellen Position, da nach der letzten Headerinformation noch ein Leerzeichen als trenner folgt.
CurSavegameInfo.GamedataOffset = static_cast<uint>(File->pos());
curSavegameInfo.gamedataOffset = static_cast<uint>(file->pos());
}
delete File;
delete file;
}
}
};
// -----------------------------------------------------------------------------
// Construction / Destruction
// -----------------------------------------------------------------------------
PersistenceService &PersistenceService::GetInstance() {
static PersistenceService Instance;
return Instance;
PersistenceService &PersistenceService::getInstance() {
static PersistenceService instance;
return instance;
}
// -----------------------------------------------------------------------------
PersistenceService::PersistenceService() : m_impl(new Impl) {
PersistenceService::PersistenceService() : _impl(new Impl) {
}
// -----------------------------------------------------------------------------
PersistenceService::~PersistenceService() {
delete m_impl;
delete _impl;
}
// -----------------------------------------------------------------------------
// Implementation
// -----------------------------------------------------------------------------
void PersistenceService::ReloadSlots() {
m_impl->ReloadSlots();
void PersistenceService::reloadSlots() {
_impl->reloadSlots();
}
// -----------------------------------------------------------------------------
uint PersistenceService::GetSlotCount() {
uint PersistenceService::getSlotCount() {
return SLOT_COUNT;
}
// -----------------------------------------------------------------------------
Common::String PersistenceService::GetSavegameDirectory() {
Common::FSNode node(FileSystemUtil::GetInstance().GetUserdataDirectory());
Common::String PersistenceService::getSavegameDirectory() {
Common::FSNode node(FileSystemUtil::getInstance().getUserdataDirectory());
Common::FSNode childNode = node.getChild(SAVEGAME_DIRECTORY);
// Try and return the path using the savegame subfolder. But if doesn't exist, fall back on the data directory
@ -250,13 +211,11 @@ Common::String PersistenceService::GetSavegameDirectory() {
return node.getPath();
}
// -----------------------------------------------------------------------------
namespace {
bool CheckSlotID(uint SlotID) {
bool checkslotID(uint slotID) {
// Überprüfen, ob die Slot-ID zulässig ist.
if (SlotID >= SLOT_COUNT) {
BS_LOG_ERRORLN("Tried to access an invalid slot (%d). Only slot ids from 0 to %d are allowed.", SlotID, SLOT_COUNT - 1);
if (slotID >= SLOT_COUNT) {
BS_LOG_ERRORLN("Tried to access an invalid slot (%d). Only slot ids from 0 to %d are allowed.", slotID, SLOT_COUNT - 1);
return false;
} else {
return true;
@ -264,142 +223,134 @@ bool CheckSlotID(uint SlotID) {
}
}
// -----------------------------------------------------------------------------
bool PersistenceService::IsSlotOccupied(uint SlotID) {
if (!CheckSlotID(SlotID)) return false;
return m_impl->m_SavegameInformations[SlotID].IsOccupied;
bool PersistenceService::isSlotOccupied(uint slotID) {
if (!checkslotID(slotID))
return false;
return _impl->_savegameInformations[slotID].isOccupied;
}
// -----------------------------------------------------------------------------
bool PersistenceService::IsSavegameCompatible(uint SlotID) {
if (!CheckSlotID(SlotID)) return false;
return m_impl->m_SavegameInformations[SlotID].IsCompatible;
bool PersistenceService::isSavegameCompatible(uint slotID) {
if (!checkslotID(slotID))
return false;
return _impl->_savegameInformations[slotID].isCompatible;
}
// -----------------------------------------------------------------------------
Common::String &PersistenceService::GetSavegameDescription(uint SlotID) {
static Common::String EmptyString;
if (!CheckSlotID(SlotID)) return EmptyString;
return m_impl->m_SavegameInformations[SlotID].Description;
Common::String &PersistenceService::getSavegameDescription(uint slotID) {
static Common::String emptyString;
if (!checkslotID(slotID))
return emptyString;
return _impl->_savegameInformations[slotID].description;
}
// -----------------------------------------------------------------------------
Common::String &PersistenceService::GetSavegameFilename(uint SlotID) {
static Common::String EmptyString;
if (!CheckSlotID(SlotID)) return EmptyString;
return m_impl->m_SavegameInformations[SlotID].Filename;
Common::String &PersistenceService::getSavegameFilename(uint slotID) {
static Common::String emptyString;
if (!checkslotID(slotID))
return emptyString;
return _impl->_savegameInformations[slotID].filename;
}
// -----------------------------------------------------------------------------
bool PersistenceService::SaveGame(uint SlotID, const Common::String &ScreenshotFilename) {
bool PersistenceService::saveGame(uint slotID, const Common::String &screenshotFilename) {
// Überprüfen, ob die Slot-ID zulässig ist.
if (SlotID >= SLOT_COUNT) {
BS_LOG_ERRORLN("Tried to save to an invalid slot (%d). Only slot ids form 0 to %d are allowed.", SlotID, SLOT_COUNT - 1);
if (slotID >= SLOT_COUNT) {
BS_LOG_ERRORLN("Tried to save to an invalid slot (%d). Only slot ids form 0 to %d are allowed.", slotID, SLOT_COUNT - 1);
return false;
}
// Dateinamen erzeugen.
Common::String Filename = GenerateSavegameFilename(SlotID);
Common::String filename = generateSavegameFilename(slotID);
// Sicherstellen, dass das Verzeichnis für die Spielstanddateien existiert.
FileSystemUtil::GetInstance().CreateDirectory(GetSavegameDirectory());
FileSystemUtil::getInstance().createDirectory(getSavegameDirectory());
// Spielstanddatei öffnen und die Headerdaten schreiben.
Common::SaveFileManager *sfm = g_system->getSavefileManager();
Common::OutSaveFile *File = sfm->openForSaving(Filename);
Common::OutSaveFile *file = sfm->openForSaving(filename);
File->writeString(FILE_MARKER);
File->writeByte(' ');
File->writeString(VERSIONID);
File->writeByte(' ');
file->writeString(FILE_MARKER);
file->writeByte(' ');
file->writeString(VERSIONID);
file->writeByte(' ');
if (File->err()) {
error("Unable to write header data to savegame file \"%s\".", Filename.c_str());
if (file->err()) {
error("Unable to write header data to savegame file \"%s\".", filename.c_str());
}
// Alle notwendigen Module persistieren.
OutputPersistenceBlock Writer;
bool Success = true;
Success &= Kernel::GetInstance()->GetScript()->persist(Writer);
Success &= RegionRegistry::instance().persist(Writer);
Success &= Kernel::GetInstance()->GetGfx()->persist(Writer);
Success &= Kernel::GetInstance()->GetSfx()->persist(Writer);
Success &= Kernel::GetInstance()->GetInput()->persist(Writer);
if (!Success) {
error("Unable to persist modules for savegame file \"%s\".", Filename.c_str());
OutputPersistenceBlock writer;
bool success = true;
success &= Kernel::getInstance()->getScript()->persist(writer);
success &= RegionRegistry::instance().persist(writer);
success &= Kernel::getInstance()->getGfx()->persist(writer);
success &= Kernel::getInstance()->getSfx()->persist(writer);
success &= Kernel::getInstance()->getInput()->persist(writer);
if (!success) {
error("Unable to persist modules for savegame file \"%s\".", filename.c_str());
}
// Daten komprimieren.
uLongf CompressedLength = Writer.GetDataSize() + (Writer.GetDataSize() + 500) / 1000 + 12;
Bytef *CompressionBuffer = new Bytef[CompressedLength];
uLongf compressedLength = writer.getDataSize() + (writer.getDataSize() + 500) / 1000 + 12;
Bytef *compressionBuffer = new Bytef[compressedLength];
if (compress2(&CompressionBuffer[0], &CompressedLength, reinterpret_cast<const Bytef *>(Writer.GetData()), Writer.GetDataSize(), 6) != Z_OK) {
error("Unable to compress savegame data in savegame file \"%s\".", Filename.c_str());
if (compress2(&compressionBuffer[0], &compressedLength, reinterpret_cast<const Bytef *>(writer.getData()), writer.getDataSize(), 6) != Z_OK) {
error("Unable to compress savegame data in savegame file \"%s\".", filename.c_str());
}
// Länge der komprimierten Daten und der unkomprimierten Daten in die Datei schreiben.
char sBuffer[10];
snprintf(sBuffer, 10, "%ld", CompressedLength);
File->writeString(sBuffer);
File->writeByte(' ');
snprintf(sBuffer, 10, "%u", Writer.GetDataSize());
File->writeString(sBuffer);
File->writeByte(' ');
snprintf(sBuffer, 10, "%ld", compressedLength);
file->writeString(sBuffer);
file->writeByte(' ');
snprintf(sBuffer, 10, "%u", writer.getDataSize());
file->writeString(sBuffer);
file->writeByte(' ');
// Komprimierte Daten in die Datei schreiben.
File->write(reinterpret_cast<char *>(&CompressionBuffer[0]), CompressedLength);
if (File->err()) {
error("Unable to write game data to savegame file \"%s\".", Filename.c_str());
file->write(reinterpret_cast<char *>(&compressionBuffer[0]), compressedLength);
if (file->err()) {
error("Unable to write game data to savegame file \"%s\".", filename.c_str());
}
// Get the screenshot
Common::MemoryReadStream *thumbnail = Kernel::GetInstance()->GetGfx()->getThumbnail();
Common::MemoryReadStream *thumbnail = Kernel::getInstance()->getGfx()->getThumbnail();
if (thumbnail) {
byte *Buffer = new Byte[FILE_COPY_BUFFER_SIZE];
byte *buffer = new Byte[FILE_COPY_BUFFER_SIZE];
while (!thumbnail->eos()) {
int bytesRead = thumbnail->read(&Buffer[0], FILE_COPY_BUFFER_SIZE);
File->write(&Buffer[0], bytesRead);
int bytesRead = thumbnail->read(&buffer[0], FILE_COPY_BUFFER_SIZE);
file->write(&buffer[0], bytesRead);
}
delete[] Buffer;
delete[] buffer;
} else {
BS_LOG_WARNINGLN("The screenshot file \"%s\" does not exist. Savegame is written without a screenshot.", Filename.c_str());
BS_LOG_WARNINGLN("The screenshot file \"%s\" does not exist. Savegame is written without a screenshot.", filename.c_str());
}
// Savegameinformationen für diesen Slot aktualisieren.
m_impl->ReadSlotSavegameInformation(SlotID);
_impl->readSlotSavegameInformation(slotID);
File->finalize();
delete File;
delete[] CompressionBuffer;
file->finalize();
delete file;
delete[] compressionBuffer;
// Erfolg signalisieren.
return true;
}
// -----------------------------------------------------------------------------
bool PersistenceService::LoadGame(uint SlotID) {
bool PersistenceService::loadGame(uint slotID) {
Common::SaveFileManager *sfm = g_system->getSavefileManager();
Common::InSaveFile *File;
Common::InSaveFile *file;
// Überprüfen, ob die Slot-ID zulässig ist.
if (SlotID >= SLOT_COUNT) {
BS_LOG_ERRORLN("Tried to load from an invalid slot (%d). Only slot ids form 0 to %d are allowed.", SlotID, SLOT_COUNT - 1);
if (slotID >= SLOT_COUNT) {
BS_LOG_ERRORLN("Tried to load from an invalid slot (%d). Only slot ids form 0 to %d are allowed.", slotID, SLOT_COUNT - 1);
return false;
}
SavegameInformation &CurSavegameInfo = m_impl->m_SavegameInformations[SlotID];
SavegameInformation &curSavegameInfo = _impl->_savegameInformations[slotID];
// Überprüfen, ob der Slot belegt ist.
if (!CurSavegameInfo.IsOccupied) {
BS_LOG_ERRORLN("Tried to load from an empty slot (%d).", SlotID);
if (!curSavegameInfo.isOccupied) {
BS_LOG_ERRORLN("Tried to load from an empty slot (%d).", slotID);
return false;
}
@ -407,54 +358,54 @@ bool PersistenceService::LoadGame(uint SlotID) {
// Im Debug-Modus wird dieser Test übersprungen. Für das Testen ist es hinderlich auf die Einhaltung dieser strengen Bedingung zu bestehen,
// da sich die Versions-ID bei jeder Codeänderung mitändert.
#ifndef DEBUG
if (!CurSavegameInfo.IsCompatible) {
BS_LOG_ERRORLN("Tried to load a savegame (%d) that is not compatible with this engine version.", SlotID);
if (!curSavegameInfo.isCompatible) {
BS_LOG_ERRORLN("Tried to load a savegame (%d) that is not compatible with this engine version.", slotID);
return false;
}
#endif
byte *CompressedDataBuffer = new byte[CurSavegameInfo.GamedataLength];
byte *UncompressedDataBuffer = new Bytef[CurSavegameInfo.GamedataUncompressedLength];
byte *compressedDataBuffer = new byte[curSavegameInfo.gamedataLength];
byte *uncompressedDataBuffer = new Bytef[curSavegameInfo.gamedataUncompressedLength];
File = sfm->openForLoading(GenerateSavegameFilename(SlotID));
file = sfm->openForLoading(generateSavegameFilename(slotID));
File->seek(CurSavegameInfo.GamedataOffset);
File->read(reinterpret_cast<char *>(&CompressedDataBuffer[0]), CurSavegameInfo.GamedataLength);
if (File->err()) {
BS_LOG_ERRORLN("Unable to load the gamedata from the savegame file \"%s\".", CurSavegameInfo.Filename.c_str());
delete[] CompressedDataBuffer;
delete[] UncompressedDataBuffer;
file->seek(curSavegameInfo.gamedataOffset);
file->read(reinterpret_cast<char *>(&compressedDataBuffer[0]), curSavegameInfo.gamedataLength);
if (file->err()) {
BS_LOG_ERRORLN("Unable to load the gamedata from the savegame file \"%s\".", curSavegameInfo.filename.c_str());
delete[] compressedDataBuffer;
delete[] uncompressedDataBuffer;
return false;
}
// Spieldaten dekomprimieren.
uLongf UncompressedBufferSize = CurSavegameInfo.GamedataUncompressedLength;
if (uncompress(reinterpret_cast<Bytef *>(&UncompressedDataBuffer[0]), &UncompressedBufferSize,
reinterpret_cast<Bytef *>(&CompressedDataBuffer[0]), CurSavegameInfo.GamedataLength) != Z_OK) {
BS_LOG_ERRORLN("Unable to decompress the gamedata from savegame file \"%s\".", CurSavegameInfo.Filename.c_str());
delete[] UncompressedDataBuffer;
delete[] CompressedDataBuffer;
delete File;
uLongf uncompressedBufferSize = curSavegameInfo.gamedataUncompressedLength;
if (uncompress(reinterpret_cast<Bytef *>(&uncompressedDataBuffer[0]), &uncompressedBufferSize,
reinterpret_cast<Bytef *>(&compressedDataBuffer[0]), curSavegameInfo.gamedataLength) != Z_OK) {
BS_LOG_ERRORLN("Unable to decompress the gamedata from savegame file \"%s\".", curSavegameInfo.filename.c_str());
delete[] uncompressedDataBuffer;
delete[] compressedDataBuffer;
delete file;
return false;
}
InputPersistenceBlock Reader(&UncompressedDataBuffer[0], CurSavegameInfo.GamedataUncompressedLength);
InputPersistenceBlock reader(&uncompressedDataBuffer[0], curSavegameInfo.gamedataUncompressedLength);
// Einzelne Engine-Module depersistieren.
bool Success = true;
Success &= Kernel::GetInstance()->GetScript()->unpersist(Reader);
bool success = true;
success &= Kernel::getInstance()->getScript()->unpersist(reader);
// Muss unbedingt nach Script passieren. Da sonst die bereits wiederhergestellten Regions per Garbage-Collection gekillt werden.
Success &= RegionRegistry::instance().unpersist(Reader);
Success &= Kernel::GetInstance()->GetGfx()->unpersist(Reader);
Success &= Kernel::GetInstance()->GetSfx()->unpersist(Reader);
Success &= Kernel::GetInstance()->GetInput()->unpersist(Reader);
success &= RegionRegistry::instance().unpersist(reader);
success &= Kernel::getInstance()->getGfx()->unpersist(reader);
success &= Kernel::getInstance()->getSfx()->unpersist(reader);
success &= Kernel::getInstance()->getInput()->unpersist(reader);
delete[] CompressedDataBuffer;
delete[] UncompressedDataBuffer;
delete File;
delete[] compressedDataBuffer;
delete[] uncompressedDataBuffer;
delete file;
if (!Success) {
BS_LOG_ERRORLN("Unable to unpersist the gamedata from savegame file \"%s\".", CurSavegameInfo.Filename.c_str());
if (!success) {
BS_LOG_ERRORLN("Unable to unpersist the gamedata from savegame file \"%s\".", curSavegameInfo.filename.c_str());
return false;
}

30
engines/sword25/kernel/persistenceservice.h
View file

@ -35,18 +35,10 @@
#ifndef SWORD25_PERSISTENCESERVICE_H
#define SWORD25_PERSISTENCESERVICE_H
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "sword25/kernel/common.h"
namespace Sword25 {
// -----------------------------------------------------------------------------
// Class declaration
// -----------------------------------------------------------------------------
class PersistenceService {
public:
PersistenceService();
@ -56,27 +48,27 @@ public:
// Singleton Method
// -----------------------------------------------------------------------------
static PersistenceService &GetInstance();
static PersistenceService &getInstance();
// -----------------------------------------------------------------------------
// Interface
// -----------------------------------------------------------------------------
static uint GetSlotCount();
static Common::String GetSavegameDirectory();
static uint getSlotCount();
static Common::String getSavegameDirectory();
void ReloadSlots();
bool IsSlotOccupied(uint SlotID);
bool IsSavegameCompatible(uint SlotID);
Common::String &GetSavegameDescription(uint SlotID);
Common::String &GetSavegameFilename(uint SlotID);
void reloadSlots();
bool isSlotOccupied(uint slotID);
bool isSavegameCompatible(uint slotID);
Common::String &getSavegameDescription(uint slotID);
Common::String &getSavegameFilename(uint slotID);
bool SaveGame(uint SlotID, const Common::String &ScreenshotFilename);
bool LoadGame(uint SlotID);
bool saveGame(uint slotID, const Common::String &screenshotFilename);
bool loadGame(uint slotID);
private:
struct Impl;
Impl *m_impl;
Impl *_impl;
};
} // End of namespace Sword25

172
engines/sword25/kernel/resmanager.cpp
View file

@ -45,20 +45,20 @@ namespace Sword25 {
ResourceManager::~ResourceManager() {
// Clear all unlocked resources
EmptyCache();
emptyCache();
// All remaining resources are not released, so print warnings and release
Common::List<Resource *>::iterator Iter = m_Resources.begin();
for (; Iter != m_Resources.end(); ++Iter) {
BS_LOG_WARNINGLN("Resource \"%s\" was not released.", (*Iter)->getFileName().c_str());
Common::List<Resource *>::iterator iter = _resources.begin();
for (; iter != _resources.end(); ++iter) {
BS_LOG_WARNINGLN("Resource \"%s\" was not released.", (*iter)->getFileName().c_str());
// Set the lock count to zero
while ((*Iter)->GetLockCount() > 0) {
(*Iter)->release();
while ((*iter)->getLockCount() > 0) {
(*iter)->release();
};
// Delete the resource
delete(*Iter);
delete(*iter);
}
}
@ -67,19 +67,19 @@ ResourceManager::~ResourceManager() {
* Note: This method is not optimised for speed and should be used only for debugging purposes
* @param Ord Ordinal number of the resource. Must be between 0 and GetResourceCount() - 1.
*/
Resource *ResourceManager::GetResourceByOrdinal(int Ord) const {
Resource *ResourceManager::getResourceByOrdinal(int ord) const {
// Überprüfen ob der Index Ord innerhald der Listengrenzen liegt.
if (Ord < 0 || Ord >= GetResourceCount()) {
BS_LOG_ERRORLN("Resource ordinal (%d) out of bounds (0 - %d).", Ord, GetResourceCount() - 1);
if (ord < 0 || ord >= getResourceCount()) {
BS_LOG_ERRORLN("Resource ordinal (%d) out of bounds (0 - %d).", ord, getResourceCount() - 1);
return NULL;
}
// Liste durchlaufen und die Resource mit dem gewünschten Index zurückgeben.
int CurOrd = 0;
Common::List<Resource *>::const_iterator Iter = m_Resources.begin();
for (; Iter != m_Resources.end(); ++Iter, ++CurOrd) {
if (CurOrd == Ord)
return (*Iter);
int curOrd = 0;
Common::List<Resource *>::const_iterator iter = _resources.begin();
for (; iter != _resources.end(); ++iter, ++curOrd) {
if (curOrd == ord)
return (*iter);
}
// Die Ausführung sollte nie an diesem Punkt ankommen.
@ -92,13 +92,13 @@ Resource *ResourceManager::GetResourceByOrdinal(int Ord) const {
* BS_ResourceService, and thus helps all resource services in the ResourceManager list
* @param pService Which service
*/
bool ResourceManager::RegisterResourceService(ResourceService *pService) {
bool ResourceManager::registerResourceService(ResourceService *pService) {
if (!pService) {
BS_LOG_ERRORLN("Can't register NULL resource service.");
return false;
}
m_ResourceServices.push_back(pService);
_resourceServices.push_back(pService);
return true;
}
@ -106,34 +106,36 @@ bool ResourceManager::RegisterResourceService(ResourceService *pService) {
/**
* Deletes resources as necessary until the specified memory limit is not being exceeded.
*/
void ResourceManager::DeleteResourcesIfNecessary() {
void ResourceManager::deleteResourcesIfNecessary() {
// If enough memory is available, or no resources are loaded, then the function can immediately end
if (m_KernelPtr->GetUsedMemory() < m_MaxMemoryUsage || m_Resources.empty()) return;
if (_kernelPtr->getUsedMemory() < _maxMemoryUsage || _resources.empty())
return;
// Keep deleting resources until the memory usage of the process falls below the set maximum limit.
// The list is processed backwards in order to first release those resources who have been
// not been accessed for the longest
Common::List<Resource *>::iterator Iter = m_Resources.end();
Common::List<Resource *>::iterator iter = _resources.end();
do {
--Iter;
--iter;
// The resource may be released only if it isn't locked
if ((*Iter)->GetLockCount() == 0) Iter = DeleteResource(*Iter);
} while (Iter != m_Resources.begin() && m_KernelPtr->GetUsedMemory() > m_MaxMemoryUsage);
if ((*iter)->getLockCount() == 0)
iter = deleteResource(*iter);
} while (iter != _resources.begin() && _kernelPtr->getUsedMemory() > _maxMemoryUsage);
}
/**
* Releases all resources that are not locked.
**/
void ResourceManager::EmptyCache() {
void ResourceManager::emptyCache() {
// Scan through the resource list
Common::List<Resource *>::iterator Iter = m_Resources.begin();
while (Iter != m_Resources.end()) {
if ((*Iter)->GetLockCount() == 0) {
Common::List<Resource *>::iterator iter = _resources.begin();
while (iter != _resources.end()) {
if ((*iter)->getLockCount() == 0) {
// Delete the resource
Iter = DeleteResource(*Iter);
iter = deleteResource(*iter);
} else
++Iter;
++iter;
}
}
@ -141,29 +143,30 @@ void ResourceManager::EmptyCache() {
* Returns a requested resource. If any error occurs, returns NULL
* @param FileName Filename of resource
*/
Resource *ResourceManager::RequestResource(const Common::String &FileName) {
Resource *ResourceManager::requestResource(const Common::String &fileName) {
// Get the absolute path to the file
Common::String UniqueFileName = GetUniqueFileName(FileName);
if (UniqueFileName == "")
Common::String uniqueFileName = getUniqueFileName(fileName);
if (uniqueFileName == "")
return NULL;
// Determine whether the resource is already loaded
// If the resource is found, it will be placed at the head of the resource list and returned
{
Resource *pResource = GetResource(UniqueFileName);
Resource *pResource = getResource(uniqueFileName);
if (pResource) {
MoveToFront(pResource);
(pResource)->AddReference();
moveToFront(pResource);
(pResource)->addReference();
return pResource;
}
}
// The resource was not found, therefore, must not be loaded yet
if (m_LogCacheMiss) BS_LOG_WARNINGLN("\"%s\" was not precached.", UniqueFileName.c_str());
if (_logCacheMiss)
BS_LOG_WARNINGLN("\"%s\" was not precached.", uniqueFileName.c_str());
Resource *pResource;
if ((pResource = loadResource(UniqueFileName))) {
pResource->AddReference();
if ((pResource = loadResource(uniqueFileName))) {
pResource->addReference();
return pResource;
}
@ -176,26 +179,26 @@ Resource *ResourceManager::RequestResource(const Common::String &FileName) {
* @param ForceReload Indicates whether the file should be reloaded if it's already in the cache.
* This is useful for files that may have changed in the interim
*/
bool ResourceManager::PrecacheResource(const Common::String &FileName, bool ForceReload) {
bool ResourceManager::precacheResource(const Common::String &fileName, bool forceReload) {
// Get the absolute path to the file
Common::String UniqueFileName = GetUniqueFileName(FileName);
if (UniqueFileName == "")
Common::String uniqueFileName = getUniqueFileName(fileName);
if (uniqueFileName == "")
return false;
Resource *ResourcePtr = GetResource(UniqueFileName);
Resource *resourcePtr = getResource(uniqueFileName);
if (ForceReload && ResourcePtr) {
if (ResourcePtr->GetLockCount()) {
BS_LOG_ERRORLN("Could not force precaching of \"%s\". The resource is locked.", FileName.c_str());
if (forceReload && resourcePtr) {
if (resourcePtr->getLockCount()) {
BS_LOG_ERRORLN("Could not force precaching of \"%s\". The resource is locked.", fileName.c_str());
return false;
} else {
DeleteResource(ResourcePtr);
ResourcePtr = 0;
deleteResource(resourcePtr);
resourcePtr = 0;
}
}
if (!ResourcePtr && loadResource(UniqueFileName) == NULL) {
BS_LOG_ERRORLN("Could not precache \"%s\",", FileName.c_str());
if (!resourcePtr && loadResource(uniqueFileName) == NULL) {
BS_LOG_ERRORLN("Could not precache \"%s\",", fileName.c_str());
return false;
}
@ -206,13 +209,13 @@ bool ResourceManager::PrecacheResource(const Common::String &FileName, bool Forc
* Moves a resource to the top of the resource list
* @param pResource The resource
*/
void ResourceManager::MoveToFront(Resource *pResource) {
void ResourceManager::moveToFront(Resource *pResource) {
// Erase the resource from it's current position
m_Resources.erase(pResource->_iterator);
_resources.erase(pResource->_iterator);
// Re-add the resource at the front of the list
m_Resources.push_front(pResource);
_resources.push_front(pResource);
// Reset the resource iterator to the repositioned item
pResource->_iterator = m_Resources.begin();
pResource->_iterator = _resources.begin();
}
/**
@ -223,24 +226,24 @@ void ResourceManager::MoveToFront(Resource *pResource) {
*/
Resource *ResourceManager::loadResource(const Common::String &fileName) {
// ResourceService finden, der die Resource laden kann.
for (uint i = 0; i < m_ResourceServices.size(); ++i) {
if (m_ResourceServices[i]->canLoadResource(fileName)) {
for (uint i = 0; i < _resourceServices.size(); ++i) {
if (_resourceServices[i]->canLoadResource(fileName)) {
// If more memory is desired, memory must be released
DeleteResourcesIfNecessary();
deleteResourcesIfNecessary();
// Load the resource
Resource *pResource;
if (!(pResource = m_ResourceServices[i]->loadResource(fileName))) {
if (!(pResource = _resourceServices[i]->loadResource(fileName))) {
BS_LOG_ERRORLN("Responsible service could not load resource \"%s\".", fileName.c_str());
return NULL;
}
// Add the resource to the front of the list
m_Resources.push_front(pResource);
pResource->_iterator = m_Resources.begin();
_resources.push_front(pResource);
pResource->_iterator = _resources.begin();
// Also store the resource in the hash table for quick lookup
m_ResourceHashTable[pResource->GetFileNameHash() % HASH_TABLE_BUCKETS].push_front(pResource);
_resourceHashTable[pResource->getFileNameHash() % HASH_TABLE_BUCKETS].push_front(pResource);
return pResource;
}
@ -254,56 +257,55 @@ Resource *ResourceManager::loadResource(const Common::String &fileName) {
* Returns the full path of a given resource filename.
* It will return an empty string if a path could not be created.
*/
Common::String ResourceManager::GetUniqueFileName(const Common::String &FileName) const {
Common::String ResourceManager::getUniqueFileName(const Common::String &fileName) const {
// Get a pointer to the package manager
PackageManager *pPackage = (PackageManager *)m_KernelPtr->GetPackage();
PackageManager *pPackage = (PackageManager *)_kernelPtr->getPackage();
if (!pPackage) {
BS_LOG_ERRORLN("Could not get package manager.");
return Common::String("");
}
// Absoluten Pfad der Datei bekommen und somit die Eindeutigkeit des Dateinamens sicherstellen
Common::String UniqueFileName = pPackage->getAbsolutePath(FileName);
if (UniqueFileName == "")
BS_LOG_ERRORLN("Could not create absolute file name for \"%s\".", FileName.c_str());
Common::String uniquefileName = pPackage->getAbsolutePath(fileName);
if (uniquefileName == "")
BS_LOG_ERRORLN("Could not create absolute file name for \"%s\".", fileName.c_str());
return UniqueFileName;
return uniquefileName;
}
/**
* Deletes a resource, removes it from the lists, and updates m_UsedMemory
*/
Common::List<Resource *>::iterator ResourceManager::DeleteResource(Resource *pResource) {
Common::List<Resource *>::iterator ResourceManager::deleteResource(Resource *pResource) {
// Remove the resource from the hash table
m_ResourceHashTable[pResource->GetFileNameHash() % HASH_TABLE_BUCKETS].remove(pResource);
_resourceHashTable[pResource->getFileNameHash() % HASH_TABLE_BUCKETS].remove(pResource);
Resource *pDummy = pResource;
// Delete the resource from the resource list
Common::List<Resource *>::iterator Result = m_Resources.erase(pResource->_iterator);
Common::List<Resource *>::iterator result = _resources.erase(pResource->_iterator);
// Delete the resource
delete(pDummy);
// Return the iterator
return Result;
return result;
}
/**
* Returns a pointer to a loaded resource. If any error occurs, NULL will be returned.
* @param UniqueFileName The absolute path and filename
* @param UniquefileName The absolute path and filename
* Gibt einen Pointer auf die angeforderte Resource zurück, oder NULL, wenn die Resourcen nicht geladen ist.
*/
Resource *ResourceManager::GetResource(const Common::String &UniqueFileName) const {
Resource *ResourceManager::getResource(const Common::String &uniquefileName) const {
// Determine whether the resource is already loaded
const Common::List<Resource *>& HashBucket = m_ResourceHashTable[
BS_String::GetHash(UniqueFileName) % HASH_TABLE_BUCKETS];
const Common::List<Resource *>& hashBucket = _resourceHashTable[BS_String::getHash(uniquefileName) % HASH_TABLE_BUCKETS];
{
Common::List<Resource *>::const_iterator Iter = HashBucket.begin();
for (; Iter != HashBucket.end(); ++Iter) {
Common::List<Resource *>::const_iterator iter = hashBucket.begin();
for (; iter != hashBucket.end(); ++iter) {
// Wenn die Resource gefunden wurde wird sie zurückgegeben.
if ((*Iter)->getFileName() == UniqueFileName)
return *Iter;
if ((*iter)->getFileName() == uniquefileName)
return *iter;
}
}
@ -314,10 +316,10 @@ Resource *ResourceManager::GetResource(const Common::String &UniqueFileName) con
/**
* Writes the names of all currently locked resources to the log file
*/
void ResourceManager::DumpLockedResources() {
for (Common::List<Resource *>::iterator Iter = m_Resources.begin(); Iter != m_Resources.end(); ++Iter) {
if ((*Iter)->GetLockCount() > 0) {
BS_LOGLN("%s", (*Iter)->getFileName().c_str());
void ResourceManager::dumpLockedResources() {
for (Common::List<Resource *>::iterator iter = _resources.begin(); iter != _resources.end(); ++iter) {
if ((*iter)->getLockCount() > 0) {
BS_LOGLN("%s", (*iter)->getFileName().c_str());
}
}
}
@ -328,9 +330,9 @@ void ResourceManager::DumpLockedResources() {
* as a guideline, and not as a fixed boundary. It is not guaranteed not to be exceeded;
* the whole game engine may still use more memory than any amount specified.
*/
void ResourceManager::SetMaxMemoryUsage(uint MaxMemoryUsage) {
m_MaxMemoryUsage = MaxMemoryUsage;
DeleteResourcesIfNecessary();
void ResourceManager::setMaxMemoryUsage(uint maxMemoryUsage) {
_maxMemoryUsage = maxMemoryUsage;
deleteResourcesIfNecessary();
}
} // End of namespace Sword25

60
engines/sword25/kernel/resmanager.h
View file

@ -35,14 +35,12 @@
#ifndef SWORD25_RESOURCEMANAGER_H
#define SWORD25_RESOURCEMANAGER_H
// Includes
#include "common/list.h"
#include "sword25/kernel/common.h"
namespace Sword25 {
// Class definitions
class ResourceService;
class Resource;
class Kernel;
@ -55,7 +53,7 @@ public:
* Returns a requested resource. If any error occurs, returns NULL
* @param FileName Filename of resource
*/
Resource *RequestResource(const Common::String &FileName);
Resource *requestResource(const Common::String &fileName);
/**
* Loads a resource into the cache
@ -63,13 +61,13 @@ public:
* @param ForceReload Indicates whether the file should be reloaded if it's already in the cache.
* This is useful for files that may have changed in the interim
*/
bool PrecacheResource(const Common::String &FileName, bool ForceReload = false);
bool precacheResource(const Common::String &fileName, bool forceReload = false);
/**
* Returns the number of loaded resources
*/
int GetResourceCount() const {
return static_cast<int>(m_Resources.size());
int getResourceCount() const {
return static_cast<int>(_resources.size());
}
/**
@ -77,25 +75,25 @@ public:
* Note: This method is not optimised for speed and should be used only for debugging purposes
* @param Ord Ordinal number of the resource. Must be between 0 and GetResourceCount() - 1.
*/
Resource *GetResourceByOrdinal(int Ord) const;
Resource *getResourceByOrdinal(int ord) const;
/**
* Registers a RegisterResourceService. This method is the constructor of
* BS_ResourceService, and thus helps all resource services in the ResourceManager list
* @param pService Which service
*/
bool RegisterResourceService(ResourceService *pService);
bool registerResourceService(ResourceService *pService);
/**
* Releases all resources that are not locked.
**/
void EmptyCache();
void emptyCache();
/**
* Returns the maximum memory the kernel has used
*/
int GetMaxMemoryUsage() const {
return m_MaxMemoryUsage;
int getMaxMemoryUsage() const {
return _maxMemoryUsage;
}
/**
@ -104,28 +102,28 @@ public:
* as a guideline, and not as a fixed boundary. It is not guaranteed not to be exceeded;
* the whole game engine may still use more memory than any amount specified.
*/
void SetMaxMemoryUsage(uint MaxMemoryUsage);
void setMaxMemoryUsage(uint maxMemoryUsage);
/**
* Specifies whether a warning is written to the log when a cache miss occurs.
* THe default value is "false".
*/
bool IsLogCacheMiss() const {
return m_LogCacheMiss;
bool isLogCacheMiss() const {
return _logCacheMiss;
}
/**
* Sets whether warnings are written to the log if a cache miss occurs.
* @param Flag If "true", then future warnings will be logged
*/
void SetLogCacheMiss(bool Flag) {
m_LogCacheMiss = Flag;
void setLogCacheMiss(bool flag) {
_logCacheMiss = flag;
}
/**
* Writes the names of all currently locked resources to the log file
*/
void DumpLockedResources();
void dumpLockedResources();
private:
/**
@ -133,9 +131,9 @@ private:
* Only the BS_Kernel class can generate copies this class. Thus, the constructor is private
*/
ResourceManager(Kernel *pKernel) :
m_KernelPtr(pKernel),
m_MaxMemoryUsage(100000000),
m_LogCacheMiss(false)
_kernelPtr(pKernel),
_maxMemoryUsage(100000000),
_logCacheMiss(false)
{}
virtual ~ResourceManager();
@ -147,7 +145,7 @@ private:
* Moves a resource to the top of the resource list
* @param pResource The resource
*/
void MoveToFront(Resource *pResource);
void moveToFront(Resource *pResource);
/**
* Loads a resource and updates the m_UsedMemory total
@ -161,31 +159,31 @@ private:
* Returns the full path of a given resource filename.
* It will return an empty string if a path could not be created.
*/
Common::String GetUniqueFileName(const Common::String &FileName) const;
Common::String getUniqueFileName(const Common::String &fileName) const;
/**
* Deletes a resource, removes it from the lists, and updates m_UsedMemory
*/
Common::List<Resource *>::iterator DeleteResource(Resource *pResource);
Common::List<Resource *>::iterator deleteResource(Resource *pResource);
/**
* Returns a pointer to a loaded resource. If any error occurs, NULL will be returned.
* @param UniqueFileName The absolute path and filename
* Gibt einen Pointer auf die angeforderte Resource zurück, oder NULL, wenn die Resourcen nicht geladen ist.
*/
Resource *GetResource(const Common::String &UniqueFileName) const;
Resource *getResource(const Common::String &uniqueFileName) const;
/**
* Deletes resources as necessary until the specified memory limit is not being exceeded.
*/
void DeleteResourcesIfNecessary();
void deleteResourcesIfNecessary();
Kernel *m_KernelPtr;
uint m_MaxMemoryUsage;
Common::Array<ResourceService *> m_ResourceServices;
Common::List<Resource *> m_Resources;
Common::List<Resource *> m_ResourceHashTable[HASH_TABLE_BUCKETS];
bool m_LogCacheMiss;
Kernel *_kernelPtr;
uint _maxMemoryUsage;
Common::Array<ResourceService *> _resourceServices;
Common::List<Resource *> _resources;
Common::List<Resource *> _resourceHashTable[HASH_TABLE_BUCKETS];
bool _logCacheMiss;
};
} // End of namespace Sword25

4
engines/sword25/kernel/resource.cpp
View file

@ -44,11 +44,11 @@ namespace Sword25 {
Resource::Resource(const Common::String &fileName, RESOURCE_TYPES type) :
_type(type),
_refCount(0) {
PackageManager *pPM = Kernel::GetInstance()->GetPackage();
PackageManager *pPM = Kernel::getInstance()->getPackage();
BS_ASSERT(pPM);
_fileName = pPM->getAbsolutePath(fileName);
_fileNameHash = BS_String::GetHash(fileName);
_fileNameHash = BS_String::getHash(fileName);
}
void Resource::release() {

16
engines/sword25/kernel/resource.h
View file

@ -62,7 +62,7 @@ public:
* Prevents the resource from being released.
* @remarks This method allows a resource to be locked multiple times.
**/
void AddReference() {
void addReference() {
++_refCount;
}
@ -77,7 +77,7 @@ public:
* Returns the current lock count for the resource
* @return The current lock count
**/
int GetLockCount() const {
int getLockCount() const {
return _refCount;
}
@ -91,14 +91,14 @@ public:
/**
* Returns the hash of the filename of a resource
*/
uint GetFileNameHash() const {
uint getFileNameHash() const {
return _fileNameHash;
}
/**
* Returns a resource's type
*/
uint GetType() const {
uint getType() const {
return _type;
}
@ -106,10 +106,10 @@ protected:
virtual ~Resource() {}
private:
Common::String _fileName; ///< The absolute filename
uint _fileNameHash; ///< The hash value of the filename
uint _refCount; ///< The number of locks
uint _type; ///< The type of the resource
Common::String _fileName; ///< The absolute filename
uint _fileNameHash; ///< The hash value of the filename
uint _refCount; ///< The number of locks
uint _type; ///< The type of the resource
Common::List<Resource *>::iterator _iterator; ///< Points to the resource position in the LRU list
};

5
engines/sword25/kernel/resservice.h
View file

@ -35,7 +35,6 @@
#ifndef SWORD25_RESOURCESERVICE_H
#define SWORD25_RESOURCESERVICE_H
// Includes
#include "sword25/kernel/common.h"
#include "sword25/kernel/service.h"
#include "sword25/kernel/kernel.h"
@ -48,8 +47,8 @@ class Resource;
class ResourceService : public Service {
public:
ResourceService(Kernel *pKernel) : Service(pKernel) {
ResourceManager *pResource = pKernel->GetResourceManager();
pResource->RegisterResourceService(this);
ResourceManager *pResource = pKernel->getResourceManager();
pResource->registerResourceService(this);
}
virtual ~ResourceService() {}

64
engines/sword25/kernel/scummvmwindow.cpp
View file

@ -43,31 +43,31 @@
namespace Sword25 {
bool ScummVMWindow::_ClassRegistered = false;
bool ScummVMWindow::_classRegistered = false;
// Constructor / Destructor
// ------------------------
ScummVMWindow::ScummVMWindow(int X, int Y, int Width, int Height, bool Visible) {
ScummVMWindow::ScummVMWindow(int x, int y, int width, int height, bool visible) {
// Presume that init will fail
_InitSuccess = false;
_initSuccess = false;
// We don't support any window creation except at the origin 0,0
assert(X == 0);
assert(Y == 0);
assert(x == 0);
assert(y == 0);
if (!_ClassRegistered) {
if (!_classRegistered) {
// Nothing here currently
_ClassRegistered = true;
_classRegistered = true;
}
// Fenstersichtbarkeit setzen
SetVisible(Visible);
setVisible(visible);
// Indicate success
_InitSuccess = true;
_WindowAlive = true;
_CloseWanted = false;
_initSuccess = true;
_windowAlive = true;
_closeWanted = false;
}
ScummVMWindow::~ScummVMWindow() {
@ -75,86 +75,86 @@ ScummVMWindow::~ScummVMWindow() {
// Get Methods
// ------------
int ScummVMWindow::GetX() {
int ScummVMWindow::getX() {
return 0;
}
int ScummVMWindow::GetY() {
int ScummVMWindow::getY() {
return 0;
}
int ScummVMWindow::GetClientX() {
int ScummVMWindow::getClientX() {
return 0;
}
int ScummVMWindow::GetClientY() {
int ScummVMWindow::getClientY() {
return 0;
}
int ScummVMWindow::GetWidth() {
int ScummVMWindow::getWidth() {
return g_system->getWidth();
}
int ScummVMWindow::GetHeight() {
int ScummVMWindow::getHeight() {
return g_system->getHeight();
}
Common::String ScummVMWindow::GetTitle() {
Common::String ScummVMWindow::getTitle() {
return Common::String("");
}
bool ScummVMWindow::IsVisible() {
bool ScummVMWindow::isVisible() {
return true;
}
bool ScummVMWindow::HasFocus() {
bool ScummVMWindow::hasFocus() {
// FIXME: Is there a way to tell if ScummVM has the focus in Windowed mode?
return true;
}
uint ScummVMWindow::GetWindowHandle() {
uint ScummVMWindow::getWindowHandle() {
return 0;
}
void ScummVMWindow::SetWindowAlive(bool v) {
_WindowAlive = v;
void ScummVMWindow::setWindowAlive(bool v) {
_windowAlive = v;
}
// Set Methods
// ------------
void ScummVMWindow::SetX(int X) {
void ScummVMWindow::setX(int X) {
// No implementation
}
void ScummVMWindow::SetY(int Y) {
void ScummVMWindow::setY(int Y) {
// No implementation
}
void ScummVMWindow::SetWidth(int Width) {
void ScummVMWindow::setWidth(int width) {
// No implementation
}
void ScummVMWindow::SetHeight(int Height) {
void ScummVMWindow::setHeight(int height) {
// No implementation
}
void ScummVMWindow::SetVisible(bool Visible) {
void ScummVMWindow::setVisible(bool visible) {
// No implementation
}
void ScummVMWindow::SetTitle(const Common::String &Title) {
void ScummVMWindow::setTitle(const Common::String &title) {
// No implementation
}
bool ScummVMWindow::ProcessMessages() {
bool ScummVMWindow::processMessages() {
// All messages are handled separately in the input manager. The only thing we
// need to do here is to keep returning whether the window/game is still alive
return _WindowAlive;
return _windowAlive;
}
bool ScummVMWindow::WaitForFocus() {
bool ScummVMWindow::waitForFocus() {
// No implementation
return true;
}

50
engines/sword25/kernel/scummvmwindow.h
View file

@ -41,43 +41,41 @@
#ifndef SWORD25_SCUMMVMWINDOW_H
#define SWORD25_SCUMMVMWINDOW_H
// Includes
#include "sword25/kernel/common.h"
#include "sword25/kernel/window.h"
namespace Sword25 {
// Class definition
class ScummVMWindow : public Window {
public:
ScummVMWindow(int X, int Y, int Width, int Height, bool Visible);
ScummVMWindow(int x, int y, int width, int height, bool visible);
virtual ~ScummVMWindow();
bool IsVisible();
void SetVisible(bool Visible);
int GetX();
void SetX(int X);
int GetY();
void SetY(int X);
int GetClientX();
int GetClientY();
int GetWidth();
void SetWidth(int Width);
int GetHeight();
void SetHeight(int Height);
Common::String GetTitle();
void SetWindowAlive(bool v);
void SetTitle(const Common::String &Title);
bool HasFocus();
uint GetWindowHandle();
bool WaitForFocus();
bool ProcessMessages();
bool isVisible();
void setVisible(bool visible);
int getX();
void setX(int x);
int getY();
void setY(int x);
int getClientX();
int getClientY();
int getWidth();
void setWidth(int width);
int getHeight();
void setHeight(int height);
Common::String getTitle();
void setWindowAlive(bool v);
void setTitle(const Common::String &title);
bool hasFocus();
uint getWindowHandle();
bool waitForFocus();
bool processMessages();
private:
static bool _ClassRegistered;
bool _WindowAlive;
int _ClientXDelta;
int _ClientYDelta;
static bool _classRegistered;
bool _windowAlive;
int _clientXDelta;
int _clientYDelta;
};
} // End of namespace Sword25

1
engines/sword25/kernel/service_ids.h
View file

@ -81,7 +81,6 @@ const BS_ServiceInfo BS_SERVICE_TABLE[] = {
{ "fmv", "oggtheora", OggTheora_CreateObject }
};
} // End of namespace Sword25
#endif

74
engines/sword25/kernel/string.h
View file

@ -39,71 +39,75 @@
namespace BS_String {
inline uint GetHash(const Common::String &Str) {
uint Result = 0;
inline uint getHash(const Common::String &str) {
uint result = 0;
for (uint i = 0; i < Str.size(); i++)
Result = ((Result << 5) - Result) + Str[i];
for (uint i = 0; i < str.size(); i++)
result = ((result << 5) - result) + str[i];
return Result;
return result;
}
inline bool ToInt(const Common::String &Str, int &Result) {
Common::String::const_iterator Iter = Str.begin();
inline bool toInt(const Common::String &str, int &result) {
Common::String::const_iterator iter = str.begin();
// Skip whitespaces
while (*Iter && (*Iter == ' ' || *Iter == '\t')) {
++Iter;
while (*iter && (*iter == ' ' || *iter == '\t')) {
++iter;
}
if (Iter == Str.end()) return false;
if (iter == str.end())
return false;
// Read sign, if available
bool IsNegative = false;
if (*Iter == '-') {
IsNegative = true;
++Iter;
} else if (*Iter == '+')
++Iter;
bool isNegative = false;
if (*iter == '-') {
isNegative = true;
++iter;
} else if (*iter == '+')
++iter;
// Skip whitespaces
while (*Iter && (*Iter == ' ' || *Iter == '\t')) {
++Iter;
while (*iter && (*iter == ' ' || *iter == '\t')) {
++iter;
}
if (Iter == Str.end()) return false;
if (iter == str.end())
return false;
// Convert string to integer
Result = 0;
while (Iter != Str.end()) {
if (*Iter < '0' || *Iter > '9') {
while (*Iter && (*Iter == ' ' || *Iter == '\t')) {
++Iter;
result = 0;
while (iter != str.end()) {
if (*iter < '0' || *iter > '9') {
while (*iter && (*iter == ' ' || *iter == '\t')) {
++iter;
}
if (Iter != Str.end()) return false;
if (iter != str.end())
return false;
break;
}
Result = (Result * 10) + (*Iter - '0');
++Iter;
result = (result * 10) + (*iter - '0');
++iter;
}
if (IsNegative) Result = -Result;
if (isNegative)
result = -result;
return true;
}
inline bool ToBool(const Common::String &Str, bool &Result) {
if (Str == "true" || Str == "TRUE") {
Result = true;
inline bool toBool(const Common::String &str, bool &result) {
if (str == "true" || str == "TRUE") {
result = true;
return true;
} else if (Str == "false" || Str == "FALSE") {
Result = false;
} else if (str == "false" || str == "FALSE") {
result = false;
return true;
}
return false;
}
inline void ToLower(Common::String &Str) {
Str.toLowercase();
inline void toLower(Common::String &str) {
str.toLowercase();
}
} // End of namespace BS_String

16
engines/sword25/kernel/window.cpp
View file

@ -40,13 +40,13 @@
namespace Sword25 {
// Erstellt ein Fenster des GUI des aktuellen Betriebssystems
Window *Window::CreateBSWindow(int X, int Y, int Width, int Height, bool Visible) {
Window *Window::createBSWindow(int x, int y, int width, int height, bool visible) {
// Fenster erstellen
Window *pWindow = (Window *) new ScummVMWindow(X, Y, Width, Height, Visible);
Window *pWindow = (Window *) new ScummVMWindow(x, y, width, height, visible);
// Falls das Fenster erfolgreich initialisiert wurde, wird ein Pointer auf das Fensterobjekt
// zurückgegeben
if (pWindow->_InitSuccess)
if (pWindow->_initSuccess)
return pWindow;
// Ansonsten wird das Fensterobjekt zerstört und NULL zurückgegeben
@ -56,14 +56,14 @@ Window *Window::CreateBSWindow(int X, int Y, int Width, int Height, bool Visible
// Gibt True zurück wenn das Fenster WM_CLOSE empfangen hat -
// solange, bis RejectClose() aufgerufen wurde.
bool Window::CloseWanted() {
bool result = _CloseWanted;
_CloseWanted = false;
bool Window::closeWanted() {
bool result = _closeWanted;
_closeWanted = false;
return result;
}
void Window::SetCloseWanted(bool Wanted) {
_CloseWanted = Wanted;
void Window::setCloseWanted(bool wanted) {
_closeWanted = wanted;
}
} // End of namespace Sword25

51
engines/sword25/kernel/window.h
View file

@ -44,13 +44,10 @@
#ifndef SWORD25_WINDOW_H
#define SWORD25_WINDOW_H
// Includes
#include "sword25/kernel/common.h"
namespace Sword25 {
// Class definitions
/**
* A simple window class interface
*
@ -59,8 +56,8 @@ namespace Sword25 {
*/
class Window {
protected:
bool _InitSuccess;
bool _CloseWanted;
bool _initSuccess;
bool _closeWanted;
public:
virtual ~Window() {}
@ -68,97 +65,97 @@ public:
/**
* Returns the visibility of the window.
*/
virtual bool IsVisible() = 0;
virtual bool isVisible() = 0;
/**
* Sets the visibility of the window
* @param Visible Specifies whether the window should be visible or hidden
*/
virtual void SetVisible(bool Visible) = 0;
virtual void setVisible(bool visible) = 0;
/**
* Returns the X position of the window
*/
virtual int GetX() = 0;
virtual int getX() = 0;
/**
* Sets the X position of the window
* @paramX The new X position for the window, or -1 for centre aligned
*/
virtual void SetX(int X) = 0;
virtual void setX(int X) = 0;
/**
* Gets the Y position of the window
*/
virtual int GetY() = 0;
virtual int getY() = 0;
/**
* Sets the Y position of the window
* @param Y The new Y position for the window, or -1 for centre aligned
*/
virtual void SetY(int X) = 0;
virtual void setY(int X) = 0;
/**
* Returns the X position of the window's client area
*/
virtual int GetClientX() = 0;
virtual int getClientX() = 0;
/**
* Returns the Y position of the window's client area
*/
virtual int GetClientY() = 0;
virtual int getClientY() = 0;
/**
* Returns the width of the window without the frame
*/
virtual int GetWidth() = 0;
virtual int getWidth() = 0;
/**
* Sets the width of the window without the frame
*/
virtual void SetWidth(int Width) = 0;
virtual void setWidth(int width) = 0;
/**
* Gets the height of the window without the frame
*/
virtual int GetHeight() = 0;
virtual int getHeight() = 0;
/**
* Sets the height of the window without the frame
*/
virtual void SetHeight(int Height) = 0;
virtual void setHeight(int height) = 0;
/**
* Returns the title of the window
*/
virtual Common::String GetTitle() = 0;
virtual Common::String getTitle() = 0;
/**
* Sets the title of the window
* @param Title The new window title
*/
virtual void SetTitle(const Common::String &Title) = 0;
virtual void setTitle(const Common::String &title) = 0;
/**
* Handle the processing of any pending window messages. This method should be called
* during the main loop.
*/
virtual bool ProcessMessages() = 0;
virtual bool processMessages() = 0;
/**
* Pauses the applicaiton until the window has focus, or has been closed.
* Returns false if the window was closed.
*/
virtual bool WaitForFocus() = 0;
virtual bool waitForFocus() = 0;
/**
* Returns true if the window has focus, false otherwise.
*/
virtual bool HasFocus() = 0;
virtual bool hasFocus() = 0;
/**
* Returns the system handle that represents the window. Note that any use of the handle
* will not be portable code.
*/
virtual uint GetWindowHandle() = 0;
virtual uint getWindowHandle() = 0;
virtual void SetWindowAlive(bool v) = 0;
virtual void setWindowAlive(bool v) = 0;
/**
* Specifies whether the window is wanted to be closed. This is used together with CloseWanted()
* to allow scripts to query when the main window should be closed, or the user is asking it to close
**/
void SetCloseWanted(bool Wanted);
void setCloseWanted(bool wanted);
/**
* Returns the previous value set in a call to SetCloseWanted.
* Note that calling this also resets the value back to false, until such time as the SetCloseWanted()
* method is called again.
**/
bool CloseWanted();
bool closeWanted();
/**
* Creates a new window instance. Returns a pointer to the window, or NULL if the creation failed.
@ -169,7 +166,7 @@ public:
* @param Height The height of the window without the frame
* @param Visible Specifies whether window should be visible
*/
static Window *CreateBSWindow(int X, int Y, int Width, int Height, bool Visible);
static Window *createBSWindow(int x, int y, int width, int height, bool visible);
};
} // End of namespace Sword25

6
engines/sword25/math/geometry_script.cpp
View file

@ -360,7 +360,7 @@ static int r_setY(lua_State *L) {
}
static void drawPolygon(const Polygon &polygon, uint color, const Vertex &offset) {
GraphicEngine *pGE = Kernel::GetInstance()->GetGfx();
GraphicEngine *pGE = Kernel::getInstance()->getGfx();
BS_ASSERT(pGE);
for (int i = 0; i < polygon.vertexCount - 1; i++)
@ -470,9 +470,9 @@ static const luaL_reg WALKREGION_METHODS[] = {
};
bool Geometry::registerScriptBindings() {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ScriptEngine *pScript = pKernel->GetScript();
ScriptEngine *pScript = pKernel->getScript();
BS_ASSERT(pScript);
lua_State *L = static_cast< lua_State *>(pScript->getScriptObject());
BS_ASSERT(L);

4
engines/sword25/math/walkregion.cpp
View file

@ -165,7 +165,7 @@ static void relaxEndPoint(const Vertex &curNodePos,
}
template<class T>
void ReverseArray(Common::Array<T> &arr) {
void reverseArray(Common::Array<T> &arr) {
const uint size = arr.size();
if (size < 2)
return;
@ -216,7 +216,7 @@ bool WalkRegion::findPath(const Vertex &start, const Vertex &end, BS_Path &path)
// The nodes of the path must be untwisted, as they were extracted in reverse order.
// This step could be saved if the path from end to the beginning was desired
ReverseArray<Vertex>(path);
reverseArray<Vertex>(path);
return true;
}

2
engines/sword25/package/packagemanager.cpp
View file

@ -154,7 +154,7 @@ byte *PackageManager::getFile(const Common::String &fileName, uint *fileSizePtr)
// Savegame loading logic
Common::SaveFileManager *sfm = g_system->getSavefileManager();
Common::InSaveFile *file = sfm->openForLoading(
FileSystemUtil::GetInstance().GetPathFilename(fileName));
FileSystemUtil::getInstance().getPathFilename(fileName));
if (!file) {
BS_LOG_ERRORLN("Could not load savegame \"%s\".", fileName.c_str());
return 0;

8
engines/sword25/package/packagemanager_script.cpp
View file

@ -42,9 +42,9 @@
namespace Sword25 {
static PackageManager *getPM() {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
PackageManager *pPM = pKernel->GetPackage();
PackageManager *pPM = pKernel->getPackage();
BS_ASSERT(pPM);
return pPM;
}
@ -197,9 +197,9 @@ static const luaL_reg PACKAGE_FUNCTIONS[] = {
};
bool PackageManager::registerScriptBindings() {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ScriptEngine *pScript = pKernel->GetScript();
ScriptEngine *pScript = pKernel->getScript();
BS_ASSERT(pScript);
lua_State *L = static_cast<lua_State *>(pScript->getScriptObject());
BS_ASSERT(L);

2
engines/sword25/script/lua_extensions.cpp
View file

@ -47,7 +47,7 @@ static int warning(lua_State *L) {
lua_pushstring(L, "WARNING - ");
lua_pushvalue(L, 1);
lua_concat(L, 3);
BS_Log::Log("%s\n", luaL_checkstring(L, -1));
BS_Log::log("%s\n", luaL_checkstring(L, -1));
lua_pop(L, 1);
#ifdef DEBUG

2
engines/sword25/script/luascript.cpp
View file

@ -151,7 +151,7 @@ bool LuaScriptEngine::executeFile(const Common::String &fileName) {
debug(2, "LuaScriptEngine::executeFile(%s)", fileName.c_str());
// Get a pointer to the package manager
PackageManager *pPackage = Kernel::GetInstance()->GetPackage();
PackageManager *pPackage = Kernel::getInstance()->getPackage();
BS_ASSERT(pPackage);
// File read

2
engines/sword25/sfx/soundengine.cpp
View file

@ -157,7 +157,7 @@ bool SoundEngine::playSound(const Common::String &fileName, SOUND_TYPES type, fl
}
uint SoundEngine::playSoundEx(const Common::String &fileName, SOUND_TYPES type, float volume, float pan, bool loop, int loopStart, int loopEnd, uint layer) {
Common::SeekableReadStream *in = Kernel::GetInstance()->GetPackage()->getStream(fileName);
Common::SeekableReadStream *in = Kernel::getInstance()->getPackage()->getStream(fileName);
Audio::SeekableAudioStream *stream = Audio::makeVorbisStream(in, DisposeAfterUse::YES);
uint id;
SndHandle *handle = getHandle(&id);

80
engines/sword25/sfx/soundengine_script.cpp
View file

@ -46,9 +46,9 @@
namespace Sword25 {
static int init(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
if (lua_gettop(L) == 0)
@ -62,9 +62,9 @@ static int init(lua_State *L) {
}
static int update(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
pSfx->update();
@ -73,9 +73,9 @@ static int update(lua_State *L) {
}
static int setVolume(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
pSfx->setVolume(static_cast<float>(luaL_checknumber(L, 1)),
@ -85,9 +85,9 @@ static int setVolume(lua_State *L) {
}
static int getVolume(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
lua_pushnumber(L, pSfx->getVolume(static_cast<SoundEngine::SOUND_TYPES>(static_cast<uint>(luaL_checknumber(L, 1)))));
@ -96,9 +96,9 @@ static int getVolume(lua_State *L) {
}
static int pauseAll(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
pSfx->pauseAll();
@ -107,9 +107,9 @@ static int pauseAll(lua_State *L) {
}
static int resumeAll(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
pSfx->resumeAll();
@ -118,9 +118,9 @@ static int resumeAll(lua_State *L) {
}
static int pauseLayer(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
pSfx->pauseLayer(static_cast<int>(luaL_checknumber(L, 1)));
@ -129,9 +129,9 @@ static int pauseLayer(lua_State *L) {
}
static int resumeLayer(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
pSfx->resumeLayer(static_cast<int>(luaL_checknumber(L, 1)));
@ -176,9 +176,9 @@ static void processPlayParams(lua_State *L, Common::String &fileName, SoundEngin
}
static int playSound(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
Common::String fileName;
@ -197,9 +197,9 @@ static int playSound(lua_State *L) {
}
static int playSoundEx(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
Common::String fileName;
@ -218,9 +218,9 @@ static int playSoundEx(lua_State *L) {
}
static int setSoundVolume(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
pSfx->setSoundVolume(static_cast<uint>(luaL_checknumber(L, 1)), static_cast<float>(luaL_checknumber(L, 2)));
@ -229,9 +229,9 @@ static int setSoundVolume(lua_State *L) {
}
static int setSoundPanning(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
pSfx->setSoundPanning(static_cast<uint>(luaL_checknumber(L, 1)), static_cast<float>(luaL_checknumber(L, 2)));
@ -240,9 +240,9 @@ static int setSoundPanning(lua_State *L) {
}
static int pauseSound(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
pSfx->pauseSound(static_cast<uint>(luaL_checknumber(L, 1)));
@ -251,9 +251,9 @@ static int pauseSound(lua_State *L) {
}
static int resumeSound(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
pSfx->resumeSound(static_cast<uint>(luaL_checknumber(L, 1)));
@ -262,9 +262,9 @@ static int resumeSound(lua_State *L) {
}
static int stopSound(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
pSfx->stopSound(static_cast<uint>(luaL_checknumber(L, 1)));
@ -273,9 +273,9 @@ static int stopSound(lua_State *L) {
}
static int isSoundPaused(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
lua_pushbooleancpp(L, pSfx->isSoundPaused(static_cast<uint>(luaL_checknumber(L, 1))));
@ -284,9 +284,9 @@ static int isSoundPaused(lua_State *L) {
}
static int isSoundPlaying(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
lua_pushbooleancpp(L, pSfx->isSoundPlaying(static_cast<uint>(luaL_checknumber(L, 1))));
@ -295,9 +295,9 @@ static int isSoundPlaying(lua_State *L) {
}
static int getSoundVolume(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
lua_pushnumber(L, pSfx->getSoundVolume(static_cast<uint>(luaL_checknumber(L, 1))));
@ -306,9 +306,9 @@ static int getSoundVolume(lua_State *L) {
}
static int getSoundPanning(lua_State *L) {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
SoundEngine *pSfx = pKernel->GetSfx();
SoundEngine *pSfx = pKernel->getSfx();
BS_ASSERT(pSfx);
lua_pushnumber(L, pSfx->getSoundPanning(static_cast<uint>(luaL_checknumber(L, 1))));
@ -349,9 +349,9 @@ static const lua_constant_reg SFX_CONSTANTS[] = {
};
bool SoundEngine::registerScriptBindings() {
Kernel *pKernel = Kernel::GetInstance();
Kernel *pKernel = Kernel::getInstance();
BS_ASSERT(pKernel);
ScriptEngine *pScript = pKernel->GetScript();
ScriptEngine *pScript = pKernel->getScript();
BS_ASSERT(pScript);
lua_State *L = static_cast<lua_State *>(pScript->getScriptObject());
BS_ASSERT(L);

14
engines/sword25/sword25.cpp
View file

@ -90,13 +90,13 @@ Common::Error Sword25Engine::appStart() {
return Common::kUnsupportedColorMode;
// Kernel initialization
if (!Kernel::GetInstance()->GetInitSuccess()) {
if (!Kernel::getInstance()->getInitSuccess()) {
BS_LOG_ERRORLN("Kernel initialization failed.");
return Common::kUnknownError;
}
// Package-Manager starten, damit die Packfiles geladen werden können.
PackageManager *packageManagerPtr = static_cast<PackageManager *>(Kernel::GetInstance()->NewService("package", PACKAGE_MANAGER));
PackageManager *packageManagerPtr = static_cast<PackageManager *>(Kernel::getInstance()->newService("package", PACKAGE_MANAGER));
if (!packageManagerPtr) {
BS_LOG_ERRORLN("PackageManager initialization failed.");
return Common::kUnknownError;
@ -112,7 +112,7 @@ Common::Error Sword25Engine::appStart() {
}
// Einen Pointer auf den Skript-Engine holen.
ScriptEngine *scriptPtr = Kernel::GetInstance()->GetScript();
ScriptEngine *scriptPtr = Kernel::getInstance()->getScript();
if (!scriptPtr) {
BS_LOG_ERRORLN("Script intialization failed.");
return Common::kUnknownError;
@ -126,7 +126,7 @@ Common::Error Sword25Engine::appStart() {
bool Sword25Engine::appMain() {
// The main script start. This script loads all the other scripts and starts the actual game.
ScriptEngine *scriptPtr = Kernel::GetInstance()->GetScript();
ScriptEngine *scriptPtr = Kernel::getInstance()->getScript();
BS_ASSERT(scriptPtr);
scriptPtr->executeFile(DEFAULT_SCRIPT_FILE);
@ -135,20 +135,20 @@ bool Sword25Engine::appMain() {
bool Sword25Engine::appEnd() {
// The kernel is shutdown, and un-initialises all subsystems
Kernel::DeleteInstance();
Kernel::deleteInstance();
AnimationTemplateRegistry::destroy();
RenderObjectRegistry::destroy();
RegionRegistry::destroy();
// Free the log file if it was used
BS_Log::_CloseLog();
BS_Log::closeLog();
return true;
}
bool Sword25Engine::loadPackages() {
PackageManager *packageManagerPtr = Kernel::GetInstance()->GetPackage();
PackageManager *packageManagerPtr = Kernel::getInstance()->getPackage();
BS_ASSERT(packageManagerPtr);
// Load the main package