SWImage::SWImage(const Common::String &filename, bool &result) :
_imageDataPtr(0),
_width(0),
_height(0) {
result = false;
PackageManager *pPackage = Kernel::getInstance()->getPackage();
assert(pPackage);
// Load file
byte *pFileData;
uint fileSize;
pFileData = pPackage->getFile(filename, &fileSize);
if (!pFileData) {
error("File \"%s\" could not be loaded.", filename.c_str());
return;
}
// Uncompress the image
int pitch;
byte *pUncompressedData;
if (!ImgLoader::decodePNGImage(pFileData, fileSize, pUncompressedData, _width, _height, pitch)) {
error("Could not decode image.");
return;
}
// Cleanup FileData
delete[] pFileData;
_imageDataPtr = (uint *)pUncompressedData;
result = true;
return;
}
static int LoadPackage(lua_State *L) {
const char* str = lua_tostring(L,-1);
PackageManager* p = App::getPackageManager();
p->LoadPackage(str);
lua_pop(L,1);
return 0;
}
FontResource::FontResource(Kernel *pKernel, const Common::String &fileName) :
_pKernel(pKernel),
_valid(false),
Resource(fileName, Resource::TYPE_FONT),
Common::XMLParser() {
// Get a pointer to the package manager
assert(_pKernel);
PackageManager *pPackage = _pKernel->getPackage();
assert(pPackage);
// Load the contents of the file
uint fileSize;
char *xmlData = pPackage->getXmlFile(getFileName(), &fileSize);
if (!xmlData) {
error("Could not read \"%s\".", getFileName().c_str());
return;
}
// Parse the contents
if (!loadBuffer((const byte *)xmlData, fileSize))
return;
_valid = parse();
close();
free(xmlData);
}
bool FontResource::parserCallback_font(ParserNode *node) {
// Get the attributes of the font
Common::String bitmapFilename = node->values["bitmap"];
if (!parseIntegerKey(node->values["lineheight"], 1, &_lineHeight)) {
warning("Illegal or missing lineheight attribute in <font> tag in \"%s\". Assuming default (\"%d\").",
getFileName().c_str(), DEFAULT_LINEHEIGHT);
_lineHeight = DEFAULT_LINEHEIGHT;
}
if (!parseIntegerKey(node->values["gap"], 1, &_gapWidth)) {
warning("Illegal or missing gap attribute in <font> tag in \"%s\". Assuming default (\"%d\").",
getFileName().c_str(), DEFAULT_GAPWIDTH);
_gapWidth = DEFAULT_GAPWIDTH;
}
// Get a reference to the package manager
assert(_pKernel);
PackageManager *pPackage = _pKernel->getPackage();
assert(pPackage);
// Get the full path and filename for the bitmap resource
_bitmapFileName = pPackage->getAbsolutePath(bitmapFilename);
if (_bitmapFileName == "") {
error("Image file \"%s\" was specified in <font> tag of \"%s\" but could not be found.",
_bitmapFileName.c_str(), getFileName().c_str());
}
// Pre-cache the resource
if (!_pKernel->getResourceManager()->precacheResource(_bitmapFileName)) {
error("Could not precache \"%s\".", _bitmapFileName.c_str());
}
return true;
}
static int AddSearchPath(lua_State *L) {
const char* str = lua_tostring(L,-1);
PackageManager* p = App::getPackageManager();
p->addSearchPath(str);
lua_pop(L,1);
return 0;
}
PackageManager* Project::createPackage()
{
PackageManager* pkgMgr = new PackageManager();
pkgMgr->metadata()->setName("Untitled Package");
mPackageManagers.push_back(pkgMgr);
return pkgMgr;
}
int
main(void)
{
PackageManager app;
app.Run();
return 0;
}
Resource::Resource(const Common::String &fileName, RESOURCE_TYPES type) :
_type(type),
_refCount(0) {
PackageManager *pPM = Kernel::getInstance()->getPackage();
assert(pPM);
_fileName = pPM->getAbsolutePath(fileName);
}
RenderedImage::RenderedImage(const Common::String &filename, bool &result) :
_data(0),
_width(0),
_height(0),
_isTransparent(true) {
result = false;
PackageManager *pPackage = Kernel::getInstance()->getPackage();
assert(pPackage);
_backSurface = Kernel::getInstance()->getGfx()->getSurface();
// Load file
byte *pFileData;
uint fileSize;
bool isPNG = true;
if (filename.hasPrefix("/saves")) {
pFileData = readSavegameThumbnail(filename, fileSize, isPNG);
} else {
pFileData = pPackage->getFile(filename, &fileSize);
}
if (!pFileData) {
error("File \"%s\" could not be loaded.", filename.c_str());
return;
}
// Uncompress the image
int pitch;
if (isPNG)
result = ImgLoader::decodePNGImage(pFileData, fileSize, _data, _width, _height, pitch);
else
result = ImgLoader::decodeThumbnailImage(pFileData, fileSize, _data, _width, _height, pitch);
if (!result) {
error("Could not decode image.");
delete[] pFileData;
return;
}
// Cleanup FileData
delete[] pFileData;
_doCleanup = true;
#if defined(SCUMM_LITTLE_ENDIAN)
// Makes sense for LE only at the moment
checkForTransparency();
#endif
return;
}
int main(int ac, char **av) {
PackageManager pkgMan;
JsonParser parser;
std::string cmd, topic, type;
int cpt;
int size = parser.getSize();;
while (parser.parseNextPackage(cmd, topic, type, cpt)) {
std::cout << "launch package:" << cmd << " " << topic << " " << type <<std::endl;
pkgMan.launchPackage(cmd, topic, type);
std::cout << "Package " << cpt << "/" << size << " launched..." << std::endl;
sleep(2);
}
std::cout << std::endl << "<<< MscProject launched >>>" << std::endl << std::endl;
return 0;
}
//throw on error
static ResolutionResult checkImport(const PackageManager& pm, const ParseResultPtr& pr, const std::string& pkgName, const CustomTypeExprNode* tnode, const std::string& type)
{
PackagePtr pkg = pm.package(pkgName);
NodePtr node = pkg->getExport(type);
TypeKind kind;
if (node) {
switch (node->type()) {
case NodeType_InterfaceDecl:
kind = TypeKind_Interface;
break;
case NodeType_EnumDecl:
kind = TypeKind_Enum;
break;
case NodeType_StructDecl:
kind = TypeKind_Struct;
break;
default:
pr->addDiag(Diagnostic(DiagnosticType_Error, "'" + type + "' in package '" + pkgName + "' is not a type", tnode->loc()));
throw std::runtime_error("Not a type");
break;
}
return ResolutionResult(pkgName, type, kind);
}
pr->addDiag(Diagnostic(DiagnosticType_Error, "Can't find '" + type + "' in package '" + pkgName + "'", tnode->loc()));
throw std::runtime_error("Can't find import");
}
bool Project::write(ProgressFeedback* feedback)
{
String pathname(mPath);
pathname += PATHSEP;
pathname += mName;
pathname += ".project";
TiXmlDocument doc;
TiXmlDeclaration decl("1.0", "", "");
doc.InsertEndChild(decl);
TiXmlElement project("project");
std::stringstream ss;
ss << mVersion;
std::string str(ss.str());
project.SetAttribute("version", str.c_str());
ss.str("");
ss << mPackageManagers.size();
str.assign(ss.str());
project.SetAttribute("package_count", str.c_str());
String packagePath(mPath);
packagePath += "/packages/";
for (PackageManagers::iterator it = mPackageManagers.begin(); it != mPackageManagers.end(); ++it) {
PackageManager* pkgMgr = *it;
TiXmlElement package("package");
String name(pkgMgr->metadata()->getName());
package.SetAttribute("name", name);
name = pkgMgr->packageFilename();
package.SetAttribute("filename", name);
project.InsertEndChild(package);
// write out the actual package file
pkgMgr->save(packagePath);
}
doc.InsertEndChild(project);
doc.SaveFile(pathname);
return true;
}
void
PackageManager::add(const PackageManager & theOther) {
AC_TRACE << "add from package '" << theOther.getSearchPath() << "'";
PackageList::const_iterator it = theOther._myPackages.begin();
for (; it != theOther._myPackages.end(); ++it) {
add(*it);
}
}
bool Sword25Engine::loadPackages() {
PackageManager *packageManagerPtr = Kernel::getInstance()->getPackage();
assert(packageManagerPtr);
// Load the main package
if (!packageManagerPtr->loadPackage("data.b25c", "/"))
return false;
// Get the contents of the main program directory and sort them alphabetically
Common::FSNode dir(ConfMan.get("path"));
Common::FSList files;
if (!dir.isDirectory() || !dir.getChildren(files, Common::FSNode::kListAll)) {
warning("Game data path does not exist or is not a directory");
return false;
}
Common::sort(files.begin(), files.end());
// Identify all patch packages
// The filename of patch packages must have the form patch??.b25c, with the question marks
// are placeholders for numbers.
// Since the filenames have been sorted, patches are mounted with low numbers first, through
// to ones with high numbers. This is important, because newly mount packages overwrite
// existing files in the virtual file system, if they include files with the same name.
for (Common::FSList::const_iterator it = files.begin(); it != files.end(); ++it) {
if (it->getName().matchString("patch???.b25c", true))
if (!packageManagerPtr->loadPackage(it->getName(), "/"))
return false;
}
// Identify and mount all language packages
// The filename of the packages have the form lang_*.b25c (eg. lang_de.b25c)
for (Common::FSList::const_iterator it = files.begin(); it != files.end(); ++it) {
if (it->getName().matchString("lang_*.b25c", true))
if (!packageManagerPtr->loadPackage(it->getName(), "/"))
return false;
}
return true;
}
SWImage::SWImage(const Common::String &filename, bool &result) :
_imageDataPtr(0),
_width(0),
_height(0) {
result = false;
PackageManager *pPackage = Kernel::getInstance()->getPackage();
assert(pPackage);
// Datei laden
byte *pFileData;
uint fileSize;
pFileData = pPackage->getFile(filename, &fileSize);
if (!pFileData) {
error("File \"%s\" could not be loaded.", filename.c_str());
return;
}
// Bildeigenschaften bestimmen
int pitch;
if (!PNGLoader::imageProperties(pFileData, fileSize, _width, _height)) {
error("Could not read image properties.");
return;
}
// Das Bild dekomprimieren
byte *pUncompressedData;
if (!PNGLoader::decodeImage(pFileData, fileSize, pUncompressedData, _width, _height, pitch)) {
error("Could not decode image.");
return;
}
// Dateidaten freigeben
delete[] pFileData;
_imageDataPtr = (uint *)pUncompressedData;
result = true;
return;
}
bool LuaScriptEngine::executeFile(const Common::String &fileName) {
#ifdef DEBUG
int __startStackDepth = lua_gettop(_state);
#endif
debug(2, "LuaScriptEngine::executeFile(%s)", fileName.c_str());
// Get a pointer to the package manager
PackageManager *pPackage = Kernel::getInstance()->getPackage();
assert(pPackage);
// File read
uint fileSize;
byte *fileData = pPackage->getFile(fileName, &fileSize);
if (!fileData) {
error("Couldn't read \"%s\".", fileName.c_str());
#ifdef DEBUG
assert(__startStackDepth == lua_gettop(_state));
#endif
return false;
}
// Run the file content
if (!executeBuffer(fileData, fileSize, "@" + pPackage->getAbsolutePath(fileName))) {
// Release file buffer
delete[] fileData;
#ifdef DEBUG
assert(__startStackDepth == lua_gettop(_state));
#endif
return false;
}
// Release file buffer
delete[] fileData;
#ifdef DEBUG
assert(__startStackDepth == lua_gettop(_state));
#endif
return true;
}
Common::Error Sword25Engine::appStart() {
// Initialize the graphics mode to ARGB8888
Graphics::PixelFormat format = Graphics::PixelFormat(4, 8, 8, 8, 8, 16, 8, 0, 24);
initGraphics(800, 600, true, &format);
if (format != g_system->getScreenFormat())
return Common::kUnsupportedColorMode;
// Kernel initialization
if (!Kernel::getInstance()->getInitSuccess()) {
error("Kernel initialization failed.");
return Common::kUnknownError;
}
// Load packages
PackageManager *packageManagerPtr = Kernel::getInstance()->getPackage();
if (getGameFlags() & GF_EXTRACTED) {
if (!packageManagerPtr->loadDirectoryAsPackage(ConfMan.get("path"), "/"))
return Common::kUnknownError;
} else {
if (!loadPackages())
return Common::kUnknownError;
}
// Pass the command line to the script engine.
ScriptEngine *scriptPtr = Kernel::getInstance()->getScript();
if (!scriptPtr) {
error("Script intialization failed.");
return Common::kUnknownError;
}
// Set the game target for use in savegames
setGameTarget(_targetName.c_str());
Common::StringArray commandParameters;
scriptPtr->setCommandLine(commandParameters);
return Common::kNoError;
}
AutoPtr<IDrawable> AppSecurityPermissions::MyPermissionGroupInfo::LoadGroupIcon(
/* [in] */ PackageManager pm)
{
if (icon != 0) {
return loadIcon(pm);
} else {
ApplicationInfo appInfo;
try {
appInfo = pm.getApplicationInfo(packageName, 0);
return appInfo.loadIcon(pm);
} catch (NameNotFoundException e) {
}
}
return NULL;
}
static int RemoveAllPath(lua_State *L) {
PackageManager* p = App::getPackageManager();
p->removeAllPath();
return 0;
}
static int SearchPackages(lua_State *L) {
PackageManager* p = App::getPackageManager();
p->Search();
return 0;
}
bool Project::read(ProgressFeedback* feedback)
{
String pathname(mPath);
pathname += PATHSEP;
pathname += mName;
pathname += ".project";
TiXmlDocument doc;
doc.LoadFile(pathname);
updateFeedback(feedback);
if (doc.Error()) {
return false;
}
// otherwise, read project file
TiXmlElement* root = doc.RootElement();
// TODO: check version compatibility
const char* nPackageAttr = root->Attribute("package_count");
int nPkg = -1;
if (nPackageAttr)
nPkg = atoi(nPackageAttr);
TiXmlElement* package = root->FirstChildElement("package");
// for deferred object-reference resolution
DeferredObjectResolves deferred;
ObjectIdToObject lut;
// for metadata thumbnail loading
std::list<Metadata*> metaList;
int p = 0;
while (package) {
const char* name = package->Attribute("name");
const char* filename = package->Attribute("filename");
std::string pkgInfoText("Loading Package: ");
updateFeedback(feedback, pkgInfoText.c_str());
if (name && filename) {
pkgInfoText.append(name);
PackageManager* pkgMgr = new PackageManager();
pkgMgr->metadata()->setName(name);
String path(mPath);
path += "/packages/";
pkgMgr->load(path, deferred, lut);
// add package metadata to list to post-process
pkgMgr->getAllMetadata(metaList);
mPackageManagers.push_back(pkgMgr);
updateFeedback(feedback, int(float(++p)/float(nPkg)*100.f), pkgInfoText.c_str());
}
package = package->NextSiblingElement("package");
}
// then do Phase 2 load (object reference resolution)
for (DeferredObjectResolves::iterator it = deferred.begin(); it != deferred.end(); ++it) {
DeferredResolution& d = *it;
ObjectIdToObject::iterator o = lut.find(d.mUUID);
if (o != lut.end()) {
d.mProp->setData(d.mObject, o->second);
}
}
// Phase 3 -- initialize all objects in the project
for (PackageManagers::iterator it = mPackageManagers.begin(); it != mPackageManagers.end(); ++it) {
(*it)->initializeAllObjects();
}
// load all thumbnails in parallel
tbb::task* dummy = new(tbb::task::allocate_root()) DummyTask;
dummy->set_ref_count(metaList.size() + 1);
for (std::list<Metadata*>::iterator it = metaList.begin(); it != metaList.end(); ++it) {
tbb::task* t = new(dummy->allocate_child()) ThumbnailTask(*it);
dummy->spawn(*t);
}
dummy->wait_for_all();
return true;
}
PackageManager* Project::addPackage(const char* packagePath)
{
// verify that the package's path is our package directory; if not, copy the
// package file to our packages dir first and change the path
String packagesDir(mPath);
packagesDir += "/packages/";
String baseName;
FileSystem::baseName(baseName, packagePath);
String packageDir;
FileSystem::directoryName(packageDir, packagePath);
if (!FileSystem::isSamePath(packagesDir, packageDir)) {
String fileName;
FileSystem::fileName(fileName, packagePath);
String newPackagePath(packagesDir);
newPackagePath.append("/");
newPackagePath.append(fileName);
if (!FileSystem::copyFile(packagePath, newPackagePath)) {
// then what?
return 0;
}
}
PackageManager* pkgMgr = new PackageManager;
pkgMgr->metadata()->setName(baseName);
DeferredObjectResolves deferred;
ObjectIdToObject lut;
if (!pkgMgr->load(packagesDir, deferred, lut)) {
delete pkgMgr;
return 0;
}
mPackageManagers.push_back(pkgMgr);
// then do Phase 2 load (object reference resolution)
for (DeferredObjectResolves::iterator it = deferred.begin(); it != deferred.end(); ++it) {
DeferredResolution& d = *it;
ObjectIdToObject::iterator o = lut.find(d.mUUID);
if (o != lut.end()) {
d.mProp->setData(d.mObject, o->second);
}
}
std::list<Metadata*> metaList;
pkgMgr->getAllMetadata(metaList);
// load all thumbnails in parallel
tbb::task* dummy = new(tbb::task::allocate_root()) DummyTask;
dummy->set_ref_count(metaList.size() + 1);
for (std::list<Metadata*>::iterator it = metaList.begin(); it != metaList.end(); ++it) {
tbb::task* t = new(dummy->allocate_child()) ThumbnailTask(*it);
dummy->spawn(*t);
}
dummy->wait_for_all();
return pkgMgr;
}
