bool MohawkEngine_Riven::checkDatafiles() {
Common::String missingFiles;
const char **datafiles = listExpectedDatafiles();
for (int i = 0; datafiles[i] != nullptr; i++) {
if (!SearchMan.hasFile(datafiles[i])) {
if (strcmp(datafiles[i], "j_Data3.mhk") == 0
|| strcmp(datafiles[i], "b_Data1.mhk") == 0) {
// j_Data3.mhk and b_Data1.mhk come from the 1.02 patch. They are not required to play.
continue;
}
if (!missingFiles.empty()) {
missingFiles += ", ";
}
missingFiles += datafiles[i];
}
}
if (missingFiles.empty()) {
return true;
}
Common::String message = _("You are missing the following required Riven data files:\n") + missingFiles;
warning("%s", message.c_str());
GUIErrorMessage(message);
return false;
}
void Win32TaskbarManager::setOverlayIcon(const Common::String &name, const Common::String &description) {
//warning("[Win32TaskbarManager::setOverlayIcon] Setting overlay icon to: %s (%s)", name.c_str(), description.c_str());
if (_taskbar == NULL)
return;
if (name.empty()) {
_taskbar->SetOverlayIcon(getHwnd(), NULL, L"");
return;
}
// Compute full icon path
Common::String path = getIconPath(name);
if (path.empty())
return;
HICON pIcon = (HICON)::LoadImage(NULL, path.c_str(), IMAGE_ICON, 16, 16, LR_LOADFROMFILE);
if (!pIcon) {
warning("[Win32TaskbarManager::setOverlayIcon] Cannot load icon!");
return;
}
// Sets the overlay icon
LPWSTR desc = ansiToUnicode(description.c_str());
_taskbar->SetOverlayIcon(getHwnd(), pIcon, desc);
DestroyIcon(pIcon);
delete[] desc;
}
Common::String Win32TaskbarManager::getIconPath(Common::String target) {
// We first try to look for a iconspath configuration variable then
// fallback to the extra path
//
// Icons can be either in a subfolder named "icons" or directly in the path
Common::String iconsPath = ConfMan.get("iconspath");
Common::String extraPath = ConfMan.get("extrapath");
#define TRY_ICON_PATH(path) { \
Common::FSNode node((path)); \
if (node.exists()) \
return (path); \
}
if (!iconsPath.empty()) {
TRY_ICON_PATH(iconsPath + "/" + target + ".ico");
TRY_ICON_PATH(iconsPath + "/" + ConfMan.get("gameid") + ".ico");
TRY_ICON_PATH(iconsPath + "/icons/" + target + ".ico");
TRY_ICON_PATH(iconsPath + "/icons/" + ConfMan.get("gameid") + ".ico");
}
if (!extraPath.empty()) {
TRY_ICON_PATH(extraPath + "/" + target + ".ico");
TRY_ICON_PATH(extraPath + "/" + ConfMan.get("gameid") + ".ico");
TRY_ICON_PATH(extraPath + "/icons/" + target + ".ico");
TRY_ICON_PATH(extraPath + "/icons/" + ConfMan.get("gameid") + ".ico");
}
return "";
}
Common::String OSystem_POSIX::getDefaultConfigFileName() {
Common::String configFile;
Common::String prefix;
#ifdef MACOSX
prefix = getenv("HOME");
#elif !defined(SAMSUNGTV)
const char *envVar;
// Our old configuration file path for POSIX systems was ~/.scummvmrc.
// If that file exists, we still use it.
envVar = getenv("HOME");
if (envVar && *envVar) {
configFile = envVar;
configFile += '/';
configFile += ".scummvmrc";
if (configFile.size() < MAXPATHLEN) {
struct stat sb;
if (stat(configFile.c_str(), &sb) == 0) {
return configFile;
}
}
}
// On POSIX systems we follow the XDG Base Directory Specification for
// where to store files. The version we based our code upon can be found
// over here: http://standards.freedesktop.org/basedir-spec/basedir-spec-0.8.html
envVar = getenv("XDG_CONFIG_HOME");
if (!envVar || !*envVar) {
envVar = getenv("HOME");
if (!envVar) {
return 0;
}
if (Posix::assureDirectoryExists(".config", envVar)) {
prefix = envVar;
prefix += "/.config";
}
} else {
prefix = envVar;
}
if (!prefix.empty() && Posix::assureDirectoryExists("scummvm", prefix.c_str())) {
prefix += "/scummvm";
}
#endif
if (!prefix.empty() && (prefix.size() + 1 + _baseConfigName.size()) < MAXPATHLEN) {
configFile = prefix;
configFile += '/';
configFile += _baseConfigName;
} else {
configFile = _baseConfigName;
}
return configFile;
}
bool Win32AudioCDManager::openCD(const Common::String &drive) {
// Just some bounds checking
if (drive.empty() || drive.size() > 3)
return false;
if (!Common::isAlpha(drive[0]) || drive[1] != ':')
return false;
if (drive[2] != 0 && drive[2] != '\\')
return false;
DriveList drives;
if (!tryAddDrive(toupper(drive[0]), drives))
return false;
// Construct the drive path and try to open it
Common::String drivePath = Common::String::format("\\\\.\\%c:", drives[0]);
_driveHandle = CreateFileA(drivePath.c_str(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (_driveHandle == INVALID_HANDLE_VALUE) {
warning("Failed to open drive %c:\\, error %d", drives[0], (int)GetLastError());
return false;
}
if (!loadTOC()) {
close();
return false;
}
return true;
}
void AboutDialog::addLine(const char *str) {
if (*str == 0) {
_lines.push_back("");
} else {
Common::String format(str, 2);
str += 2;
static Common::String asciiStr;
if (format[0] == 'A') {
bool useAscii = false;
#ifdef USE_TRANSLATION
// We could use TransMan.getCurrentCharset() but rather than compare strings
// it is easier to use TransMan.getCharsetMapping() (non null in case of non
// ISO-8859-1 mapping)
useAscii = (TransMan.getCharsetMapping() != NULL);
#endif
if (useAscii)
asciiStr = str;
return;
}
StringArray wrappedLines;
if (!asciiStr.empty()) {
g_gui.getFont().wordWrapText(asciiStr, _w - 2 * _xOff, wrappedLines);
asciiStr.clear();
} else
g_gui.getFont().wordWrapText(str, _w - 2 * _xOff, wrappedLines);
for (StringArray::const_iterator i = wrappedLines.begin(); i != wrappedLines.end(); ++i) {
_lines.push_back(format + *i);
}
}
}
void ScriptManager::parseScrFile(const Common::String &fileName, bool isGlobal) {
Common::File file;
if (!file.open(fileName)) {
warning("Script file not found: %s", fileName.c_str());
return;
}
while(!file.eos()) {
Common::String line = file.readLine();
if (file.err()) {
warning("Error parsing scr file: %s", fileName.c_str());
return;
}
trimCommentsAndWhiteSpace(&line);
if (line.empty())
continue;
if (line.matchString("puzzle:*", true)) {
Puzzle *puzzle = new Puzzle();
sscanf(line.c_str(),"puzzle:%u",&(puzzle->key));
parsePuzzle(puzzle, file);
if (isGlobal) {
_globalPuzzles.push_back(puzzle);
} else {
_activePuzzles.push_back(puzzle);
}
} else if (line.matchString("control:*", true)) {
parseControl(line, file);
}
}
}
void TeenAgentEngine::displayMessage(const Common::String &str, byte color, uint16 position) {
if (str.empty()) {
return;
}
if (color == 0xd1) { //mark's
SceneEvent e(SceneEvent::kPlayAnimation);
e.animation = 0;
e.slot = 0x80;
scene->push(e);
}
{
SceneEvent event(SceneEvent::kMessage);
event.message = str;
event.color = color;
event.slot = 0;
event.dst.x = position % 320;
event.dst.y = position / 320;
scene->push(event);
}
{
SceneEvent e(SceneEvent::kPauseAnimation);
e.animation = 0;
e.slot = 0x80;
scene->push(e);
}
}
bool ThemeEngine::themeConfigParseHeader(Common::String header, Common::String &themeName) {
// Check that header is not corrupted
if ((byte)header[0] > 127) {
warning("Corrupted theme header found");
return false;
}
header.trim();
if (header.empty())
return false;
if (header[0] != '[' || header.lastChar() != ']')
return false;
header.deleteChar(0);
header.deleteLastChar();
Common::StringTokenizer tok(header, ":");
if (tok.nextToken() != SCUMMVM_THEME_VERSION_STR)
return false;
themeName = tok.nextToken();
Common::String author = tok.nextToken();
return tok.empty();
}
int32 NotesHandler::getSize() {
Common::String fileName = _file->build();
if (fileName.empty())
return -1;
Common::InSaveFile *saveFile;
SaveConverter_Notes converter(_vm, _notesSize, fileName);
if (converter.isOldSave(&saveFile)) {
// Old save, get the size olden-style
int32 size = saveFile->size();
delete saveFile;
return size;
}
SaveReader reader(1, 0, fileName);
SaveHeader header;
if (!reader.load())
return -1;
if (!reader.readPartHeader(0, &header))
return -1;
// Return the part's size
return header.getSize();
}
bool ThemeParser::resolutionCheck(const Common::String &resolution) {
if (resolution.empty())
return true;
Common::StringTokenizer globTokenizer(resolution, ", ");
Common::String cur, w, h;
bool definedRes = false;
while (!globTokenizer.empty()) {
bool ignore = false;
cur = globTokenizer.nextToken();
if (cur[0] == '-') {
ignore = true;
cur.deleteChar(0);
} else {
definedRes = true;
}
Common::StringTokenizer resTokenizer(cur, "x");
w = resTokenizer.nextToken();
h = resTokenizer.nextToken();
if ((w == "X" || atoi(w.c_str()) == g_system->getOverlayWidth()) &&
(h == "Y" || atoi(h.c_str()) == g_system->getOverlayHeight()))
return !ignore;
}
return !definedRes;
}
bool LabEngine::saveRestoreGame() {
bool isOK = false;
// The original had one screen for saving/loading. We have two.
// Ask the user which screen to use.
GUI::MessageDialog saveOrLoad(_("Would you like to save or restore a game?"), _("Save"), _("Restore"));
int choice = saveOrLoad.runModal();
if (choice == GUI::kMessageOK) {
// Save
GUI::SaveLoadChooser *dialog = new GUI::SaveLoadChooser(_("Save game:"), _("Save"), true);
int slot = dialog->runModalWithCurrentTarget();
if (slot >= 0) {
Common::String desc = dialog->getResultString();
if (desc.empty()) {
// create our own description for the saved game, the user didn't enter it
desc = dialog->createDefaultSaveDescription(slot);
}
isOK = saveGame(slot, desc);
}
delete dialog;
} else {
// Restore
GUI::SaveLoadChooser *dialog = new GUI::SaveLoadChooser(_("Restore game:"), _("Restore"), false);
int slot = dialog->runModalWithCurrentTarget();
if (slot >= 0) {
isOK = loadGame(slot);
}
delete dialog;
}
return isOK;
}
void MemoryObject::loadFile(const Common::String &filename) {
debugC(5, kDebugLoading, "MemoryObject::loadFile(<%s>)", filename.c_str());
if (filename.empty())
return;
if (!_data) {
NGIArchive *arr = g_fp->_currArchive;
if (g_fp->_currArchive != _libHandle && _libHandle)
g_fp->_currArchive = _libHandle;
Common::SeekableReadStream *s = g_fp->_currArchive->createReadStreamForMember(filename);
if (s) {
assert(s->size() > 0);
_dataSize = s->size();
debugC(5, kDebugLoading, "Loading %s (%d bytes)", filename.c_str(), _dataSize);
_data = (byte *)calloc(_dataSize, 1);
s->read(_data, _dataSize);
delete s;
} else {
// We have no object to read. This is fine
}
g_fp->_currArchive = arr;
}
}
Common::String BuriedEngine::getFilePath(uint32 stringID) {
Common::String path = getString(stringID);
Common::String output;
if (path.empty())
return output;
uint i = 0;
// The non-demo paths have CD info followed by a backslash.
// We ignore this.
// In the demo, we remove the "BITDATA" prefix because the
// binaries are in the same directory.
if (isDemo())
i += 8;
else
i += 2;
for (; i < path.size(); i++) {
if (path[i] == '\\')
output += '/';
else
output += path[i];
}
return output;
}
FilesystemNode::FilesystemNode(const Common::String &p) {
if (p.empty() || p == ".")
_realNode = AbstractFilesystemNode::getCurrentDirectory();
else
_realNode = AbstractFilesystemNode::getNodeForPath(p);
_refCount = new int(1);
}
const ExtraGuiOptions AdvancedMetaEngine::getExtraGuiOptions(const Common::String &target) const {
if (!_extraGuiOptions)
return ExtraGuiOptions();
ExtraGuiOptions options;
// If there isn't any target specified, return all available GUI options.
// Only used when an engine starts in order to set option defaults.
if (target.empty()) {
for (const ADExtraGuiOptionsMap *entry = _extraGuiOptions; entry->guioFlag; ++entry)
options.push_back(entry->option);
return options;
}
// Query the GUI options
const Common::String guiOptionsString = ConfMan.get("guioptions", target);
const Common::String guiOptions = parseGameGUIOptions(guiOptionsString);
// Add all the applying extra GUI options.
for (const ADExtraGuiOptionsMap *entry = _extraGuiOptions; entry->guioFlag; ++entry) {
if (guiOptions.contains(entry->guioFlag))
options.push_back(entry->option);
}
return options;
}
/**
* This dialog class provides a simple message display with support for either one or two buttons.
*/
MessageDialog::MessageDialog(const Common::String &message, const Common::String &btn1Message,
const Common::String &btn2Message) : GfxDialog() {
// Set up the message
addElements(&_msg, &_btn1, NULL);
_msg.set(message, 200, ALIGN_LEFT);
_msg._bounds.moveTo(0, 0);
_defaultButton = &_btn1;
// Set up the first button
_btn1.setText(btn1Message);
_btn1._bounds.moveTo(_msg._bounds.right - _btn1._bounds.width(), _msg._bounds.bottom + 2);
if (!btn2Message.empty()) {
// Set up the second button
add(&_btn2);
_btn2.setText(btn2Message);
_btn2._bounds.moveTo(_msg._bounds.right - _btn2._bounds.width(), _msg._bounds.bottom + 2);
_btn1._bounds.translate(-(_btn2._bounds.width() + 4), 0);
}
// Do post setup for the dialog
setDefaults();
// Set the dialog's center
setCenter(g_globals->_dialogCenter.x, g_globals->_dialogCenter.y);
}
Common::String TinyTSA::getBriefingMovie() {
Common::String movieName = Neighborhood::getBriefingMovie();
if (movieName.empty()) {
switch (getCurrentActivation()) {
case kActivationTinyTSAJumpToNorad:
g_AIChip->showBriefingClicked();
startExtraSequenceSync(kTinyTSA37PegasusAI7, kHintInterruption);
startExtraSequenceSync(kTinyTSA37AI7ToNorad, kFilterNoInput);
g_AIChip->clearClicked();
movieName = "";
break;
case kActivationTinyTSAJumpToMars:
g_AIChip->showBriefingClicked();
startExtraSequenceSync(kTinyTSA37PegasusAI6, kHintInterruption);
startExtraSequenceSync(kTinyTSA37AI6ToMars, kFilterNoInput);
g_AIChip->clearClicked();
movieName = "";
break;
case kActivationTinyTSAJumpToWSC:
g_AIChip->showBriefingClicked();
startExtraSequenceSync(kTinyTSA37PegasusAI5, kHintInterruption);
startExtraSequenceSync(kTinyTSA37AI5ToWSC, kFilterNoInput);
g_AIChip->clearClicked();
movieName = "";
break;
default:
movieName = "Images/AI/TSA/XT04";
break;
}
}
return movieName;
}
Common::String TinyTSA::getEnvScanMovie() {
Common::String movieName = Neighborhood::getEnvScanMovie();
if (movieName.empty()) {
g_AIChip->showEnvScanClicked();
startExtraSequenceSync(kTinyTSA37EnvironmentalScan, kHintInterruption);
switch (getCurrentActivation()) {
case kActivationTinyTSAJumpToNorad:
startExtraSequenceSync(kTinyTSA37AI7ToNorad, kFilterNoInput);
showExtraView(kTinyTSA37JumpToNoradMenu);
break;
case kActivationTinyTSAJumpToMars:
startExtraSequenceSync(kTinyTSA37AI6ToMars, kFilterNoInput);
showExtraView(kTinyTSA37JumpToMarsMenu);
break;
case kActivationTinyTSAJumpToWSC:
startExtraSequenceSync(kTinyTSA37AI5ToWSC, kFilterNoInput);
showExtraView(kTinyTSA37JumpToWSCMenu);
break;
default:
showMainJumpMenu();
break;
}
g_AIChip->clearClicked();
}
return movieName;
}
bool SaveLoad_v4::GameHandler::createReader(int slot) {
// If slot < 0, just check if a reader exists
if (slot < 0)
return (_reader != 0);
if (!_reader || (_reader->getSlot() != ((uint32) slot))) {
Common::String slotFile = _slotFile->build(slot);
if (slotFile.empty())
return false;
delete _reader;
SaveConverter_v4 converter(_vm, slotFile);
if (converter.isOldSave()) {
// Old save, plug the converter in
if (!converter.load()) {
return false;
}
_reader = new SaveReader(3, slot, converter);
} else
_reader = new SaveReader(3, slot, slotFile);
if (!_reader->load()) {
delete _reader;
_reader = 0;
return false;
}
}
return true;
}
/**
* Add a ready-made domain based on its name and contents
* The domain name should not already exist in the ConfigManager.
**/
void ConfigManager::addDomain(const Common::String &domainName, const ConfigManager::Domain &domain) {
if (domainName.empty())
return;
if (domainName == kApplicationDomain) {
_appDomain = domain;
#ifdef ENABLE_KEYMAPPER
} else if (domainName == kKeymapperDomain) {
_keymapperDomain = domain;
#endif
} else if (domain.contains("gameid")) {
// If the domain contains "gameid" we assume it's a game domain
if (_gameDomains.contains(domainName))
warning("Game domain %s already exists in ConfigManager", domainName.c_str());
_gameDomains[domainName] = domain;
_domainSaveOrder.push_back(domainName);
// Check if we have the same misc domain. For older config files
// we could have 'ghost' domains with the same name, so delete
// the ghost domain
if (_miscDomains.contains(domainName))
_miscDomains.erase(domainName);
} else {
// Otherwise it's a miscellaneous domain
if (_miscDomains.contains(domainName))
warning("Misc domain %s already exists in ConfigManager", domainName.c_str());
_miscDomains[domainName] = domain;
}
}
bool StarTrekEngine::showSaveMenu() {
GUI::SaveLoadChooser *dialog;
Common::String desc;
int slot;
dialog = new GUI::SaveLoadChooser(_("Save game:"), _("Save"), true);
slot = dialog->runModalWithCurrentTarget();
desc = dialog->getResultString();
if (desc.empty()) {
// create our own description for the saved game, the user didnt enter it
desc = dialog->createDefaultSaveDescription(slot);
}
if (desc.size() > 28)
desc = Common::String(desc.c_str(), 28);
delete dialog;
if (slot < 0)
return true;
return saveGame(slot, desc);
}
bool VideoPlayer::reopenVideo(Video &video) {
if (video.isEmpty())
return true;
if (video.fileName.empty()) {
video.close();
return false;
}
Properties properties;
properties.type = video.properties.type;
Common::String fileName = findFile(video.fileName, properties);
if (fileName.empty()) {
video.close();
return false;
}
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(fileName);
if (!stream) {
video.close();
return false;
}
if (!video.decoder->reloadStream(stream)) {
delete stream;
return false;
}
return true;
}
void SoundTownsPC98_v2::playTrack(uint8 track) {
if (track == _lastTrack && _musicEnabled)
return;
int trackNum = -1;
if (_vm->gameFlags().platform == Common::kPlatformFMTowns) {
for (uint i = 0; i < res()->cdaTableSize; i++) {
if (track == (uint8)READ_LE_UINT16(&res()->cdaTable[i * 2])) {
trackNum = (int)READ_LE_UINT16(&res()->cdaTable[i * 2 + 1]) - 1;
break;
}
}
}
beginFadeOut();
Common::String musicFile = res()->pattern ? Common::String::format(res()->pattern, track) : (res()->fileList ? res()->fileList[track] : 0);
if (musicFile.empty())
return;
delete[] _musicTrackData;
_musicTrackData = _vm->resource()->fileData(musicFile.c_str(), 0);
_driver->loadMusicData(_musicTrackData, true);
if (_musicEnabled == 2 && trackNum != -1) {
g_system->getAudioCDManager()->play(trackNum+1, _driver->looping() ? -1 : 1, 0, 0);
g_system->getAudioCDManager()->update();
} else if (_musicEnabled) {
_driver->cont();
}
_lastTrack = track;
}
void SciEngine::loadMacExecutable() {
if (getPlatform() != Common::kPlatformMacintosh || getSciVersion() < SCI_VERSION_1_EARLY || getSciVersion() > SCI_VERSION_1_1)
return;
Common::String filename;
switch (getGameId()) {
case GID_KQ6:
filename = "King's Quest VI";
break;
case GID_FREDDYPHARKAS:
filename = "Freddy Pharkas";
break;
default:
break;
}
if (filename.empty())
return;
if (!_macExecutable.open(filename) || !_macExecutable.hasResFork()) {
// KQ6/Freddy require the executable to load their icon bar palettes
if (hasMacIconBar())
error("Could not load Mac resource fork '%s'", filename.c_str());
// TODO: Show some sort of warning dialog saying they can't get any
// high-res Mac fonts, when we get to that point ;)
}
}
GameDescriptor::GameDescriptor(const PlainGameDescriptor &pgd, Common::String guioptions) {
setVal("gameid", pgd.gameid);
setVal("description", pgd.description);
if (!guioptions.empty())
setVal("guioptions", Common::getGameGUIOptionsDescription(guioptions));
}
void RemoteBrowserDialog::updateListing() {
// Update the path display
Common::String path = _node.path();
if (path.empty())
path = "/"; //root
if (_navigationLocked)
path = "Loading... " + path;
_currentPath->setLabel(path);
if (!_navigationLocked) {
// Populate the ListWidget
ListWidget::StringArray list;
ListWidget::ColorList colors;
for (Common::Array<Cloud::StorageFile>::iterator i = _nodeContent.begin(); i != _nodeContent.end(); ++i) {
if (i->isDirectory()) {
list.push_back(i->name() + "/");
colors.push_back(ThemeEngine::kFontColorNormal);
} else {
list.push_back(i->name());
colors.push_back(ThemeEngine::kFontColorAlternate);
}
}
_fileList->setList(list, &colors);
_fileList->scrollTo(0);
}
_fileList->setEnabled(!_navigationLocked);
// Finally, redraw
g_gui.scheduleTopDialogRedraw();
}
Ps2FilesystemNode::Ps2FilesystemNode(const Common::String &path) {
dbg_printf("NEW FSNODE(%s)\n", path.c_str());
_path = path;
if (path.empty()) {
_isHere = true;
_isDirectory = true; /* root is always a dir */
_isRoot = true;
_displayName = Common::String("PlayStation 2");
_verified = true;
} else if (path.lastChar() == ':') {
_isHere = true;
_isDirectory = true; /* devs are always a dir */
_isRoot = false;
_displayName = getDeviceDescription();
_verified = true;
} else {
_verified = false;
doverify();
if (!_isHere)
return;
_displayName = _lastPathComponent(_path);
if (_isDirectory && _path.lastChar() != '/')
_path+= '/';
_isRoot = false;
}
}
// returns true if something has been completed
// completion has to be delete[]-ed then
bool Debugger::tabComplete(const char *input, Common::String &completion) const {
// very basic tab completion
// for now it just supports command completions
// adding completions of command parameters would be nice (but hard) :-)
// maybe also give a list of possible command completions?
// (but this will require changes to console)
if (strchr(input, ' '))
return false; // already finished the first word
const uint inputlen = strlen(input);
completion.clear();
CommandsMap::const_iterator i, e = _cmds.end();
for (i = _cmds.begin(); i != e; ++i) {
if (i->_key.hasPrefix(input)) {
uint commandlen = i->_key.size();
if (commandlen == inputlen) { // perfect match, so no tab completion possible
return false;
}
if (commandlen > inputlen) { // possible match
// no previous match
if (completion.empty()) {
completion = i->_key.c_str() + inputlen;
} else {
// take common prefix of previous match and this command
for (uint j = 0; j < completion.size(); j++) {
if (inputlen + j >= i->_key.size() ||
completion[j] != i->_key[inputlen + j]) {
completion = Common::String(completion.begin(), completion.begin() + j);
// If there is no unambiguous completion, abort
if (completion.empty())
return false;
break;
}
}
}
}
}
}
if (completion.empty())
return false;
return true;
}
Common::OutSaveFile *SlotFileStatic::openWrite() const {
Common::String name = build();
if (name.empty())
return 0;
Common::SaveFileManager *saveMan = g_system->getSavefileManager();
Common::OutSaveFile *result = saveMan->openForSaving(name);
return result;
}