void Room::update()
{
static unsigned cntr = 0;
// std::cerr << "Updating room " << getName() << std::endl;
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
std::default_random_engine engine(seed);
std::uniform_real_distribution<double> distr(0.0, 1.0);
std::uniform_int_distribution<int> lvl(1,3);
if (distr(engine) > 0.1)
return;
if (distr(engine) < encounters.dragon)
this->addActor(new Dragon("dragon" + std::to_string(++cntr), lvl(engine)));
if (distr(engine) < encounters.thief)
this->addActor(new Thief("thief" + std::to_string(++cntr), lvl(engine)));
if (distr(engine) < encounters.golem)
this->addActor(new Golem("golem" + std::to_string(++cntr), lvl(engine)));
if (distr(engine) < encounters.troll)
this->addActor(new Troll("troll" + std::to_string(++cntr), lvl(engine)));
}
void layer_raster::reset_table_defs()
{
if (m_tbls.empty())
return;
for (size_t lvl(0); lvl < m_raster.levels.size(); ++lvl)
get_provider()->reset_table_def(m_raster.levels[lvl].geometry);
}
void Level::LoadFromFile(const std::string& filename) {
m_name = filename;
std::ifstream lvl(filename.c_str());
if (!lvl) {
std::cerr << "Nie udało się załadować pliku " << filename << "\n";
m_loaded = false;
return;
}
lvl >> m_width >> m_height;
m_data.resize(m_height);
for (size_t y = 0; y < m_height; ++y) {
m_data.at(y).resize(m_width);
}
for (size_t y = 0; y < m_height; ++y) {
for (size_t x = 0; x < m_width; ++x) {
int tmp;
lvl >> tmp;
m_data.at(y).at(x) = FT::FieldType(tmp);
}
}
m_loaded = true;
}
void ItemFormatterBase::setJobLevelFld(int index, const QString &fld, bool center)
{
QByteArray lvl(fld.trimmed().toAscii());
if (lvl.size()) {
setTextFld(index, job_level_to_str(lvl[0]), center);
} else {
setTextFld(index, "", center);
}
}
bool TMap::loadBigMap(const CString& pFileName, TServer* pServer)
{
// Get the appropriate filesystem.
CFileSystem* fileSystem = pServer->getFileSystem();
if (pServer->getSettings()->getBool("nofoldersconfig", false) == false)
fileSystem = pServer->getFileSystem(FS_FILE);
CString fileName = fileSystem->find(pFileName);
modTime = fileSystem->getModTime(pFileName);
mapName = pFileName;
// Make sure the file exists.
if (fileName.length() == 0) return false;
// Load the gmap.
std::vector<CString> fileData = CString::loadToken(fileName);
// Parse it.
std::vector<CString>::iterator i = fileData.begin();
levels.clear();
int bmapx = 0;
int bmapy = 0;
while (i != fileData.end())
{
CString line = i->removeAll("\r").trim();
if (line.length() == 0) { ++i; continue; }
// Untokenize the level names and put them into a vector for easy loading.
line.guntokenizeI();
std::vector<CString> names = line.tokenize("\n");
for (std::vector<CString>::iterator j = names.begin(); j != names.end(); ++j)
{
// Check for blank levels.
if (*j == "\r")
{
++bmapx;
continue;
}
// Save the level into the map.
SMapLevel lvl(bmapx++, bmapy);
levels[*j] = lvl;
}
if (bmapx > width) width = bmapx;
bmapx = 0;
++bmapy;
++i;
}
height = bmapy;
return true;
}
int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
Test lvl("Battery.ChargePercentage", print_int);
Test bars("Battery.ChargeBars", print_int);
Test timelow("Battery.TimeUntilLow", print_ulonglong);
Test timefull("Battery.TimeUntilFull", print_ulonglong);
Test ischg("Battery.IsCharging", print_bool);
Test onbat("Battery.OnBattery", print_bool);
Test lowbat("Battery.LowBattery", print_bool);
return app.exec();
}
layer* layer_raster::fit(provider_ptr pvd)
{
auto raster(pvd->fit_to_reg(m_raster));
std::vector<brig::table_def> tbls;
for (size_t lvl(0); lvl < get_levels(); ++lvl)
{
auto tbl(get_table_def(lvl));
tbl.id.name = raster.levels[lvl].geometry.name;
tbls.push_back(pvd->fit_to_create(tbl));
}
return new layer_raster(pvd, raster, tbls);
}
//Puzzle functions
void World::loadPuzzles(string file) {
//Load puzzles
char buffer[64];
string dataText, argText;
ifstream lvl(file);
int phase = 0;
//Helper variables for loading puzzles
PartData data;
string type, dynamic;
vector <PartData> parts;
Puzzle *puzzle = NULL;
int bonus, challenge, time, par, parX, parY;
//Load level
while (!lvl.eof()) {
//Read to buffer
lvl >> buffer;
argText = buffer;
dataText = buffer;
dataText.erase(std::remove(dataText.begin(), dataText.end(), ','), dataText.end());
if (dataText.find("door") != -1) {
//Done with description line, start phase 1
phase = 1;
}
else if (phase && dataText.find("puzzle") != -1) {
lvl >> buffer;
if (puzzle != NULL) {
puzzle->setParts(parts);
puzzle->setChallenge(challenge);
puzzle->setBonus(bonus);
puzzle->setTime(time);
puzzle->setParticleSpawn(par, parX, parY);
puzzles->push_back(puzzle);
}
puzzle = new Puzzle();
parts.clear();
bonus = 0;
challenge = 0;
time = -1;
par = 0;
parX = 0;
parY = 0;
}
else if (phase) {
void append(const boost::posix_time::ptime ×tamp, const Log::Level level,
const std::string &position, const std::string &message) {
const boost::optional<Context::Handle> ctx = Context::getContextOptional();
if (ctx) {
const ::tm tm = boost::posix_time::to_tm(timestamp);
LocalRef<jobject> localDateTime =
localDateTimeClass_.callStaticObjectMethod(
localDateTimeOfId_, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec);
LocalRef<jobject> lvl(
logLevelClass_.newEnumByOrdinal(static_cast<jint>(level)));
LocalRef<jobject> pos(newStringUTF(position));
LocalRef<jobject> msg(newStringUTF(message));
ctx.get()->env()->CallVoidMethod(log_.get(), appendId_,
localDateTime.get(), lvl.get(),
pos.get(), msg.get());
ctx.get()->throwIfOccured();
}
}
graphics::texture render_fbo(const rect& area, const std::vector<entity_ptr> objects)
{
const controls::control_backup_scope ctrl_backup;
const int tex_width = graphics::texture::allows_npot() ? area.w() : graphics::texture::next_power_of_2(area.w());
const int tex_height = graphics::texture::allows_npot() ? area.h() : graphics::texture::next_power_of_2(area.h());
GLint video_framebuffer_id = 0;
glGetIntegerv(EXT_MACRO(GL_FRAMEBUFFER_BINDING), &video_framebuffer_id);
GLuint texture_id = 0;
glGenTextures(1, &texture_id);
glBindTexture(GL_TEXTURE_2D, texture_id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex_width, tex_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
GLuint framebuffer_id = 0;
EXT_CALL(glGenFramebuffers)(1, &framebuffer_id);
EXT_CALL(glBindFramebuffer)(EXT_MACRO(GL_FRAMEBUFFER), framebuffer_id);
// attach the texture to FBO color attachment point
EXT_CALL(glFramebufferTexture2D)(EXT_MACRO(GL_FRAMEBUFFER), EXT_MACRO(GL_COLOR_ATTACHMENT0),
GL_TEXTURE_2D, texture_id, 0);
// check FBO status
GLenum status = EXT_CALL(glCheckFramebufferStatus)(EXT_MACRO(GL_FRAMEBUFFER));
ASSERT_NE(status, EXT_MACRO(GL_FRAMEBUFFER_UNSUPPORTED));
ASSERT_EQ(status, EXT_MACRO(GL_FRAMEBUFFER_COMPLETE));
glViewport(0, 0, area.w(), area.h());
level_ptr lvl(new level("empty.cfg"));
foreach(const entity_ptr& e, objects) {
lvl->add_character(e);
lvl->add_draw_character(e);
}
size_t mystack::AnytimeContractSearchStack(gridSearch& GS) {
//search in a round robin manner in this step as well
if(level > 0) {
size_t totalCount(0);
for(size_t i = 0; i < numRange; i++) {
size_t count = sArr[i]->AnytimeContractSearchStack(GS);
expCount[i] += count;
totalCount += count;
if(expCount[i] >= lim[i]) {
suspend[i] = true;
}
}
return totalCount;
}
size_t count(0);
do {
bool exist(false);
size_t lvl(0);
openEntry qCur = SelectBestFromAllLevels(exist, lvl);
if(!exist)
{
return count;
}
bool added = GS.CallBack(qCur, lvl);
if(added) {
expCount[lvl]++;
count++;
if(expCount[lvl] >= lim[lvl]) {
suspend[lvl] = true;
}
}
} while(true);
return count;
}
extern "C" int main(int argcount, char* argvec[])
#endif
{
#if defined(__native_client__)
std::cerr << "Running game_main" << std::endl;
chdir("/frogatto");
{
char buf[256];
const char* const res = getcwd(buf,sizeof(buf));
std::cerr << "Current working directory: " << res << std::endl;
}
#endif
#ifdef _MSC_VER
freopen("CON", "w", stderr);
freopen("CON", "w", stdout);
#endif
#if defined(__APPLE__) && TARGET_OS_MAC
chdir([[[NSBundle mainBundle] resourcePath] fileSystemRepresentation]);
#endif
#ifdef NO_STDERR
std::freopen("/dev/null", "w", stderr);
std::cerr.sync_with_stdio(true);
#endif
std::cerr << "Frogatto engine version " << preferences::version() << "\n";
LOG( "After print engine version" );
#if defined(TARGET_BLACKBERRY)
chdir("app/native");
std::cout<< "Changed working directory to: " << getcwd(0, 0) << std::endl;
#endif
game_logic::init_callable_definitions();
std::string level_cfg = "titlescreen.cfg";
bool unit_tests_only = false, skip_tests = false;
bool run_benchmarks = false;
std::vector<std::string> benchmarks_list;
std::string utility_program;
std::vector<std::string> util_args;
std::string server = "wesnoth.org";
#if defined(UTILITY_IN_PROC)
bool create_utility_in_new_process = false;
std::string utility_name;
#endif
bool is_child_utility = false;
const char* profile_output = NULL;
std::string profile_output_buf;
#if defined(__ANDROID__)
//monstartup("libapplication.so");
#endif
std::string orig_level_cfg = level_cfg;
std::string override_level_cfg = "";
int modules_loaded = 0;
std::vector<std::string> argv;
for(int n = 1; n < argcount; ++n) {
#if defined(UTILITY_IN_PROC)
std::string sarg(argvec[n]);
if(sarg.compare(0, 15, "--utility-proc=") == 0) {
create_utility_in_new_process = true;
utility_name = "--utility-child=" + sarg.substr(15);
} else {
argv.push_back(argvec[n]);
}
#else
argv.push_back(argvec[n]);
#endif
if(argv.size() >= 2 && argv[argv.size()-2] == "-NSDocumentRevisionsDebugMode" && argv.back() == "YES") {
//XCode passes these arguments by default when debugging -- make sure they are ignored.
argv.resize(argv.size()-2);
}
}
std::cerr << "Build Options:";
for(auto bo : preferences::get_build_options()) {
std::cerr << " " << bo;
}
std::cerr << std::endl;
#if defined(UTILITY_IN_PROC)
if(create_utility_in_new_process) {
argv.push_back(utility_name);
#if defined(_MSC_VER)
// app name is ignored for windows, we get windows to tell us.
is_child_utility = create_utility_process("", argv);
#else
is_child_utility = create_utility_process(argvec[0], argv);
#endif
if(!is_child_utility) {
argv.pop_back();
}
#if defined(_MSC_VER)
atexit(terminate_utility_process);
#endif
}
#endif
if(sys::file_exists("./master-config.cfg")) {
std::cerr << "LOADING CONFIGURATION FROM master-config.cfg" << std::endl;
variant cfg = json::parse_from_file("./master-config.cfg");
if(cfg.is_map()) {
if( cfg["id"].is_null() == false) {
std::cerr << "SETTING MODULE PATH FROM master-config.cfg: " << cfg["id"].as_string() << std::endl;
preferences::set_preferences_path_from_module(cfg["id"].as_string());
//XXX module::set_module_name(cfg["id"].as_string(), cfg["id"].as_string());
}
if(cfg["arguments"].is_null() == false) {
std::vector<std::string> additional_args = cfg["arguments"].as_list_string();
argv.insert(argv.begin(), additional_args.begin(), additional_args.end());
std::cerr << "ADDING ARGUMENTS FROM master-config.cfg:";
for(size_t n = 0; n < cfg["arguments"].num_elements(); ++n) {
std::cerr << " " << cfg["arguments"][n].as_string();
}
std::cerr << std::endl;
}
}
}
stats::record_program_args(argv);
for(size_t n = 0; n < argv.size(); ++n) {
const int argc = argv.size();
const std::string arg(argv[n]);
std::string arg_name, arg_value;
std::string::const_iterator equal = std::find(arg.begin(), arg.end(), '=');
if(equal != arg.end()) {
arg_name = std::string(arg.begin(), equal);
arg_value = std::string(equal+1, arg.end());
}
if(arg_name == "--module") {
if(load_module(arg_value, &argv) != 0) {
std::cerr << "FAILED TO LOAD MODULE: " << arg_value << "\n";
return -1;
}
++modules_loaded;
} else if(arg == "--tests") {
unit_tests_only = true;
}
}
if(modules_loaded == 0 && !unit_tests_only) {
if(load_module(DEFAULT_MODULE, &argv) != 0) {
std::cerr << "FAILED TO LOAD MODULE: " << DEFAULT_MODULE << "\n";
return -1;
}
}
preferences::load_preferences();
LOG( "After load_preferences()" );
// load difficulty settings after module, before rest of args.
difficulty::manager();
for(size_t n = 0; n < argv.size(); ++n) {
const size_t argc = argv.size();
const std::string arg(argv[n]);
std::string arg_name, arg_value;
std::string::const_iterator equal = std::find(arg.begin(), arg.end(), '=');
if(equal != arg.end()) {
arg_name = std::string(arg.begin(), equal);
arg_value = std::string(equal+1, arg.end());
}
std::cerr << "ARGS: " << arg << std::endl;
if(arg.substr(0,4) == "-psn") {
// ignore.
} else if(arg_name == "--module") {
// ignore already processed.
} else if(arg_name == "--profile" || arg == "--profile") {
profile_output_buf = arg_value;
profile_output = profile_output_buf.c_str();
} else if(arg_name == "--utility" || arg_name == "--utility-child") {
if(arg_name == "--utility-child") {
is_child_utility = true;
}
utility_program = arg_value;
for(++n; n < argc; ++n) {
const std::string arg(argv[n]);
util_args.push_back(arg);
}
break;
} else if(arg == "--benchmarks") {
run_benchmarks = true;
} else if(arg_name == "--benchmarks") {
run_benchmarks = true;
benchmarks_list = util::split(arg_value);
} else if(arg == "--tests") {
// ignore as already processed.
} else if(arg == "--no-tests") {
skip_tests = true;
} else if(arg_name == "--width") {
std::string w(arg_value);
preferences::set_actual_screen_width(boost::lexical_cast<int>(w));
} else if(arg == "--width" && n+1 < argc) {
std::string w(argv[++n]);
preferences::set_actual_screen_width(boost::lexical_cast<int>(w));
} else if(arg_name == "--height") {
std::string h(arg_value);
preferences::set_actual_screen_height(boost::lexical_cast<int>(h));
} else if(arg == "--height" && n+1 < argc) {
std::string h(argv[++n]);
preferences::set_actual_screen_height(boost::lexical_cast<int>(h));
} else if(arg_name == "--level") {
override_level_cfg = arg_value;
} else if(arg == "--level" && n+1 < argc) {
override_level_cfg = argv[++n];
} else if(arg_name == "--host") {
server = arg_value;
} else if(arg == "--host" && n+1 < argc) {
server = argv[++n];
} else if(arg == "--compiled") {
preferences::set_load_compiled(true);
#ifndef NO_EDITOR
} else if(arg == "--edit") {
preferences::set_edit_on_start(true);
#endif
} else if(arg == "--no-compiled") {
preferences::set_load_compiled(false);
#if defined(TARGET_PANDORA)
} else if(arg == "--no-fbo") {
preferences::set_fbo(false);
} else if(arg == "--no-bequ") {
preferences::set_bequ(false);
#endif
} else if(arg == "--help" || arg == "-h") {
print_help(std::string(argvec[0]));
return 0;
} else {
const bool res = preferences::parse_arg(argv[n].c_str());
if(!res) {
std::cerr << "unrecognized arg: '" << arg << "'\n";
return -1;
}
}
}
checksum::manager checksum_manager;
#ifndef NO_EDITOR
sys::filesystem_manager fs_manager;
#endif // NO_EDITOR
preferences::expand_data_paths();
background_task_pool::manager bg_task_pool_manager;
LOG( "After expand_data_paths()" );
std::cerr << "Preferences dir: " << preferences::user_data_path() << '\n';
//make sure that the user data path exists.
if(!preferences::setup_preferences_dir()) {
std::cerr << "cannot create preferences dir!\n";
}
std::cerr << "\n";
const tbs::internal_server_manager internal_server_manager_scope(preferences::internal_tbs_server());
if(utility_program.empty() == false
&& test::utility_needs_video(utility_program) == false) {
#if defined(UTILITY_IN_PROC)
if(is_child_utility) {
ASSERT_LOG(ipc::semaphore::create(shared_sem_name, 1) != false,
"Unable to create shared semaphore: " << errno);
std::cerr.sync_with_stdio(true);
}
#endif
test::run_utility(utility_program, util_args);
return 0;
}
#if defined(TARGET_PANDORA)
EGL_Open();
#endif
#if defined(__ANDROID__)
std::freopen("stdout.txt","w",stdout);
std::freopen("stderr.txt","w",stderr);
std::cerr.sync_with_stdio(true);
#endif
LOG( "Start of main" );
if(!skip_tests && !test::run_tests()) {
return -1;
}
if(unit_tests_only) {
return 0;
}
// Create the main window.
// Initalise SDL and Open GL.
main_window = graphics::window_manager_ptr(new graphics::window_manager());
main_window->create_window(preferences::actual_screen_width(), preferences::actual_screen_height());
#ifdef TARGET_OS_HARMATTAN
g_type_init();
#endif
i18n::init ();
LOG( "After i18n::init()" );
#if TARGET_OS_IPHONE || defined(TARGET_BLACKBERRY) || defined(__ANDROID__)
//on the iPhone and PlayBook, try to restore the auto-save if it exists
if(sys::file_exists(preferences::auto_save_file_path()) && sys::read_file(std::string(preferences::auto_save_file_path()) + ".stat") == "1") {
level_cfg = "autosave.cfg";
sys::write_file(std::string(preferences::auto_save_file_path()) + ".stat", "0");
}
#endif
if(override_level_cfg.empty() != true) {
level_cfg = override_level_cfg;
orig_level_cfg = level_cfg;
}
const stats::manager stats_manager;
#ifndef NO_EDITOR
const external_text_editor::manager editor_manager;
#endif // NO_EDITOR
#if defined(USE_BOX2D)
box2d::manager b2d_manager;
#endif
const load_level_manager load_manager;
{ //manager scope
const font::manager font_manager;
const sound::manager sound_manager;
#if !defined(__native_client__)
const joystick::manager joystick_manager;
#endif
graphics::texture::manager texture_manager;
#ifndef NO_EDITOR
editor::manager editor_manager;
#endif
variant preloads;
loading_screen loader;
try {
variant gui_node = json::parse_from_file(preferences::load_compiled() ? "data/compiled/gui.cfg" : "data/gui.cfg");
gui_section::init(gui_node);
loader.draw_and_increment(_("Initializing GUI"));
framed_gui_element::init(gui_node);
sound::init_music(json::parse_from_file("data/music.cfg"));
graphical_font::init_for_locale(i18n::get_locale());
preloads = json::parse_from_file("data/preload.cfg");
int preload_items = preloads["preload"].num_elements();
loader.set_number_of_items(preload_items+7); // 7 is the number of items that will be loaded below
custom_object::init();
loader.draw_and_increment(_("Initializing custom object functions"));
init_custom_object_functions(json::parse_from_file("data/functions.cfg"));
loader.draw_and_increment(_("Initializing textures"));
loader.load(preloads);
loader.draw_and_increment(_("Initializing tiles"));
tile_map::init(json::parse_from_file("data/tiles.cfg"));
game_logic::formula_object::load_all_classes();
} catch(const json::parse_error& e) {
std::cerr << "ERROR PARSING: " << e.error_message() << "\n";
return 0;
}
loader.draw(_("Loading level"));
#if defined(__native_client__)
while(1) {
}
#endif
#if defined(__APPLE__) && !(TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE) && !defined(USE_SHADERS)
GLint swapInterval = 1;
CGLSetParameter(CGLGetCurrentContext(), kCGLCPSwapInterval, &swapInterval);
#endif
loader.finish_loading();
//look to see if we got any quit events while loading.
{
SDL_Event event;
while(input::sdl_poll_event(&event)) {
if(event.type == SDL_QUIT) {
return 0;
}
}
}
formula_profiler::manager profiler(profile_output);
#ifdef USE_SHADERS
texture_frame_buffer::init(preferences::actual_screen_width(), preferences::actual_screen_height());
#else
texture_frame_buffer::init();
#endif
if(run_benchmarks) {
if(benchmarks_list.empty() == false) {
test::run_benchmarks(&benchmarks_list);
} else {
test::run_benchmarks();
}
return 0;
} else if(utility_program.empty() == false && test::utility_needs_video(utility_program) == true) {
test::run_utility(utility_program, util_args);
return 0;
}
bool quit = false;
while(!quit && !show_title_screen(level_cfg)) {
boost::intrusive_ptr<level> lvl(load_level(level_cfg));
#if !defined(__native_client__)
//see if we're loading a multiplayer level, in which case we
//connect to the server.
multiplayer::manager mp_manager(lvl->is_multiplayer());
if(lvl->is_multiplayer()) {
multiplayer::setup_networked_game(server);
}
if(lvl->is_multiplayer()) {
last_draw_position() = screen_position();
std::string level_cfg = "waiting-room.cfg";
boost::intrusive_ptr<level> wait_lvl(load_level(level_cfg));
wait_lvl->finish_loading();
wait_lvl->set_multiplayer_slot(0);
if(wait_lvl->player()) {
wait_lvl->player()->set_current_level(level_cfg);
}
wait_lvl->set_as_current_level();
level_runner runner(wait_lvl, level_cfg, orig_level_cfg);
multiplayer::sync_start_time(*lvl, boost::bind(&level_runner::play_cycle, &runner));
lvl->set_multiplayer_slot(multiplayer::slot());
}
#endif
last_draw_position() = screen_position();
assert(lvl.get());
if(!lvl->music().empty()) {
sound::play_music(lvl->music());
}
if(lvl->player() && level_cfg != "autosave.cfg") {
lvl->player()->set_current_level(level_cfg);
lvl->player()->get_entity().save_game();
}
set_scene_title(lvl->title());
try {
quit = level_runner(lvl, level_cfg, orig_level_cfg).play_level();
level_cfg = orig_level_cfg;
} catch(multiplayer_exception&) {
}
}
level::clear_current_level();
} //end manager scope, make managers destruct before calling SDL_Quit
// controls::debug_dump_controls();
#if defined(TARGET_PANDORA) || defined(TARGET_TEGRA)
EGL_Destroy();
#endif
preferences::save_preferences();
#if !defined(_MSC_VER) && defined(UTILITY_IN_PROC)
if(create_utility_in_new_process) {
terminate_utility_process();
}
#endif
std::set<variant*> loading;
swap_variants_loading(loading);
if(loading.empty() == false) {
fprintf(stderr, "Illegal object: %p\n", (void*)(*loading.begin())->as_callable_loading());
ASSERT_LOG(false, "Unresolved unserialized objects: " << loading.size());
}
//#ifdef _MSC_VER
// ExitProcess(0);
//#endif
return 0;
}
bool TMap::loadGMap(const CString& pFileName, TServer* pServer)
{
// Get the appropriate filesystem.
CFileSystem* fileSystem = pServer->getFileSystem();
if (pServer->getSettings()->getBool("nofoldersconfig", false) == false)
fileSystem = pServer->getFileSystem(FS_LEVEL);
CString fileName = fileSystem->find(pFileName);
modTime = fileSystem->getModTime(pFileName);
mapName = pFileName;
// Make sure the file exists.
if (fileName.length() == 0) return false;
// Load the gmap.
std::vector<CString> fileData = CString::loadToken(fileName);
// Parse it.
for (std::vector<CString>::iterator i = fileData.begin(); i != fileData.end(); ++i)
{
// Tokenize
std::vector<CString> curLine = i->removeAll("\r").tokenize();
if (curLine.size() < 1)
continue;
// Parse Each Type
if (curLine[0] == "WIDTH")
{
if (curLine.size() != 2)
continue;
width = strtoint(curLine[1]);
}
else if (curLine[0] == "HEIGHT")
{
if (curLine.size() != 2)
continue;
height = strtoint(curLine[1]);
}
else if (curLine[0] == "GENERATED")
{
if (curLine.size() != 2)
continue;
// Not really needed.
}
else if (curLine[0] == "LEVELNAMES")
{
levels.clear();
++i;
int gmapx = 0;
int gmapy = 0;
while (i != fileData.end())
{
CString line = i->removeAll("\r").trim();
if (line.length() == 0) { ++i; continue; }
if (line == "LEVELNAMESEND") break;
// Untokenize the level names and put them into a vector for easy loading.
line.guntokenizeI();
std::vector<CString> names = line.tokenize("\n");
for (std::vector<CString>::iterator j = names.begin(); j != names.end(); ++j)
{
// Check for blank levels.
if (*j == "\r")
{
++gmapx;
continue;
}
// Save the level into the map.
SMapLevel lvl(gmapx++, gmapy);
levels[*j] = lvl;
}
gmapx = 0;
++gmapy;
++i;
}
}
else if (curLine[0] == "MAPIMG")
{
if (curLine.size() != 2)
continue;
mapImage = curLine[1];
}
else if (curLine[0] == "MINIMAPIMG")
{
if (curLine.size() != 2)
continue;
miniMapImage = curLine[1];
}
else if (curLine[0] == "NOAUTOMAPPING")
{
// Clientside only.
}
else if (curLine[0] == "LOADFULLMAP")
{
// Not supported currently.
}
else if (curLine[0] == "LOADATSTART")
{
// Not supported currently.
++i;
while (i != fileData.end())
{
CString line = i->removeAll("\r");
if (line == "LOADATSTARTEND") break;
}
}
// TODO: 3D settings maybe?
}
return true;
}
/// ------------------------------------------------------------------------------------------------
/// Method which is called at the beginning of the run
void
correlate::beginRun(Event& evt, Env& env)
{
MsgLog(name(), debug, "correlate::beginRun()" );
p_outputPrefix = *( (shared_ptr<std::string>) evt.get(IDSTRING_OUTPUT_PREFIX) ).get();
updatePixelArrays(evt);
if (p_pix1_sp && p_pix2_sp){
MsgLog(name(), trace, "read data for pix1(n=" << p_pix1_sp->size() << "), pix2(n=" << p_pix2_sp->size() << ")" );
}else{
MsgLog(name(), error, "could not get data from pixX(addr=" << p_pix1_sp.get() << ") or pixY(addr=" << p_pix2_sp.get() << ")" );
}
//if stop_q is still zero, give it a reasonable default value
if (p_stopQ == 0){
p_stopQ = p_pix1_sp->calcMax();
}
//create a CrossCorrelator object (whose data will be replaced in every event())
//take care of everything that needs to be done only once here
delete p_cc;
p_cc = new CrossCorrelator(p_pix1_sp.get(), p_pix1_sp.get(), p_pix2_sp.get(), p_nPhi, p_nQ1);
p_nLag = p_cc->nLag();
//set some properties of the cross correlator
if (p_useMask) {
p_cc->setMask( p_mask );
p_cc->setMaskEnable ( true );
}else{
p_cc->setMaskEnable( false );
}
if (p_autoCorrelateOnly) {
p_cc->setXccaEnable( false );
}else{
p_cc->setXccaEnable( true );
}
//check psana's debug level, set a debug flag for cc, if it's at least 'trace'
MsgLogger::MsgLogLevel lvl(MsgLogger::MsgLogLevel::trace);
if ( MsgLogger::MsgLogger().logging(lvl) ) {
p_cc->setDebug(1);
}
//prepare lookup table, if necessary
if ( p_alg == 2 || p_alg == 4 ){
MsgLog(name(), info, "creating lookup table");
p_cc->createLookupTable(p_LUTy, p_LUTx);
}
//construct a file name to read the grand average polar image, e.g., something like
// reg/neh/home/feldkamp/scratch_cxi35711/runs_2012_03_07_gaincorr/r0084/r0084_avg_polar.h5
if (p_useGrandAvgPolar){
string fn_grandAvgPolar = p_grandAvgPolarDir + p_outputPrefix + "/" + p_outputPrefix + p_grandAvgPolarExt;
MsgLog( name(), info, "grand average (polar): " << fn_grandAvgPolar );
array2D<double> *img2D = 0;
int fail = io->readFromFile( fn_grandAvgPolar, img2D );
if (!fail){
p_cc->setGrandAvgPolar( img2D );
MsgLog(name(), info, "grand average (polar) loaded successfully" );
}else{
MsgLog(name(), info, "grand average (polar) NOT loaded" );
WAIT;
}
delete img2D;
}
MsgLog(name(), info, "CrossCorrelator set up. "
<< " cc=" << p_cc
<< " mask=" << p_cc->mask()
<< " xccaEnable=" << p_cc->xccaEnable()
<< " nQ= " << p_cc->nQ()
<< " nPhi= " << p_cc->nPhi()
<< " nLag= " << p_cc->nLag()
);
//size average-keeping arrays after p_nLag is known (from the cross-correlator)
p_polarAvg_sp = shared_ptr<array2D<double> >( new array2D<double>(p_nQ1,p_nPhi) );
p_corrAvg_sp = shared_ptr<array2D<double> >( new array2D<double>(p_nQ1,p_nLag) );
p_qAvg_sp = shared_ptr<array1D<double> >( new array1D<double>(p_nQ1) );
p_iAvg_sp = shared_ptr<array1D<double> >( new array1D<double>(p_nQ1) );
}
void SpawnShell::consMessage(const considerStruct * con, uint32_t, uint8_t dir)
{
Item* item;
Spawn* spawn;
if (dir == DIR_CLIENT)
{
if (con->playerid != con->targetid)
{
item = m_spawns.find(con->targetid);
if (item != NULL)
{
spawn = (Spawn*)item;
// note that this spawn has been considered
spawn->setConsidered(true);
emit spawnConsidered(item);
}
}
return;
}
QString lvl("");
QString hps("");
QString cn("");
QString msg("Faction: Your faction standing with ");
//printf("%i, %i, %i, %i\n", con->unknown1[0], con->unknown1[1], con->unknown2[0], con->unknown2[1]);
// is it you that you've conned?
if (con->playerid == con->targetid)
{
// print it's deity
printf("Diety: %s\n", (const char*)m_player->deityName());
// well, this is You
msg += "YOU";
}
else
{
// find the spawn if it exists
item = m_spawns.find(con->targetid);
// has the spawn been seen before?
if (item != NULL)
{
Spawn* spawn = (Spawn*)item;
// yes
printf("Diety: %s\n", (const char*)spawn->deityName());
int changed = tSpawnChangedNone;
/* maxhp and curhp are available when considering players, */
/* but not when considering mobs. */
if (con->maxHp || con->curHp)
{
if (spawn->NPC() == SPAWN_NPC_UNKNOWN)
{
spawn->setNPC(SPAWN_PLAYER); // player
changed |= tSpawnChangedNPC;
}
spawn->setMaxHP(con->maxHp);
spawn->setHP(con->curHp);
changed |= tSpawnChangedHP;
}
else if (item->NPC() == SPAWN_NPC_UNKNOWN)
{
spawn->setNPC(SPAWN_NPC);
changed |= tSpawnChangedNPC;
}
// note the updates if any
if (changed != tSpawnChangedNone)
{
if (updateFilterFlags(item))
changed |= tSpawnChangedFilter;
if (updateRuntimeFilterFlags(item))
changed |= tSpawnChangedRuntimeFilter;
item->updateLastChanged();
emit changeItem(item, changed);
}
// note that this spawn has been considered
spawn->setConsidered(true);
emit spawnConsidered(item);
msg += item->name();
} // end if spawn found
else
msg += "Spawn:" + QString::number(con->targetid, 16);
} // else not yourself
switch (con->level)
{
case 0:
{
cn.sprintf(" (even)");
break;
}
case 2:
{
cn.sprintf(" (green)");
break;
}
case 4:
{
cn.sprintf(" (blue)");
break;
}
case 13:
{
cn.sprintf(" (red)");
break;
}
case 15:
{
cn.sprintf(" (yellow)");
break;
}
case 18:
{
cn.sprintf(" (cyan)");
break;
}
default:
{
cn.sprintf(" (unknown: %d)", con->level);
break;
}
}
msg += cn;
if (con->maxHp || con->curHp)
{
lvl.sprintf(" (%i/%i HP)", con->curHp, con->maxHp);
msg += lvl;
}
msg += QString(" is: ") + print_faction(con->faction) + " ("
+ QString::number(con->faction) + ")!";
emit msgReceived(msg);
} // end consMessage()
void MessageShell::consMessage(const uint8_t* data, size_t, uint8_t dir)
{
const considerStruct * con = (const considerStruct*)data;
const Item* item;
QString lvl("");
QString hps("");
QString cn("");
QString deity;
QString msg("Your faction standing with ");
// is it you that you've conned?
if (con->playerid == con->targetid)
{
deity = m_player->deityName();
// well, this is You
msg += m_player->name();
}
else
{
// find the spawn if it exists
item = m_spawnShell->findID(tSpawn, con->targetid);
// has the spawn been seen before?
if (item != NULL)
{
Spawn* spawn = (Spawn*)item;
// yes
deity = spawn->deityName();
msg += item->name();
} // end if spawn found
else
msg += "Spawn:" + QString::number(con->targetid, 16);
} // else not yourself
switch (con->level)
{
case 0:
case 20:
msg += " (even)";
break;
case 2:
msg += " (green)";
break;
case 4:
msg += " (blue)";
break;
case 13:
msg += " (red)";
break;
case 15:
msg += " (yellow)";
break;
case 18:
msg += " (cyan)";
break;
default:
msg += " (unknown: " + QString::number(con->level) + ")";
break;
}
if (!deity.isEmpty())
msg += QString(" [") + deity + "]";
if (con->maxHp || con->curHp)
{
lvl.sprintf(" (%i/%i HP)", con->curHp, con->maxHp);
msg += lvl;
}
msg += QString(" is: ") + print_faction(con->faction) + " ("
+ QString::number(con->faction) + ")!";
m_messages->addMessage(MT_Consider, msg);
} // end consMessage()
int main() {
sdl::Window wnd("Gravity", sdl::Vector2i(100, 100), 640, 480);
sdl::Renderer renderer(wnd, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
sdl::Event event;
Sprite quad("images/rect.png", renderer);
Level lvl(renderer);
sdl::Texture bg(renderer, "images/background.png");
sdl::Rect bg_rect(0, 0, wnd.width(), wnd.height());
Font font("font/arial.ttf", 12);
font.setPosition(32, wnd.height() - 32);
bool running = true;
while (running && lvl.isValid()) {
while (sdl::PollEvent(&event)) {
if (event.type == SDL_QUIT)
running = false;
else if (event.type == SDL_KEYDOWN) {
if (!lvl.timer.isRunning())
lvl.timer.start();
switch (event.keyboard.key) {
case SDLK_ESCAPE:
running = false;
break;
case SDLK_LEFT:
quad.setMovement(-MOVE, 0);
break;
case SDLK_RIGHT:
quad.setMovement(MOVE, 0);
break;
case SDLK_UP:
quad.setMovement(0, -MOVE);
break;
case SDLK_DOWN:
quad.setMovement(0, MOVE);
break;
case SDLK_SPACE:
quad.stopMovement();
break;
}
}
}
renderer.clear(&sdl::Color::White);
renderer.copy(bg, &bg_rect);
if (DeadFrames == 0) {
if (check_tile(lvl, quad))
quad.drawOn(renderer);
} else {
DeadFrames--;
renderer.setDrawColor(sdl::Color::Black);
const sdl::Vector2i& movement = quad.getMovement();
for (sdl::Vector2i& vec : Fragments) {
renderer.drawPoint(vec);
const i16_t rx = Dist(Gen);
const i16_t ry = Dist(Gen);
vec.x += rx + movement.x;
vec.y += ry + movement.y;
}
if (DeadFrames == 0) {
quad.stopMovement();
}
}
lvl.render();
font.format(renderer, "%d s %d ms, Deaths: %d", lvl.timer.getTicks() / 1000, lvl.timer.getTicks() % 1000, Deaths);
renderer.present();
}
}
extern "C" int main(int argcount, char* argvec[])
#endif
{
#if defined(__native_client__)
std::cerr << "Running game_main" << std::endl;
chdir("/frogatto");
{
char buf[256];
const char* const res = getcwd(buf,sizeof(buf));
std::cerr << "Current working directory: " << res << std::endl;
}
#endif
#if defined(__APPLE__) && TARGET_OS_MAC
chdir([[[NSBundle mainBundle] resourcePath] fileSystemRepresentation]);
#endif
#ifdef NO_STDERR
std::freopen("/dev/null", "w", stderr);
std::cerr.sync_with_stdio(true);
#endif
std::cerr << "Frogatto engine version " << preferences::version() << "\n";
LOG( "After print engine version" );
#if defined(TARGET_BLACKBERRY)
chdir("app/native");
std::cout<< "Changed working directory to: " << getcwd(0, 0) << std::endl;
#endif
game_logic::init_callable_definitions();
std::string level_cfg = "titlescreen.cfg";
bool unit_tests_only = false, skip_tests = false;
bool run_benchmarks = false;
std::vector<std::string> benchmarks_list;
std::string utility_program;
std::vector<std::string> util_args;
std::string server = "wesnoth.org";
#if defined(UTILITY_IN_PROC)
bool create_utility_in_new_process = false;
std::string utility_name;
#endif
bool is_child_utility = false;
const char* profile_output = NULL;
std::string profile_output_buf;
#if defined(__ANDROID__)
//monstartup("libapplication.so");
#endif
std::string orig_level_cfg = level_cfg;
std::string override_level_cfg = "";
int modules_loaded = 0;
std::vector<std::string> argv;
for(int n = 1; n < argcount; ++n) {
#if defined(UTILITY_IN_PROC)
std::string sarg(argvec[n]);
if(sarg.compare(0, 15, "--utility-proc=") == 0) {
create_utility_in_new_process = true;
utility_name = "--utility-child=" + sarg.substr(15);
} else {
argv.push_back(argvec[n]);
}
#else
argv.push_back(argvec[n]);
#endif
if(argv.size() >= 2 && argv[argv.size()-2] == "-NSDocumentRevisionsDebugMode" && argv.back() == "YES") {
//XCode passes these arguments by default when debugging -- make sure they are ignored.
argv.resize(argv.size()-2);
}
}
#if defined(UTILITY_IN_PROC)
if(create_utility_in_new_process) {
argv.push_back(utility_name);
#if defined(_MSC_VER)
// app name is ignored for windows, we get windows to tell us.
is_child_utility = create_utility_process("", argv);
#else
is_child_utility = create_utility_process(argvec[0], argv);
#endif
if(!is_child_utility) {
argv.pop_back();
}
#if defined(_MSC_VER)
atexit(terminate_utility_process);
#endif
}
#endif
if(sys::file_exists("./master-config.cfg")) {
std::cerr << "LOADING CONFIGURATION FROM master-config.cfg" << std::endl;
variant cfg = json::parse_from_file("./master-config.cfg");
if(cfg.is_map()) {
if( cfg["id"].is_null() == false) {
std::cerr << "SETTING MODULE PATH FROM master-config.cfg: " << cfg["id"].as_string() << std::endl;
preferences::set_preferences_path_from_module(cfg["id"].as_string());
//XXX module::set_module_name(cfg["id"].as_string(), cfg["id"].as_string());
}
if(cfg["arguments"].is_null() == false) {
std::vector<std::string> additional_args = cfg["arguments"].as_list_string();
argv.insert(argv.begin(), additional_args.begin(), additional_args.end());
std::cerr << "ADDING ARGUMENTS FROM master-config.cfg:";
for(size_t n = 0; n < cfg["arguments"].num_elements(); ++n) {
std::cerr << " " << cfg["arguments"][n].as_string();
}
std::cerr << std::endl;
}
}
}
stats::record_program_args(argv);
for(size_t n = 0; n < argv.size(); ++n) {
const int argc = argv.size();
const std::string arg(argv[n]);
std::string arg_name, arg_value;
std::string::const_iterator equal = std::find(arg.begin(), arg.end(), '=');
if(equal != arg.end()) {
arg_name = std::string(arg.begin(), equal);
arg_value = std::string(equal+1, arg.end());
}
if(arg_name == "--module") {
if(load_module(arg_value, &argv) != 0) {
std::cerr << "FAILED TO LOAD MODULE: " << arg_value << "\n";
return -1;
}
++modules_loaded;
}
}
if(modules_loaded == 0) {
if(load_module(DEFAULT_MODULE, &argv) != 0) {
std::cerr << "FAILED TO LOAD MODULE: " << DEFAULT_MODULE << "\n";
return -1;
}
}
preferences::load_preferences();
LOG( "After load_preferences()" );
// load difficulty settings after module, before rest of args.
difficulty::manager();
for(size_t n = 0; n < argv.size(); ++n) {
const size_t argc = argv.size();
const std::string arg(argv[n]);
std::string arg_name, arg_value;
std::string::const_iterator equal = std::find(arg.begin(), arg.end(), '=');
if(equal != arg.end()) {
arg_name = std::string(arg.begin(), equal);
arg_value = std::string(equal+1, arg.end());
}
std::cerr << "ARGS: " << arg << std::endl;
if(arg_name == "--module") {
// ignore already processed.
} else if(arg_name == "--profile" || arg == "--profile") {
profile_output_buf = arg_value;
profile_output = profile_output_buf.c_str();
} else if(arg_name == "--utility" || arg_name == "--utility-child") {
if(arg_name == "--utility-child") {
is_child_utility = true;
}
utility_program = arg_value;
for(++n; n < argc; ++n) {
const std::string arg(argv[n]);
util_args.push_back(arg);
}
break;
} else if(arg == "--benchmarks") {
run_benchmarks = true;
} else if(arg_name == "--benchmarks") {
run_benchmarks = true;
benchmarks_list = util::split(arg_value);
} else if(arg == "--tests") {
unit_tests_only = true;
} else if(arg == "--no-tests") {
skip_tests = true;
} else if(arg_name == "--width") {
std::string w(arg_value);
preferences::set_actual_screen_width(boost::lexical_cast<int>(w));
} else if(arg == "--width" && n+1 < argc) {
std::string w(argv[++n]);
preferences::set_actual_screen_width(boost::lexical_cast<int>(w));
} else if(arg_name == "--height") {
std::string h(arg_value);
preferences::set_actual_screen_height(boost::lexical_cast<int>(h));
} else if(arg == "--height" && n+1 < argc) {
std::string h(argv[++n]);
preferences::set_actual_screen_height(boost::lexical_cast<int>(h));
} else if(arg_name == "--level") {
override_level_cfg = arg_value;
} else if(arg == "--level" && n+1 < argc) {
override_level_cfg = argv[++n];
} else if(arg_name == "--host") {
server = arg_value;
} else if(arg == "--host" && n+1 < argc) {
server = argv[++n];
} else if(arg == "--compiled") {
preferences::set_load_compiled(true);
#ifndef NO_EDITOR
} else if(arg == "--edit") {
preferences::set_edit_on_start(true);
#endif
} else if(arg == "--no-compiled") {
preferences::set_load_compiled(false);
#if defined(TARGET_PANDORA)
} else if(arg == "--no-fbo") {
preferences::set_fbo(false);
} else if(arg == "--no-bequ") {
preferences::set_bequ(false);
#endif
} else if(arg == "--help" || arg == "-h") {
print_help(std::string(argvec[0]));
return 0;
} else {
const bool res = preferences::parse_arg(argv[n].c_str());
if(!res) {
std::cerr << "unrecognized arg: '" << arg << "'\n";
return -1;
}
}
}
checksum::manager checksum_manager;
#ifndef NO_EDITOR
sys::filesystem_manager fs_manager;
#endif // NO_EDITOR
preferences::expand_data_paths();
background_task_pool::manager bg_task_pool_manager;
LOG( "After expand_data_paths()" );
std::cerr << "Preferences dir: " << preferences::user_data_path() << '\n';
//make sure that the user data path exists.
if(!preferences::setup_preferences_dir()) {
std::cerr << "cannot create preferences dir!\n";
}
std::cerr << "\n";
if(preferences::internal_tbs_server()) {
tbs::internal_server::init();
}
if(utility_program.empty() == false
&& test::utility_needs_video(utility_program) == false) {
#if defined(UTILITY_IN_PROC)
if(is_child_utility) {
ASSERT_LOG(ipc::semaphore::create(shared_sem_name, 1) != false,
"Unable to create shared semaphore: " << errno);
std::cerr.sync_with_stdio(true);
}
#endif
test::run_utility(utility_program, util_args);
return 0;
}
#if defined(TARGET_PANDORA)
EGL_Open();
#endif
#if defined(__ANDROID__)
std::freopen("stdout.txt","w",stdout);
std::freopen("stderr.txt","w",stderr);
std::cerr.sync_with_stdio(true);
#endif
LOG( "Start of main" );
#if !defined(__native_client__)
Uint32 sdl_init_flags = SDL_INIT_VIDEO | SDL_INIT_JOYSTICK;
#if defined(_WINDOWS) || defined(TARGET_OS_IPHONE)
sdl_init_flags |= SDL_INIT_TIMER;
#endif
if(SDL_Init(sdl_init_flags) < 0) {
std::cerr << "could not init SDL\n";
return -1;
}
LOG( "After SDL_Init" );
#endif
#ifdef TARGET_OS_HARMATTAN
g_type_init();
#endif
i18n::init ();
LOG( "After i18n::init()" );
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
#if defined(TARGET_OS_IPHONE) || defined(TARGET_BLACKBERRY) || defined(__ANDROID__)
//on the iPhone and PlayBook, try to restore the auto-save if it exists
if(sys::file_exists(preferences::auto_save_file_path()) && sys::read_file(std::string(preferences::auto_save_file_path()) + ".stat") == "1") {
level_cfg = "autosave.cfg";
sys::write_file(std::string(preferences::auto_save_file_path()) + ".stat", "0");
}
#endif
if(override_level_cfg.empty() != true) {
level_cfg = override_level_cfg;
orig_level_cfg = level_cfg;
}
#if !SDL_VERSION_ATLEAST(2, 0, 0) && defined(USE_GLES2)
wm.create_window(preferences::actual_screen_width(),
preferences::actual_screen_height(),
0,
(preferences::resizable() ? SDL_RESIZABLE : 0) | (preferences::fullscreen() ? SDL_FULLSCREEN : 0));
#else
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
int width, height;
iphone_screen_res(&width, &height);
preferences::set_actual_screen_width(width);
preferences::set_actual_screen_height(height);
int multiplier = 2;
if (width > 320)
{
//preferences::set_use_pretty_scaling(true);
multiplier = 1;
}
preferences::set_virtual_screen_width(height*multiplier);
preferences::set_virtual_screen_height(width*multiplier);
preferences::set_control_scheme(height % 1024 ? "iphone_2d" : "ipad_2d");
SDL_WindowID windowID = SDL_CreateWindow (NULL, 0, 0, preferences::actual_screen_width(), preferences::actual_screen_height(),
SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN |
SDL_WINDOW_BORDERLESS);
if (windowID == 0) {
std::cerr << "Could not create window: " << SDL_GetError() << "\n";
return -1;
}
// if (SDL_GL_CreateContext(windowID) == 0) {
// std::cerr << "Could not create GL context: " << SDL_GetError() << "\n";
// return -1;
// }
if (SDL_CreateRenderer(windowID, -1, 0) != 0) {
std::cerr << "Could not create renderer\n";
return -1;
}
#else
#ifdef TARGET_OS_HARMATTAN
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,SDL_OPENGLES | SDL_FULLSCREEN) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
preferences::init_oes();
SDL_ShowCursor(0);
#else
#if defined(TARGET_PANDORA)
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),16,SDL_FULLSCREEN) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
EGL_Init();
preferences::init_oes();
#elif defined(TARGET_TEGRA)
//if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,preferences::resizable() ? SDL_RESIZABLE : 0|preferences::fullscreen() ? SDL_FULLSCREEN : 0) == NULL) {
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,SDL_FULLSCREEN) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
EGL_Init();
preferences::init_oes();
#elif defined(TARGET_BLACKBERRY)
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,SDL_OPENGL|SDL_FULLSCREEN) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
preferences::init_oes();
#elif defined(__ANDROID__)
#if SDL_VERSION_ATLEAST(2, 0, 0)
int num_video_displays = SDL_GetNumVideoDisplays();
SDL_Rect r;
if(num_video_displays < 0) {
std::cerr << "no video displays available" << std::endl;
return -1;
}
if(SDL_GetDisplayBounds(0, &r) < 0) {
preferences::set_actual_screen_width(r.w);
preferences::set_actual_screen_height(r.h);
if(r.w < 640) {
preferences::set_virtual_screen_width(r.w*2);
preferences::set_virtual_screen_height(r.h*2);
} else {
preferences::set_virtual_screen_width(r.w);
preferences::set_virtual_screen_height(r.h);
}
preferences::set_control_scheme(r.h >= 1024 ? "ipad_2d" : "android_med");
}
#else
SDL_Rect** r = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_OPENGL);
if( r != (SDL_Rect**)0 && r != (SDL_Rect**)-1 ) {
preferences::set_actual_screen_width(r[0]->w);
preferences::set_actual_screen_height(r[0]->h);
if(r[0]->w < 640) {
preferences::set_virtual_screen_width(r[0]->w*2);
preferences::set_virtual_screen_height(r[0]->h*2);
} else {
preferences::set_virtual_screen_width(r[0]->w);
preferences::set_virtual_screen_height(r[0]->h);
}
preferences::set_control_scheme(r[0]->h >= 1024 ? "ipad_2d" : "android_med");
}
#endif
#if SDL_VERSION_ATLEAST(2, 0, 0)
if(!graphics::set_video_mode(preferences::actual_screen_width(), preferences::actual_screen_height())) {
#else
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,SDL_FULLSCREEN|SDL_OPENGL) == NULL) {
#endif
std::cerr << "could not set video mode\n";
return -1;
}
#elif defined(__native_client__)
SDL_Rect** r = SDL_ListModes(NULL, SDL_OPENGL);
std::cerr << "Video modes";
if(r == (SDL_Rect**)0) {
std::cerr << "No modes available";
return -1;
}
if(r == (SDL_Rect**)-1) {
std::cerr << "All modes available";
} else {
for(int i = 0; r[i]; ++i) {
std::cerr << r[i]->w << r[i]->h << std::endl;
}
}
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,0) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
#else
#if SDL_VERSION_ATLEAST(2, 0, 0)
if(preferences::auto_size_window()) {
const SDL_DisplayMode mode = graphics::set_video_mode_auto_select();
preferences::set_actual_screen_width(mode.w);
preferences::set_actual_screen_height(mode.h);
preferences::set_virtual_screen_width(mode.w);
preferences::set_virtual_screen_height(mode.h);
} else if(!graphics::set_video_mode(preferences::actual_screen_width(), preferences::actual_screen_height())) {
#else
if(SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,SDL_OPENGL|(preferences::resizable() ? SDL_RESIZABLE : 0)|(preferences::fullscreen() ? SDL_FULLSCREEN : 0)) == NULL) {
#endif
std::cerr << "could not set video mode\n";
return -1;
}
#ifndef __APPLE__
graphics::surface wm_icon = graphics::surface_cache::get("window-icon.png");
if(!wm_icon.null()) {
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_SetWindowIcon(graphics::get_window(), wm_icon.get());
#else
SDL_WM_SetIcon(wm_icon, NULL);
#endif
}
#endif // __APPLE__
#endif
#endif
#endif
#endif
#if !SDL_VERSION_ATLEAST(2, 0, 0) && defined(__GLEW_H__)
GLenum glew_status = glewInit();
ASSERT_EQ(glew_status, GLEW_OK);
#endif
#if defined(USE_GLES2)
if(glCreateShader == NULL) {
const GLubyte* glstrings;
if(glGetString != NULL && (glstrings = glGetString(GL_VERSION)) != NULL) {
std::cerr << "OpenGL version: " << reinterpret_cast<const char *>(glstrings) << std::endl;
}
std::cerr << "glCreateShader is NULL. Check that your current video card drivers support "
<< "an OpenGL version >= 2. Exiting." << std::endl;
return 0;
}
// Has to happen after the call to glewInit().
gles2::init_default_shader();
#endif
// srand(time(NULL));
const stats::manager stats_manager;
#ifndef NO_EDITOR
const external_text_editor::manager editor_manager;
#endif // NO_EDITOR
#if defined(USE_BOX2D)
box2d::manager b2d_manager;
#endif
std::cerr << std::endl;
const GLubyte* glstrings;
if((glstrings = glGetString(GL_VENDOR)) != NULL) {
std::cerr << "OpenGL vendor: " << reinterpret_cast<const char *>(glstrings) << std::endl;
} else {
GLenum err = glGetError();
std::cerr << "Error in vendor string: " << std::hex << err << std::endl;
}
if((glstrings = glGetString(GL_VERSION)) != NULL) {
std::cerr << "OpenGL version: " << reinterpret_cast<const char *>(glstrings) << std::endl;
} else {
GLenum err = glGetError();
std::cerr << "Error in version string: " << std::hex << err << std::endl;
}
if((glstrings = glGetString(GL_EXTENSIONS)) != NULL) {
std::cerr << "OpenGL extensions: " << reinterpret_cast<const char *>(glstrings) << std::endl;
} else {
GLenum err = glGetError();
std::cerr << "Error in extensions string: " << std::hex << err << std::endl;
}
#ifdef GL_SHADING_LANGUAGE_VERSION
if((glstrings = glGetString(GL_SHADING_LANGUAGE_VERSION)) != NULL) {
std::cerr << "GLSL Version: " << reinterpret_cast<const char *>(glstrings) << std::endl;
} else {
GLenum err = glGetError();
std::cerr << "Error in GLSL string: " << std::hex << err << std::endl;
}
#endif
std::cerr << std::endl;
GLint stencil_bits = 0;
glGetIntegerv(GL_STENCIL_BITS, &stencil_bits);
std::cerr << "Stencil bits: " << stencil_bits << std::endl;
#if defined(USE_GLES2)
GLfloat min_pt_sz;
glGetFloatv(GL_POINT_SIZE_MIN, &min_pt_sz);
GLfloat max_pt_sz;
glGetFloatv(GL_POINT_SIZE_MAX, &max_pt_sz);
std::cerr << "Point size range: " << min_pt_sz << " < size < " << max_pt_sz << std::endl;
#if !defined(GL_ES_VERSION_2_0)
glEnable(GL_POINT_SPRITE);
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
#endif
#endif
glShadeModel(GL_SMOOTH);
glEnable(GL_BLEND);
#if !defined(USE_GLES2)
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
#endif
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
std::cerr << "JOYSTICKS: " << SDL_NumJoysticks() << "\n";
const load_level_manager load_manager;
{ //manager scope
const font::manager font_manager;
const sound::manager sound_manager;
#if !defined(__native_client__)
const joystick::manager joystick_manager;
#endif
graphics::texture::manager texture_manager;
#ifndef NO_EDITOR
editor::manager editor_manager;
#endif
variant preloads;
loading_screen loader;
try {
sound::init_music(json::parse_from_file("data/music.cfg"));
graphical_font::init_for_locale(i18n::get_locale());
preloads = json::parse_from_file("data/preload.cfg");
int preload_items = preloads["preload"].num_elements();
loader.set_number_of_items(preload_items+7); // 7 is the number of items that will be loaded below
custom_object::init();
loader.draw_and_increment(_("Initializing custom object functions"));
init_custom_object_functions(json::parse_from_file("data/functions.cfg"));
loader.draw_and_increment(_("Initializing textures"));
loader.load(preloads);
loader.draw_and_increment(_("Initializing tiles"));
tile_map::init(json::parse_from_file("data/tiles.cfg"));
loader.draw_and_increment(_("Initializing GUI"));
variant gui_node = json::parse_from_file(preferences::load_compiled() ? "data/compiled/gui.cfg" : "data/gui.cfg");
gui_section::init(gui_node);
loader.draw_and_increment(_("Initializing GUI"));
framed_gui_element::init(gui_node);
preferences::set_edit_and_continue(true);
game_logic::formula_object::load_all_classes();
} catch(const json::parse_error& e) {
std::cerr << "ERROR PARSING: " << e.error_message() << "\n";
return 0;
}
loader.draw(_("Loading level"));
#if defined(__native_client__)
while(1) {
}
#endif
if(!skip_tests && !test::run_tests()) {
return -1;
}
if(unit_tests_only) {
return 0;
}
#if defined(__APPLE__) && !(TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE) && !defined(USE_GLES2)
GLint swapInterval = 1;
CGLSetParameter(CGLGetCurrentContext(), kCGLCPSwapInterval, &swapInterval);
#endif
loader.finish_loading();
//look to see if we got any quit events while loading.
{
SDL_Event event;
while(SDL_PollEvent(&event)) {
if(event.type == SDL_QUIT) {
return 0;
}
}
}
formula_profiler::manager profiler(profile_output);
#ifdef USE_GLES2
texture_frame_buffer::init(preferences::actual_screen_width(), preferences::actual_screen_height());
#else
texture_frame_buffer::init();
#endif
if(run_benchmarks) {
if(benchmarks_list.empty() == false) {
test::run_benchmarks(&benchmarks_list);
} else {
test::run_benchmarks();
}
return 0;
} else if(utility_program.empty() == false && test::utility_needs_video(utility_program) == true) {
test::run_utility(utility_program, util_args);
return 0;
}
bool quit = false;
while(!quit && !show_title_screen(level_cfg)) {
boost::intrusive_ptr<level> lvl(load_level(level_cfg));
#if !defined(__native_client__)
//see if we're loading a multiplayer level, in which case we
//connect to the server.
multiplayer::manager mp_manager(lvl->is_multiplayer());
if(lvl->is_multiplayer()) {
multiplayer::setup_networked_game(server);
}
if(lvl->is_multiplayer()) {
last_draw_position() = screen_position();
std::string level_cfg = "waiting-room.cfg";
boost::intrusive_ptr<level> wait_lvl(load_level(level_cfg));
wait_lvl->finish_loading();
wait_lvl->set_multiplayer_slot(0);
if(wait_lvl->player()) {
wait_lvl->player()->set_current_level(level_cfg);
}
wait_lvl->set_as_current_level();
level_runner runner(wait_lvl, level_cfg, orig_level_cfg);
multiplayer::sync_start_time(*lvl, boost::bind(&level_runner::play_cycle, &runner));
lvl->set_multiplayer_slot(multiplayer::slot());
}
#endif
last_draw_position() = screen_position();
assert(lvl.get());
if(!lvl->music().empty()) {
sound::play_music(lvl->music());
}
if(lvl->player() && level_cfg != "autosave.cfg") {
lvl->player()->set_current_level(level_cfg);
lvl->player()->get_entity().save_game();
}
set_scene_title(lvl->title());
try {
quit = level_runner(lvl, level_cfg, orig_level_cfg).play_level();
level_cfg = orig_level_cfg;
} catch(multiplayer_exception&) {
}
}
level::clear_current_level();
} //end manager scope, make managers destruct before calling SDL_Quit
// controls::debug_dump_controls();
#if defined(TARGET_PANDORA) || defined(TARGET_TEGRA)
EGL_Destroy();
#endif
#if SDL_VERSION_ATLEAST(2, 0, 0)
// Be nice and destroy the GL context and the window.
graphics::set_video_mode(0, 0, CLEANUP_WINDOW_CONTEXT);
#elif defined(USE_GLES2)
wm.destroy_window();
#endif
SDL_Quit();
preferences::save_preferences();
std::cerr << SDL_GetError() << "\n";
#if !defined(TARGET_OS_HARMATTAN) && !defined(TARGET_TEGRA) && !defined(TARGET_BLACKBERRY) && !defined(__ANDROID__) && !defined(USE_GLES2)
std::cerr << gluErrorString(glGetError()) << "\n";
#endif
#if !defined(_MSC_VER) && defined(UTILITY_IN_PROC)
if(create_utility_in_new_process) {
terminate_utility_process();
}
#endif
#ifdef _MSC_VER
ExitProcess(0);
#endif
return 0;
}
extern "C" int main(int argcount, char** argvec)
{
#ifdef NO_STDERR
std::freopen("/dev/null", "w", stderr);
std::cerr.sync_with_stdio(true);
#endif
std::cerr << "Frogatto engine version " << preferences::version() << "\n";
LOG( "After print engine version" );
#if defined(TARGET_BLACKBERRY)
chdir("app/native");
std::cout<< "Changed working directory to: " << getcwd(0, 0) << std::endl;
#endif
std::string level_cfg = "titlescreen.cfg";
bool unit_tests_only = false, skip_tests = false;
bool run_benchmarks = false;
std::vector<std::string> benchmarks_list;
std::string utility_program;
std::vector<std::string> util_args;
std::string server = "wesnoth.org";
const char* profile_output = NULL;
std::string profile_output_buf;
std::string orig_level_cfg = level_cfg;
std::string override_level_cfg = "";
int modules_loaded = 0;
std::vector<std::string> argv;
for(int n = 1; n < argcount; ++n) {
argv.push_back(argvec[n]);
if(argv.size() >= 2 && argv[argv.size()-2] == "-NSDocumentRevisionsDebugMode" && argv.back() == "YES") {
//XCode passes these arguments by default when debugging -- make sure they are ignored.
argv.resize(argv.size()-2);
}
}
if(sys::file_exists("./master-config.cfg")) {
variant cfg = json::parse_from_file("./master-config.cfg");
if(cfg.is_map()) {
if( cfg["id"].is_null() == false) {
preferences::set_preferences_path_from_module(cfg["id"].as_string());
//XXX module::set_module_name(cfg["id"].as_string(), cfg["id"].as_string());
}
if(cfg["arguments"].is_null() == false) {
std::vector<std::string> additional_args = cfg["arguments"].as_list_string();
argv.insert(argv.begin(), additional_args.begin(), additional_args.end());
}
}
}
for(int n = 0; n < argv.size(); ++n) {
const int argc = argv.size();
const std::string arg(argv[n]);
std::string arg_name, arg_value;
std::string::const_iterator equal = std::find(arg.begin(), arg.end(), '=');
if(equal != arg.end()) {
arg_name = std::string(arg.begin(), equal);
arg_value = std::string(equal+1, arg.end());
}
if(arg_name == "--module") {
if(load_module(arg_value, &argv) != 0) {
std::cerr << "FAILED TO LOAD MODULE: " << arg_value << "\n";
return -1;
}
++modules_loaded;
}
}
if(modules_loaded == 0) {
if(load_module(DEFAULT_MODULE, &argv) != 0) {
std::cerr << "FAILED TO LOAD MODULE: " << DEFAULT_MODULE << "\n";
return -1;
}
}
preferences::load_preferences();
LOG( "After load_preferences()" );
// load difficulty settings after module, before rest of args.
difficulty::manager();
for(int n = 0; n < argv.size(); ++n) {
const int argc = argv.size();
const std::string arg(argv[n]);
std::string arg_name, arg_value;
std::string::const_iterator equal = std::find(arg.begin(), arg.end(), '=');
if(equal != arg.end()) {
arg_name = std::string(arg.begin(), equal);
arg_value = std::string(equal+1, arg.end());
}
if(arg_name == "--module") {
// ignore already processed.
} else if(arg_name == "--profile" || arg == "--profile") {
profile_output_buf = arg_value;
profile_output = profile_output_buf.c_str();
} else if(arg_name == "--utility") {
utility_program = arg_value;
for(++n; n < argc; ++n) {
const std::string arg(argv[n]);
util_args.push_back(arg);
}
break;
} else if(arg == "--benchmarks") {
run_benchmarks = true;
} else if(arg_name == "--benchmarks") {
run_benchmarks = true;
benchmarks_list = util::split(arg_value);
} else if(arg == "--tests") {
unit_tests_only = true;
} else if(arg == "--no-tests") {
skip_tests = true;
} else if(arg == "--width" && n+1 < argc) {
std::string w(argv[++n]);
preferences::set_actual_screen_width(boost::lexical_cast<int>(w));
} else if(arg == "--height" && n+1 < argc) {
std::string h(argv[++n]);
preferences::set_actual_screen_height(boost::lexical_cast<int>(h));
} else if(arg == "--level" && n+1 < argc) {
override_level_cfg = argv[++n];
} else if(arg == "--host" && n+1 < argc) {
server = argv[++n];
} else if(arg == "--compiled") {
preferences::set_load_compiled(true);
#ifndef NO_EDITOR
} else if(arg == "--edit") {
preferences::set_edit_on_start(true);
#endif
} else if(arg == "--no-compiled") {
preferences::set_load_compiled(false);
#if defined(TARGET_PANDORA)
} else if(arg == "--no-fbo") {
preferences::set_fbo(false);
} else if(arg == "--no-bequ") {
preferences::set_bequ(false);
#endif
} else if(arg == "--help" || arg == "-h") {
print_help(std::string(argvec[0]));
return 0;
} else {
const bool res = preferences::parse_arg(argv[n].c_str());
if(!res) {
std::cerr << "unrecognized arg: '" << arg << "'\n";
return -1;
}
}
}
checksum::manager checksum_manager;
preferences::expand_data_paths();
LOG( "After expand_data_paths()" );
std::cerr << "Preferences dir: " << preferences::user_data_path() << '\n';
//make sure that the user data path exists.
if(!preferences::setup_preferences_dir()) {
std::cerr << "cannot create preferences dir!\n";
}
std::cerr << "\n";
if(utility_program.empty() == false && test::utility_needs_video(utility_program) == false) {
test::run_utility(utility_program, util_args);
return 0;
}
#if defined(TARGET_PANDORA)
EGL_Open();
#endif
#if defined(__ANDROID__)
std::freopen("stdout.txt","w",stdout);
std::freopen("stderr.txt","w",stderr);
std::cerr.sync_with_stdio(true);
#endif
LOG( "Start of main" );
Uint32 sdl_init_flags = SDL_INIT_VIDEO | SDL_INIT_JOYSTICK;
#ifdef _WINDOWS
sdl_init_flags |= SDL_INIT_TIMER;
#endif
if(SDL_Init(sdl_init_flags) < 0) {
std::cerr << "could not init SDL\n";
return -1;
}
LOG( "After SDL_Init" );
#ifdef TARGET_OS_HARMATTAN
g_type_init();
#endif
i18n::init ();
LOG( "After i18n::init()" );
// SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 1);
#if defined(TARGET_OS_IPHONE) || defined(TARGET_BLACKBERRY) || defined(__ANDROID__)
//on the iPhone and PlayBook, try to restore the auto-save if it exists
if(sys::file_exists(preferences::auto_save_file_path()) && sys::read_file(std::string(preferences::auto_save_file_path()) + ".stat") == "1") {
level_cfg = "autosave.cfg";
sys::write_file(std::string(preferences::auto_save_file_path()) + ".stat", "0");
}
#endif
if(override_level_cfg.empty() != true) {
level_cfg = override_level_cfg;
orig_level_cfg = level_cfg;
}
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
int width, height;
iphone_screen_res(&width, &height);
preferences::set_actual_screen_width(width);
preferences::set_actual_screen_height(height);
int multiplier = 2;
if (width > 320)
{
//preferences::set_use_pretty_scaling(true);
multiplier = 1;
}
preferences::set_virtual_screen_width(height*multiplier);
preferences::set_virtual_screen_height(width*multiplier);
preferences::set_control_scheme(height % 1024 ? "iphone_2d" : "ipad_2d");
SDL_WindowID windowID = SDL_CreateWindow (NULL, 0, 0, preferences::actual_screen_width(), preferences::actual_screen_height(),
SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN |
SDL_WINDOW_BORDERLESS);
if (windowID == 0) {
std::cerr << "Could not create window: " << SDL_GetError() << "\n";
return -1;
}
// if (SDL_GL_CreateContext(windowID) == 0) {
// std::cerr << "Could not create GL context: " << SDL_GetError() << "\n";
// return -1;
// }
if (SDL_CreateRenderer(windowID, -1, 0) != 0) {
std::cerr << "Could not create renderer\n";
return -1;
}
#else
#ifdef TARGET_OS_HARMATTAN
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,SDL_OPENGLES | SDL_FULLSCREEN) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
preferences::init_oes();
SDL_ShowCursor(0);
#else
#ifndef __APPLE__
graphics::surface wm_icon = graphics::surface_cache::get("window-icon.png");
if(!wm_icon.null()) {
SDL_WM_SetIcon(wm_icon, NULL);
}
#endif
#if defined(TARGET_PANDORA)
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),16,SDL_FULLSCREEN) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
EGL_Init();
preferences::init_oes();
#elif defined(TARGET_TEGRA)
//if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,preferences::resizable() ? SDL_RESIZABLE : 0|preferences::fullscreen() ? SDL_FULLSCREEN : 0) == NULL) {
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,SDL_FULLSCREEN) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
EGL_Init();
preferences::init_oes();
#elif defined(TARGET_BLACKBERRY)
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,SDL_OPENGL|SDL_FULLSCREEN) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
preferences::init_oes();
#elif defined(__ANDROID__)
SDL_Rect** r = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_OPENGL);
if( r != (SDL_Rect**)0 && r != (SDL_Rect**)-1 ) {
preferences::set_actual_screen_width(r[0]->w);
preferences::set_actual_screen_height(r[0]->h);
if(r[0]->w < 640) {
preferences::set_virtual_screen_width(r[0]->w*2);
preferences::set_virtual_screen_height(r[0]->h*2);
} else {
preferences::set_virtual_screen_width(r[0]->w);
preferences::set_virtual_screen_height(r[0]->h);
}
preferences::set_control_scheme(r[0]->h >= 1024 ? "ipad_2d" : "android_med");
}
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),16,SDL_FULLSCREEN|SDL_OPENGL) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
#else
if (SDL_SetVideoMode(preferences::actual_screen_width(),preferences::actual_screen_height(),0,SDL_OPENGL|(preferences::resizable() ? SDL_RESIZABLE : 0)|(preferences::fullscreen() ? SDL_FULLSCREEN : 0)) == NULL) {
std::cerr << "could not set video mode\n";
return -1;
}
#endif
#endif
#endif
// srand(time(NULL));
const stats::manager stats_manager;
#ifndef NO_EDITOR
const external_text_editor::manager editor_manager;
#endif // NO_EDITOR
std::cerr
<< "\n"
<< "OpenGL vendor: " << reinterpret_cast<const char *>(glGetString(GL_VENDOR)) << "\n"
<< "OpenGL version: " << reinterpret_cast<const char *>(glGetString(GL_VERSION)) << "\n"
<< "OpenGL extensions: " << reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)) << "\n"
<< "\n";
glShadeModel(GL_SMOOTH);
glEnable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
SDL_WM_SetCaption(module::get_module_pretty_name().c_str(), module::get_module_pretty_name().c_str());
std::cerr << "JOYSTICKS: " << SDL_NumJoysticks() << "\n";
const load_level_manager load_manager;
{ //manager scope
const font::manager font_manager;
const sound::manager sound_manager;
const joystick::manager joystick_manager;
#if !TARGET_OS_IPHONE && !TARGET_IPHONE_SIMULATOR
const SDL_Surface* fb = SDL_GetVideoSurface();
if(fb == NULL) {
return 0;
}
#endif
graphics::texture::manager texture_manager;
#ifndef NO_EDITOR
editor::manager editor_manager;
#endif
variant preloads;
loading_screen loader;
try {
sound::init_music(json::parse_from_file(module::map_file("data/music.cfg")));
std::string filename = "data/fonts." + i18n::get_locale() + ".cfg";
if (!sys::file_exists(filename))
filename = "data/fonts.cfg";
graphical_font::init(json::parse_from_file(module::map_file(filename)));
preloads = json::parse_from_file(module::map_file("data/preload.cfg"));
int preload_items = preloads["preload"].num_elements();
loader.set_number_of_items(preload_items+7); // 7 is the number of items that will be loaded below
custom_object::init();
loader.draw_and_increment(_("Initializing custom object functions"));
init_custom_object_functions(json::parse_from_file(module::map_file("data/functions.cfg")));
loader.draw_and_increment(_("Initializing textures"));
loader.load(preloads);
loader.draw_and_increment(_("Initializing tiles"));
tile_map::init(json::parse_from_file(module::map_file("data/tiles.cfg")));
loader.draw_and_increment(_("Initializing GUI"));
variant gui_node = json::parse_from_file(module::map_file(preferences::load_compiled() ? "data/compiled/gui.cfg" : "data/gui.cfg"));
gui_section::init(gui_node);
loader.draw_and_increment(_("Initializing GUI"));
framed_gui_element::init(gui_node);
} catch(const json::parse_error& e) {
std::cerr << "ERROR PARSING: " << e.error_message() << "\n";
return 0;
}
loader.draw(_("Loading level"));
if(!skip_tests && !test::run_tests()) {
return -1;
}
if(unit_tests_only) {
return 0;
}
#if defined(__APPLE__) && !(TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE)
GLint swapInterval = 1;
CGLSetParameter(CGLGetCurrentContext(), kCGLCPSwapInterval, &swapInterval);
#endif
#ifndef SDL_VIDEO_OPENGL_ES
GLenum glew_status = glewInit();
ASSERT_EQ(glew_status, GLEW_OK);
#endif
loader.finish_loading();
//look to see if we got any quit events while loading.
{
SDL_Event event;
while(SDL_PollEvent(&event)) {
if(event.type == SDL_QUIT) {
return 0;
}
}
}
formula_profiler::manager profiler(profile_output);
texture_frame_buffer::init();
if(run_benchmarks) {
if(benchmarks_list.empty() == false) {
test::run_benchmarks(&benchmarks_list);
} else {
test::run_benchmarks();
}
return 0;
} else if(utility_program.empty() == false) {
test::run_utility(utility_program, util_args);
return 0;
}
bool quit = false;
bool of_initialized = false;
while(!quit && !show_title_screen(level_cfg)) {
boost::intrusive_ptr<level> lvl(load_level(level_cfg));
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
if (!of_initialized)
{
of_init();
of_initialized = true;
}
#endif
//see if we're loading a multiplayer level, in which case we
//connect to the server.
multiplayer::manager mp_manager(lvl->is_multiplayer());
if(lvl->is_multiplayer()) {
multiplayer::setup_networked_game(server);
}
if(lvl->is_multiplayer()) {
last_draw_position() = screen_position();
std::string level_cfg = "waiting-room.cfg";
boost::intrusive_ptr<level> wait_lvl(load_level(level_cfg));
wait_lvl->finish_loading();
wait_lvl->set_multiplayer_slot(0);
if(wait_lvl->player()) {
wait_lvl->player()->set_current_level(level_cfg);
}
wait_lvl->set_as_current_level();
level_runner runner(wait_lvl, level_cfg, orig_level_cfg);
multiplayer::sync_start_time(*lvl, boost::bind(&level_runner::play_cycle, &runner));
lvl->set_multiplayer_slot(multiplayer::slot());
}
last_draw_position() = screen_position();
assert(lvl.get());
if(!lvl->music().empty()) {
sound::play_music(lvl->music());
}
if(lvl->player() && level_cfg != "autosave.cfg") {
lvl->player()->set_current_level(level_cfg);
lvl->player()->get_entity().save_game();
}
set_scene_title(lvl->title());
try {
quit = level_runner(lvl, level_cfg, orig_level_cfg).play_level();
level_cfg = orig_level_cfg;
} catch(multiplayer_exception&) {
}
}
level::clear_current_level();
} //end manager scope, make managers destruct before calling SDL_Quit
// controls::debug_dump_controls();
#if defined(TARGET_PANDORA) || defined(TARGET_TEGRA)
EGL_Destroy();
#endif
SDL_Quit();
preferences::save_preferences();
std::cerr << SDL_GetError() << "\n";
#if !defined(TARGET_OS_HARMATTAN) && !defined(TARGET_TEGRA) && !defined(TARGET_BLACKBERRY) && !defined(__ANDROID__)
std::cerr << gluErrorString(glGetError()) << "\n";
#endif
return 0;
}
