void EngineMain::run(const bpo::variables_map& variables)
{
Settings::Settings settings;
if(!settings.loadUserSettings())
return;
size_t resolutionWidth = settings.get<size_t>("Display","resolutionWidth");
size_t resolutionHeight = settings.get<size_t>("Display","resolutionHeight");
std::string fullscreen = settings.get<std::string>("Display", "fullscreen");
std::string pathEXE = settings.get<std::string>("Game", "PathEXE");
if (pathEXE == "")
{
pathEXE = "Diablo.exe";
}
Engine::ThreadManager threadManager;
FARender::Renderer renderer(resolutionWidth, resolutionHeight, fullscreen == "true");
mInputManager = std::make_shared<EngineInputManager>(renderer.getNuklearContext());
mInputManager->registerKeyboardObserver(this);
std::thread mainThread(std::bind(&EngineMain::runGameLoop, this, &variables, pathEXE));
threadManager.run();
renderDone = true;
mainThread.join();
}
void EngineMain::run(const bpo::variables_map& variables)
{
Settings::Settings settings;
if(!settings.loadUserSettings())
return;
size_t resolutionWidth = settings.get<size_t>("Display","resolutionWidth");
size_t resolutionHeight = settings.get<size_t>("Display","resolutionHeight");
bool fullscreen = settings.get<size_t>("Display", "fullscreen");
std::string pathEXE = settings.get<std::string>("Game", "PathEXE");
if (pathEXE == "")
{
pathEXE = "Diablo.exe";
}
Engine::ThreadManager threadManager;
FARender::Renderer renderer(resolutionWidth, resolutionHeight, fullscreen);
mInputManager = new EngineInputManager(*this);
std::thread mainThread(boost::bind(&EngineMain::runGameLoop, this, &variables, pathEXE));
threadManager.run();
renderDone = true;
mainThread.join();
}
Hotkey::Hotkey(const std::string& name)
{
Settings::Settings hotkeySettings;
hotkeySettings.loadFromFile("resources/hotkeys.ini");
key = hotkeySettings.get<int>(name, "key");
shift = hotkeySettings.get<int>(name, "shift");
ctrl = hotkeySettings.get<int>(name, "ctrl");
alt = hotkeySettings.get<int>(name, "alt");
}
void Hotkey::save(const char *name)
{
std::string sname = name;
Settings::Settings hotkeySettings;
hotkeySettings.loadFromFile("resources/hotkeys.ini");
hotkeySettings.set<int>(sname, "key", key);
hotkeySettings.set<int>(sname, "shift", int(shift));
hotkeySettings.set<int>(sname, "ctrl", int(ctrl));
hotkeySettings.set<int>(sname, "alt", int(alt));
hotkeySettings.save();
}
int fa_main(int argc, char** argv)
{
Settings::Settings settings;
if(!settings.loadUserSettings())
return EXIT_FAILURE;
if (!FAIO::init(settings.get<std::string>("Game","PathMPQ")))
{
return EXIT_FAILURE;
}
Engine::EngineMain engine;
int retval = EXIT_SUCCESS;
boost::program_options::variables_map variables;
if (parseOptions(argc, argv, variables))
engine.run(variables);
else
retval = EXIT_FAILURE;
FAIO::FAFileObject::quit();
return retval;
}
void EngineMain::runGameLoop(const bpo::variables_map& variables, const std::string& pathEXE)
{
FALevelGen::FAsrand(static_cast<int> (time(nullptr)));
FAWorld::Player* player;
FARender::Renderer& renderer = *FARender::Renderer::get();
Settings::Settings settings;
if(!settings.loadUserSettings())
return;
std::string characterClass = variables["character"].as<std::string>();
DiabloExe::DiabloExe exe(pathEXE);
if (!exe.isLoaded())
{
renderer.stop();
return;
}
FAWorld::ItemManager& itemManager = FAWorld::ItemManager::get();
FAWorld::World world(exe);
FAWorld::PlayerFactory playerFactory(exe);
bool isServer = variables["mode"].as<std::string>() == "server";
if(isServer)
world.generateLevels();
itemManager.loadItems(&exe);
player = playerFactory.create(characterClass);
world.addCurrentPlayer(player);
if (variables["invuln"].as<std::string>() == "on")
player->setInvuln(true);
mInputManager->registerKeyboardObserver(&world);
mInputManager->registerMouseObserver(&world);
int32_t currentLevel = variables["level"].as<int32_t>();
FAGui::GuiManager guiManager(*this, *player);
world.setGuiManager (&guiManager);
if (currentLevel == -1)
currentLevel = 0;
bool clientWaitingForLevel = false;
// -1 represents the main menu
if(currentLevel != -1 && isServer)
world.setLevel(currentLevel);
else
clientWaitingForLevel = true;
boost::asio::io_service io;
NetManager netManager(isServer, playerFactory);
// Main game logic loop
while(!mDone)
{
boost::asio::deadline_timer timer(io, boost::posix_time::milliseconds(1000/FAWorld::World::ticksPerSecond));
if (clientWaitingForLevel)
{
clientWaitingForLevel = world.getCurrentLevel() != nullptr;
}
mInputManager->update(mPaused);
if(!mPaused && !clientWaitingForLevel)
{
world.update(mNoclip);
}
nk_context* ctx = renderer.getNuklearContext();
netManager.update();
guiManager.update(mPaused, ctx);
FAWorld::GameLevel* level = world.getCurrentLevel();
FARender::RenderState* state = renderer.getFreeState();
if(state)
{
state->mPos = player->getPos();
if(level != NULL)
state->tileset = renderer.getTileset(*level);
state->level = level;
if(!FAGui::cursorPath.empty())
state->mCursorEmpty = false;
else
state->mCursorEmpty = true;
state->mCursorFrame = FAGui::cursorFrame;
state->mCursorSpriteGroup = renderer.loadImage("data/inv/objcurs.cel");
state->mCursorHotspot = FAGui::cursorHotspot;
world.fillRenderState(state);
state->nuklearData.fill(ctx);
}
std::vector<uint32_t> spritesToPreload;
if (renderer.getAndClearSpritesNeedingPreloading(spritesToPreload))
ThreadManager::get()->sendSpritesForPreload(spritesToPreload);
nk_clear(ctx);
renderer.setCurrentState(state);
auto remainingTickTime = timer.expires_from_now().total_milliseconds();
if(remainingTickTime < 0)
std::cerr << "tick time exceeded by " << -remainingTickTime << "ms" << std::endl;
timer.wait();
}
renderer.stop();
renderer.waitUntilDone();
}
int main(int argc, char** argv)
{
if (argc > 2)
message_and_abort_fmt("Usage: %s [filename]", argv[0]);
Render::RenderSettings renderSettings;
renderSettings.windowWidth = 800;
renderSettings.windowHeight = 600;
renderSettings.fullscreen = false;
NuklearMisc::StandaloneGuiHandler guiHandler("Cel Viewer", renderSettings);
nk_context* ctx = guiHandler.getNuklearContext();
Settings::Settings settings;
settings.loadFromFile("resources/celview.ini");
bool faioInitDone = false;
std::string listFile = settings.get<std::string>("celview", "listFile", "Diablo I.txt");
std::string mpqFile = settings.get<std::string>("celview", "mpqFile", "DIABDAT.MPQ");
std::vector<std::string> celFiles;
std::string selectedImage = "";
std::unique_ptr<NuklearMisc::GuiSprite> image;
std::unique_ptr<NuklearMisc::GuiSprite> nextImage;
int animate = false;
int32_t frame = 0;
float rowHeight = 30;
auto lastFrame = std::chrono::high_resolution_clock::now();
bool quit = false;
while (!quit)
{
auto now = std::chrono::high_resolution_clock::now();
if (nextImage)
image = std::unique_ptr<NuklearMisc::GuiSprite>(nextImage.release());
renderSettings = Render::getWindowSize();
if (nk_begin(ctx, "main_window", nk_rect(0, 0, renderSettings.windowWidth, renderSettings.windowHeight), NK_WINDOW_NO_SCROLLBAR))
{
struct nk_rect bounds = nk_window_get_content_region(ctx);
nk_layout_row_dynamic(ctx, bounds.h, 2);
if (nk_group_begin(ctx, "image", 0))
{
nk_layout_row_dynamic(ctx, rowHeight, 1);
std::string label = selectedImage;
if (selectedImage == "")
label = "No image selected";
nk_label(ctx, label.c_str(), NK_TEXT_CENTERED);
nk_checkbox_label(ctx, "Animate", &animate);
if (image)
{
nk_label(ctx, (boost::format("Number of Frames: %1%") % image.get()->getSprite()->size()).str().c_str(), NK_TEXT_LEFT);
nk_label(ctx, (boost::format("Width: %1%") % image->getSprite()->getWidth()).str().c_str(), NK_TEXT_LEFT);
nk_label(ctx, (boost::format("Height: %1%") % image->getSprite()->getHeight()).str().c_str(), NK_TEXT_LEFT);
frame = nk_propertyi(ctx, "Frame", 0, frame, image->getSprite()->size(), 1, 0.2f);
if (nk_button_label(ctx, "save as png"))
{
nfdchar_t* outPath = NULL;
nfdresult_t result = NFD_SaveDialog("png", NULL, &outPath);
if (result == NFD_OKAY)
{
Render::SpriteGroup::toPng(selectedImage, outPath);
free(outPath);
}
}
if (nk_button_label(ctx, "save as gif"))
{
nfdchar_t* outPath = NULL;
nfdresult_t result = NFD_SaveDialog("gif", NULL, &outPath);
if (result == NFD_OKAY)
{
Render::SpriteGroup::toGif(selectedImage, outPath);
free(outPath);
}
}
auto msSinceLastFrame = std::chrono::duration_cast<std::chrono::milliseconds>(now - lastFrame).count();
if (animate && msSinceLastFrame > 100)
{
lastFrame = now;
frame++;
}
if (frame >= (int32_t)image.get()->getSprite()->size())
frame = 0;
Render::Sprite sprite = image.get()->getSprite()->operator[](frame);
int32_t w, h;
Render::spriteSize(sprite, w, h);
nk_layout_space_begin(ctx, NK_STATIC, h, 1);
{
nk_layout_space_push(ctx, nk_rect(0, 0, w, h));
auto canvas = nk_window_get_canvas(ctx);
struct nk_rect imageRect;
nk_widget(&imageRect, ctx);
nk_fill_rect(canvas, imageRect, 0.0, nk_rgb(0, 255, 0));
auto img = image.get()->getNkImage(frame);
nk_draw_image(canvas, imageRect, &img, nk_rgb(255, 255, 255));
}
nk_layout_space_end(ctx);
}
nk_group_end(ctx);
}
if (nk_group_begin(ctx, "file list", 0))
{
if (!faioInitDone)
{
nk_layout_row_dynamic(ctx, rowHeight * 2, 1);
NuklearMisc::nk_file_pick(ctx, "DIABDAT.MPQ", mpqFile, "mpq,MPQ", rowHeight);
NuklearMisc::nk_file_pick(ctx, "Diablo listfile", listFile, "txt", rowHeight);
if (nk_button_label(ctx, "load"))
{
FAIO::init(mpqFile, listFile);
celFiles = FAIO::listMpqFiles("*.cel");
auto tmp = FAIO::listMpqFiles("*.cl2");
celFiles.insert(celFiles.end(), tmp.begin(), tmp.end());
std::sort(celFiles.begin(), celFiles.end());
settings.set<std::string>("celview", "listFile", listFile);
settings.set<std::string>("celview", "mpqFile", mpqFile);
settings.save();
faioInitDone = true;
if (argc > 1)
{
selectedImage = argv[1];
frame = 0;
nextImage = std::unique_ptr<NuklearMisc::GuiSprite>(guiHandler.getSprite(new Render::SpriteGroup(selectedImage)));
}
}
}
nk_layout_row_dynamic(ctx, rowHeight, 1);
for (size_t i = 0; i < celFiles.size(); i++)
{
auto buttonStyle = ctx->style.button;
if (selectedImage == celFiles[i])
buttonStyle.normal = buttonStyle.hover;
if (nk_button_label_styled(ctx, &buttonStyle, celFiles[i].c_str()))
{
selectedImage = celFiles[i];
frame = 0;
nextImage = std::unique_ptr<NuklearMisc::GuiSprite>(guiHandler.getSprite(new Render::SpriteGroup(selectedImage)));
}
}
nk_group_end(ctx);
}
}
nk_end(ctx);
quit = guiHandler.update();
}
FAIO::quit();
return 0;
}
/**
* Apply the settings that are changeable in the preferences. This is also
* called in the event handler from the preferences.
*/
void ScintillaEditor::applySettings()
{
SettingsConverter conv;
Settings::Settings *s = Settings::Settings::inst();
qsci->setIndentationWidth(s->get(Settings::Settings::indentationWidth).toDouble());
qsci->setTabWidth(s->get(Settings::Settings::tabWidth).toDouble());
qsci->setWrapMode(conv.toWrapMode(s->get(Settings::Settings::lineWrap)));
qsci->setWrapIndentMode(conv.toLineWrapIndentationStyle(s->get(Settings::Settings::lineWrapIndentationStyle)));
qsci->setWrapVisualFlags(conv.toLineWrapVisualization(s->get(Settings::Settings::lineWrapVisualizationEnd)),
conv.toLineWrapVisualization(s->get(Settings::Settings::lineWrapVisualizationBegin)),
s->get(Settings::Settings::lineWrapIndentation).toDouble());
qsci->setWhitespaceVisibility(conv.toShowWhitespaces(s->get(Settings::Settings::showWhitespace)));
qsci->setWhitespaceSize(s->get(Settings::Settings::showWhitespaceSize).toDouble());
qsci->setAutoIndent(s->get(Settings::Settings::autoIndent).toBool());
std::string indentStyle = s->get(Settings::Settings::indentStyle).toString();
qsci->setIndentationsUseTabs(indentStyle == "Tabs");
std::string tabKeyFunction = s->get(Settings::Settings::tabKeyFunction).toString();
qsci->setTabIndents(tabKeyFunction == "Indent");
qsci->setBraceMatching(s->get(Settings::Settings::enableBraceMatching).toBool() ? QsciScintilla::SloppyBraceMatch : QsciScintilla::NoBraceMatch);
qsci->setCaretLineVisible(s->get(Settings::Settings::highlightCurrentLine).toBool());
}
