miguel.horta/commandergenius
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
62fd0b2dd698099a4123e7b6fd0a5924ae7e5fcc
commandergenius/project/jni/application/vcmi/vcmi-android.diff

1163 lines
36 KiB
Diff
Raw Blame History

Index: server/stdafx.h
===================================================================
--- server/stdafx.h (revision 2183)
+++ server/stdafx.h (working copy)
@@ -15,8 +15,8 @@
#include "../global.h"
#include <boost/crc.hpp>
-#include <boost/interprocess/mapped_region.hpp>
-#include <boost/interprocess/shared_memory_object.hpp>
+//#include <boost/interprocess/mapped_region.hpp>
+//#include <boost/interprocess/shared_memory_object.hpp>
#include <iostream>
#include <string>
#include <boost/asio.hpp>
Index: server/CVCMIServer.cpp
===================================================================
--- server/CVCMIServer.cpp (revision 2183)
+++ server/CVCMIServer.cpp (working copy)
@@ -29,7 +29,7 @@
using namespace boost;
using namespace boost::asio;
using namespace boost::asio::ip;
-namespace intpr = boost::interprocess;
+//namespace intpr = boost::interprocess;
bool end2 = false;
int port = 3030;
VCMIDirs GVCMIDirs;
@@ -379,6 +379,7 @@
void CVCMIServer::start()
{
+ /*
ServerReady *sr = NULL;
intpr::mapped_region *mr;
try
@@ -395,13 +396,17 @@
mr = new intpr::mapped_region(smo,intpr::read_write);
sr = new(mr->get_address())ServerReady();
}
+ */
+ notifyServerReady();
boost::system::error_code error;
tlog0<<"Listening for connections at port " << acceptor->local_endpoint().port() << std::endl;
tcp::socket * s = new tcp::socket(acceptor->io_service());
boost::thread acc(boost::bind(vaccept,acceptor,s,&error));
+ /*
sr->setToTrueAndNotify();
delete mr;
+ */
acc.join();
if (error)
Index: lib/CLodHandler.cpp
===================================================================
--- lib/CLodHandler.cpp (revision 2183)
+++ lib/CLodHandler.cpp (working copy)
@@ -60,6 +60,9 @@
return ret;
}
+int CLodHandler::dbgLastFileSize = 0;
+std::string CLodHandler::dbgLastFileName;
+
unsigned char * CLodHandler::giveFile(const std::string defName, LodFileType type, int * length)
{
std::string fname = defName;
@@ -78,13 +81,15 @@
Entry ourEntry = *en_it;
if(length) *length = ourEntry.realSize;
+ enum { SAFETY_MARGIN = 4096 }; // VCMI functions tend to read past the array end, crashing at random
mutex->lock();
unsigned char * outp;
if (ourEntry.offset<0) //file is in the sprites/ folder; no compression
{
int result;
- outp = new unsigned char[ourEntry.realSize];
+ outp = new unsigned char[ourEntry.realSize+SAFETY_MARGIN];
+ memset(outp+ourEntry.realSize, 0, SAFETY_MARGIN);
FILE * f = fopen((myDir + "/" + ourEntry.realName).c_str(), "rb");
if (f)
{
@@ -100,16 +105,25 @@
delete[] outp;
return NULL;
}
- else
+ else
+ {
+ dbgLastFileSize = ourEntry.realSize;
+ dbgLastFileName = defName;
+ //tlog0 << "Loaded file: " << fname << " size " << ourEntry.realSize << " ptr " << (void *)outp << " safety " << (int)SAFETY_MARGIN << std::endl;
return outp;
+ }
}
else if (ourEntry.size==0) //file is not compressed
{
- outp = new unsigned char[ourEntry.realSize];
+ outp = new unsigned char[ourEntry.realSize+SAFETY_MARGIN];
+ memset(outp+ourEntry.realSize, 0, SAFETY_MARGIN);
LOD.seekg(ourEntry.offset, std::ios::beg);
LOD.read((char*)outp, ourEntry.realSize);
mutex->unlock();
+ dbgLastFileSize = ourEntry.realSize;
+ dbgLastFileName = defName;
+ //tlog0 << "Loaded file: " << fname << " size " << ourEntry.realSize << " ptr " << (void *)outp << " safety " << (int)SAFETY_MARGIN << std::endl;
return outp;
}
else //we will decompress file
@@ -122,7 +136,14 @@
infs2(outp, ourEntry.size, ourEntry.realSize, decomp);
mutex->unlock();
delete[] outp;
- return decomp;
+ outp = new unsigned char[ourEntry.realSize+SAFETY_MARGIN];
+ memset(outp+ourEntry.realSize, 0, SAFETY_MARGIN);
+ memcpy(outp, decomp, ourEntry.realSize);
+ delete [] decomp;
+ dbgLastFileSize = ourEntry.realSize;
+ dbgLastFileName = defName;
+ //tlog0 << "Loaded file: " << fname << " size " << ourEntry.realSize << " ptr " << (void *)outp << " safety " << (int)SAFETY_MARGIN << std::endl;
+ return outp;
}
return NULL;
}
Index: lib/Interprocess.h
===================================================================
--- lib/Interprocess.h (revision 2183)
+++ lib/Interprocess.h (working copy)
@@ -1,3 +1,4 @@
+/*
#include <boost/interprocess/sync/interprocess_mutex.hpp>
#include <boost/interprocess/sync/interprocess_condition.hpp>
#include <boost/interprocess/mapped_region.hpp>
@@ -2,2 +3,3 @@
#include <boost/interprocess/shared_memory_object.hpp>
+*/
@@ -13,6 +15,7 @@
*
*/
+/*
struct ServerReady
{
bool ready;
@@ -51,4 +54,48 @@
delete mr;
boost::interprocess::shared_memory_object::remove("vcmi_memory");
}
-};
\ No newline at end of file
+};
+*/
+
+#include <stdio.h>
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+#include "VCMIDirs.h"
+
+#define SERVER_READY_FILENAME "/VcmiServerReadyFlag.lock"
+
+void clearServerReady()
+{
+ unlink((GVCMIDirs.UserPath + SERVER_READY_FILENAME).c_str());
+}
+
+void waitServerReady()
+{
+ while(true)
+ {
+ FILE * ff = fopen((GVCMIDirs.UserPath + SERVER_READY_FILENAME).c_str(), "r");
+ if(ff)
+ {
+ fclose(ff);
+ clearServerReady();
+ break;
+ }
+#ifdef WIN32
+ Sleep(200);
+#else
+ usleep(200000);
+#endif
+ }
+}
+
+void notifyServerReady()
+{
+ FILE * ff = fopen((GVCMIDirs.UserPath + SERVER_READY_FILENAME).c_str(), "w");
+ if(!ff)
+ return;
+ fwrite("1", 1, 1, ff);
+ fclose(ff);
+}
Index: lib/Connection.h
===================================================================
--- lib/Connection.h (revision 2183)
+++ lib/Connection.h (working copy)
@@ -82,7 +82,9 @@
{
bool operator()(const std::type_info *a, const std::type_info *b) const
{
- return a->before(*b);
+ // Comparing pointers is bad bad practice, because type_info pointers to the same types
+ // are different inside shared library and the executable that links to that library
+ return strcmp(a->name(), b->name()) > 0;
}
};
Index: lib/CLodHandler.h
===================================================================
--- lib/CLodHandler.h (revision 2183)
+++ lib/CLodHandler.h (working copy)
@@ -116,6 +116,8 @@
void extractFile(const std::string FName, const std::string name); //extracts a specific file
static unsigned char * getUnpackedFile(const std::string & path, int * sizeOut); //loads given file, decompresses and returns
+ static int dbgLastFileSize;
+ static std::string dbgLastFileName;
};
Index: CConsoleHandler.cpp
===================================================================
--- CConsoleHandler.cpp (revision 2183)
+++ CConsoleHandler.cpp (working copy)
@@ -143,6 +143,7 @@
void CConsoleHandler::setColor(int level)
{
+#ifndef ANDROID
TColor color;
switch(level)
{
@@ -179,6 +180,7 @@
#else
std::cout << color;
#endif
+#endif
}
int CConsoleHandler::run()
Index: global.h
===================================================================
--- global.h (revision 2183)
+++ global.h (working copy)
@@ -4,6 +4,7 @@
#include <iostream>
#include <sstream>
#include <algorithm> //std::find
+#include <string.h> //memcpy
#include <string> //std::find
#include <boost/logic/tribool.hpp>
#include <boost/unordered_set.hpp>
@@ -727,29 +728,21 @@
}
-#if defined(linux) && defined(sparc)
-/* SPARC does not support unaligned memory access. Let gcc know when
- * to emit the right code. */
-struct unaligned_Uint16 { ui16 val __attribute__(( packed )); };
-struct unaligned_Uint32 { ui32 val __attribute__(( packed )); };
static inline ui16 read_unaligned_u16(const void *p)
{
- const struct unaligned_Uint16 *v = (const struct unaligned_Uint16 *)p;
- return v->val;
+ ui16 out;
+ memcpy(&out, p, sizeof(out));
+ return out;
}
static inline ui32 read_unaligned_u32(const void *p)
{
- const struct unaligned_Uint32 *v = (const struct unaligned_Uint32 *)p;
- return v->val;
+ ui32 out;
+ memcpy(&out, p, sizeof(out));
+ return out;
}
-#else
-#define read_unaligned_u16(p) (* reinterpret_cast<const Uint16 *>(p))
-#define read_unaligned_u32(p) (* reinterpret_cast<const Uint32 *>(p))
-#endif
-
//for explicit overrides
#ifdef _MSC_VER
#define OVERRIDE override
Index: CThreadHelper.cpp
===================================================================
--- CThreadHelper.cpp (revision 2183)
+++ CThreadHelper.cpp (working copy)
@@ -24,10 +24,16 @@
}
void CThreadHelper::run()
{
+#ifdef ANDROID
+ // For debug make it single-threaded
+ for(int i=0;i<tasks->size();i++)
+ (*tasks)[i]();
+#else
boost::thread_group grupa;
for(int i=0;i<threads;i++)
grupa.create_thread(boost::bind(&CThreadHelper::processTasks,this));
grupa.join_all();
+#endif
}
void CThreadHelper::processTasks()
{
Index: client/Graphics.cpp
===================================================================
--- client/Graphics.cpp (revision 2183)
+++ client/Graphics.cpp (working copy)
@@ -321,6 +321,7 @@
tasks += GET_DEF_ESS(abils82,"SECSK82.DEF");
tasks += GET_DEF_ESS(spellscr,"SPELLSCR.DEF");
tasks += GET_DEF_ESS(heroMoveArrows,"ADAG.DEF");
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
std::ifstream ifs(DATA_DIR "/config/cr_bgs.txt");
int id;
@@ -331,15 +332,21 @@
tasks += GET_SURFACE(backgrounds[id],name);
name.replace(0,5,"TPCAS");
tasks += GET_SURFACE(backgroundsm[id],name);
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
}
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
CThreadHelper th(&tasks,std::max((unsigned int)1,boost::thread::hardware_concurrency()));
th.run();
+
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ << " heroMoveArrows " << heroMoveArrows <<std::endl;
for(size_t y=0; y < heroMoveArrows->ourImages.size(); ++y)
{
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ << " heroMoveArrows " << y << "/" << heroMoveArrows->ourImages.size() <<std::endl;
CSDL_Ext::alphaTransform(heroMoveArrows->ourImages[y].bitmap);
}
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
//handling 32x32px imgs
smi->notFreeImgs = true;
@@ -354,9 +361,11 @@
bigImgs[i-2] = smi2->ourImages[i].bitmap;
}
delete smi2;
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
}
void Graphics::loadHeroPortraits()
{
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
std::ifstream of(DATA_DIR "/config/portrety.txt");
int numberOfPortraits;
of>>numberOfPortraits;
@@ -384,6 +393,7 @@
void Graphics::loadWallPositions()
{
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
std::ifstream inp;
inp.open(DATA_DIR "/config/wall_pos.txt", std::ios_base::in|std::ios_base::binary);
if(!inp.is_open())
@@ -417,24 +427,32 @@
void Graphics::loadHeroAnims()
{
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
std::vector<std::pair<int,int> > rotations; //first - group number to be rotated1, second - group number after rotation1
rotations += std::make_pair(6,10), std::make_pair(7,11), std::make_pair(8,12), std::make_pair(1,13),
std::make_pair(2,14), std::make_pair(3,15);
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
for(size_t i=0; i<F_NUMBER * 2; ++i)
{
std::ostringstream nm;
nm << "AH" << std::setw(2) << std::setfill('0') << i << "_.DEF";
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
loadHeroAnim(nm.str(), rotations, &Graphics::heroAnims);
std::string name = nm.str();
}
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
loadHeroAnim("AB01_.DEF", rotations, &Graphics::boatAnims);
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
loadHeroAnim("AB02_.DEF", rotations, &Graphics::boatAnims);
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
loadHeroAnim("AB03_.DEF", rotations, &Graphics::boatAnims);
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
}
void Graphics::loadHeroAnim( const std::string &name, const std::vector<std::pair<int,int> > &rotations, std::vector<CDefEssential *> Graphics::*dst )
{
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ << " load " << name <<std::endl;
CDefEssential *anim = CDefHandler::giveDefEss(name);
(this->*dst).push_back(anim);
int pom = 0; //how many groups has been rotated
@@ -472,12 +490,15 @@
void Graphics::loadHeroFlags(std::pair<std::vector<CDefEssential *> Graphics::*, std::vector<const char *> > &pr, bool mode)
{
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
for(int i=0;i<8;i++)
(this->*pr.first).push_back(CDefHandler::giveDefEss(pr.second[i]));
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
std::vector<std::pair<int,int> > rotations; //first - group number to be rotated1, second - group number after rotation1
rotations += std::make_pair(6,10), std::make_pair(7,11), std::make_pair(8,12);
for(int q=0; q<8; ++q)
{
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
std::vector<Cimage> &curImgs = (this->*pr.first)[q]->ourImages;
for(size_t o=0; o<curImgs.size(); ++o)
{
@@ -515,6 +536,7 @@
}
}
}
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
for(size_t ff=0; ff<curImgs.size(); ++ff)
{
SDL_SetColorKey(curImgs[ff].bitmap, SDL_SRCCOLORKEY,
@@ -522,31 +544,44 @@
);
}
}
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
}
void Graphics::loadHeroFlags()
{
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
using namespace boost::assign;
timeHandler th;
std::pair<std::vector<CDefEssential *> Graphics::*, std::vector<const char *> > pr[4];
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
pr[0].first = &Graphics::flags1;
pr[0].second+=("ABF01L.DEF"),("ABF01G.DEF"),("ABF01R.DEF"),("ABF01D.DEF"),("ABF01B.DEF"),
("ABF01P.DEF"),("ABF01W.DEF"),("ABF01K.DEF");
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
pr[1].first = &Graphics::flags2;
pr[1].second+=("ABF02L.DEF"),("ABF02G.DEF"),("ABF02R.DEF"),("ABF02D.DEF"),("ABF02B.DEF"),
("ABF02P.DEF"),("ABF02W.DEF"),("ABF02K.DEF");
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
pr[2].first = &Graphics::flags3;
pr[2].second+=("ABF03L.DEF"),("ABF03G.DEF"),("ABF03R.DEF"),("ABF03D.DEF"),("ABF03B.DEF"),
("ABF03P.DEF"),("ABF03W.DEF"),("ABF03K.DEF");
pr[3].first = &Graphics::flags4;
pr[3].second+=("AF00.DEF"),("AF01.DEF"),("AF02.DEF"),("AF03.DEF"),("AF04.DEF"),
("AF05.DEF"),("AF06.DEF"),("AF07.DEF");
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
+#ifdef ANDROID
+ for(int g=0; g<4; g++)
+ {
+ loadHeroFlags(pr[g],true);
+ }
+#else
boost::thread_group grupa;
for(int g=3; g>=0; --g)
{
grupa.create_thread(boost::bind(&Graphics::loadHeroFlags,this,boost::ref(pr[g]),true));
}
grupa.join_all();
+#endif
tlog0 << "Loading and transforming heroes' flags: "<<th.getDif()<<std::endl;
}
SDL_Surface * Graphics::getPic(int ID, bool fort, bool builded)
@@ -669,6 +704,7 @@
void Graphics::loadTrueType()
{
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
bool ttfPresent = false;//was TTF initialised or not
for(int i = 0; i < FONTS_NUMBER; i++)
fontsTrueType[i] = NULL;
@@ -702,6 +738,7 @@
Font * Graphics::loadFont( const char * name )
{
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
int len = 0;
unsigned char * hlp = bitmaph->giveFile(name, FILE_FONT, &len);
if(!hlp || !len)
@@ -725,6 +762,7 @@
void Graphics::loadFonts()
{
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
static const char *fontnames [] = {"BIGFONT.FNT", "CALLI10R.FNT", "CREDITS.FNT", "HISCORE.FNT", "MEDFONT.FNT",
"SMALFONT.FNT", "TIMES08R.FNT", "TINY.FNT", "VERD10B.FNT"} ;
@@ -745,6 +783,7 @@
void Graphics::loadErmuToPicture()
{
+ tlog0<<__FUNCTION__ << " at " << __FILE__ << ":" << __LINE__ <<std::endl;
//loading ERMU to picture
std::ifstream etp(DATA_DIR "/config/ERMU_to_picture.txt");
Index: client/Client.cpp
===================================================================
--- client/Client.cpp (revision 2183)
+++ client/Client.cpp (working copy)
@@ -39,7 +39,7 @@
#include "../lib/RegisterTypes.cpp"
extern std::string NAME;
-namespace intpr = boost::interprocess;
+//namespace intpr = boost::interprocess;
/*
* Client.cpp, part of VCMI engine
@@ -498,9 +498,9 @@
void CClient::handlePack( CPack * pack )
{
- CBaseForCLApply *apply = applier->apps[typeList.getTypeID(pack)]; //find the applier
- if(apply)
+ if(applier->apps.find(typeList.getTypeID(pack)) != applier->apps.end())
{
+ CBaseForCLApply *apply = applier->apps[typeList.getTypeID(pack)]; //find the applier
apply->applyOnClBefore(this,pack);
tlog5 << "\tMade first apply on cl\n";
gs->apply(pack);
@@ -628,18 +628,22 @@
startServer();
th.update();
+ /*
intpr::scoped_lock<intpr::interprocess_mutex> slock(shared->sr->mutex);
while(!shared->sr->ready)
{
shared->sr->cond.wait(slock);
}
+ */
+ tlog0 << "Waiting for server..." << std::endl;
+ waitServerReady();
if(verbose)
tlog0 << "Waiting for server: " << th.getDif() << std::endl;
}
CConnection * CServerHandler::connectToServer()
{
- if(!shared->sr->ready)
+ if(!serverThread)
waitForServer();
th.update();
@@ -654,27 +658,31 @@
CServerHandler::CServerHandler(bool runServer /*= false*/)
{
serverThread = NULL;
- shared = NULL;
+ //shared = NULL;
port = boost::lexical_cast<std::string>(conf.cc.port);
verbose = false;
+ /*
boost::interprocess::shared_memory_object::remove("vcmi_memory"); //if the application has previously crashed, the memory may not have been removed. to avoid problems - try to destroy it
try
{
shared = new SharedMem();
} HANDLE_EXCEPTIONC(tlog1 << "Cannot open interprocess memory: ";)
+ */
}
CServerHandler::~CServerHandler()
{
- delete shared;
+ //delete shared;
delete serverThread; //detaches, not kills thread
}
void CServerHandler::callServer()
{
+ clearServerReady();
setThreadName(-1, "CServerHandler::callServer");
std::string comm = std::string(BIN_DIR PATH_SEPARATOR SERVER_NAME " ") + port + " > server_log.txt";
+ tlog0 << "Invoking VCMI server : " << comm << std::endl;
std::system(comm.c_str());
tlog0 << "Server finished\n";
}
Index: client/GUIBase.cpp
===================================================================
--- client/GUIBase.cpp (revision 2183)
+++ client/GUIBase.cpp (working copy)
@@ -11,6 +11,7 @@
#include "../CThreadHelper.h"
#include "CConfigHandler.h"
#include <boost/lexical_cast.hpp>
+
/*
* GUIBase.cpp, part of VCMI engine
@@ -364,6 +365,26 @@
}
} HANDLE_EXCEPTION
}
+
+void CGuiHandler::loopInitFromMainThread()
+{
+ setThreadName(-1, "CGuiHandler::run");
+ CCS->curh->centerCursor();
+ mainFPSmng->init(); // resets internal clock, needed for FPS manager
+}
+
+bool CGuiHandler::loopFromMainThread()
+{
+ if(terminate)
+ return false;
+ if(curInt)
+ curInt->update(); // calls a update and drawing process of the loaded game interface object at the moment
+
+ mainFPSmng->framerateDelay(); // holds a constant FPS
+ return true;
+}
+
+
CGuiHandler::CGuiHandler()
:lastClick(-500, -500)
Index: client/CDefHandler.h
===================================================================
--- client/CDefHandler.h (revision 2183)
+++ client/CDefHandler.h (working copy)
@@ -30,7 +30,6 @@
ui32 totalInBlock;
ui32 unknown2;
ui32 unknown3;
- unsigned char data[0];
};
// Def entry in file. Integer fields are all little endian and will
Index: client/Client.h
===================================================================
--- client/Client.h (revision 2183)
+++ client/Client.h (working copy)
@@ -43,7 +43,7 @@
public:
timeHandler th;
boost::thread *serverThread; //thread that called system to run server
- SharedMem *shared; //interprocess memory (for waiting for server)
+ //SharedMem *shared; //interprocess memory (for waiting for server)
bool verbose; //whether to print log msgs
std::string port; //port number in text form
Index: client/CMT.cpp
===================================================================
--- client/CMT.cpp (revision 2183)
+++ client/CMT.cpp (working copy)
@@ -92,8 +92,10 @@
void dispose();
void playIntro();
static void listenForEvents();
+static bool loopListenForEvents(bool block);
void requestChangingResolution();
void startGame(StartInfo * options, CConnection *serv = NULL);
+
#ifndef _WIN32
#ifndef _GNU_SOURCE
@@ -128,6 +130,7 @@
GDefaultOptions.settingsChanged();
}
}
+
THC tlog0<<"\tLoading default system settings: "<<pomtime.getDif()<<std::endl;
//initializing audio
@@ -137,10 +140,12 @@
CCS->soundh->init();
CCS->soundh->setVolume(GDefaultOptions.soundVolume);
CCS->musich = new CMusicHandler;
+
//CGI->musich->init();
//CGI->musich->setVolume(GDefaultOptions.musicVolume);
tlog0<<"\tInitializing sound: "<<pomtime.getDif()<<std::endl;
tlog0<<"Initializing screen and sound handling: "<<tmh.getDif()<<std::endl;
+
initDLL(::console,logfile);
const_cast<CGameInfo*>(CGI)->setFromLib();
@@ -154,7 +159,9 @@
CCS->curh->show();
tlog0<<"Screen handler: "<<pomtime.getDif()<<std::endl;
pomtime.getDif();
+ tlog0<<"Megadebug 1"<<std::endl;
graphics = new Graphics();
+ tlog0<<"Megadebug 2"<<std::endl;
graphics->loadHeroAnims();
tlog0<<"\tMain graphics: "<<tmh.getDif()<<std::endl;
tlog0<<"Initializing game graphics: "<<tmh.getDif()<<std::endl;
@@ -186,11 +193,15 @@
}
+#ifdef ANDROID
+int SDL_main(int argc, char** argv)
+#else
#ifdef _WIN32
int _tmain(int argc, _TCHAR* argv[])
#else
int main(int argc, char** argv)
#endif
+#endif
{
tlog0 << "Starting... " << std::endl;
po::options_description opts("Allowed options");
@@ -237,7 +248,6 @@
console->start();
atexit(dispose);
tlog0 <<"Creating console and logfile: "<<pomtime.getDif() << std::endl;
-
conf.init();
tlog0 <<"Loading settings: "<<pomtime.getDif() << std::endl;
tlog0 << NAME << std::endl;
@@ -262,6 +272,11 @@
tlog0<<"\tInitializing video: "<<pomtime.getDif()<<std::endl;
//we can properly play intro only in the main thread, so we have to move loading to the separate thread
+#if defined(ANDROID) || defined(LINUX)
+ init();
+ if(!vm.count("battle") && !vm.count("nointro"))
+ playIntro();
+#else
boost::thread loading(init);
if(!vm.count("battle") && !vm.count("nointro"))
@@ -270,6 +285,7 @@
SDL_FillRect(screen,NULL,0);
CSDL_Ext::update(screen);
loading.join();
+#endif
tlog0<<"Initialization of VCMI (together): "<<total.getDif()<<std::endl;
if(!vm.count("battle"))
@@ -286,8 +302,17 @@
si->playerInfos[1].color = 1;
startGame(si);
}
+ // Drawing and running event loop from non-main thread does not work at all on Andorid and crashes often on Linux
+#if defined(ANDROID) || defined(LINUX)
+ GH.loopInitFromMainThread();
+ while( GH.loopFromMainThread() )
+ {
+ while( loopListenForEvents(false) );
+ }
+#else
mainGUIThread = new boost::thread(&CGuiHandler::run, boost::ref(GH));
listenForEvents();
+#endif
return 0;
}
@@ -559,10 +584,12 @@
tlog2 << "Warning: SDL says that " << bpp << "bpp is wrong and suggests " << suggestedBpp << std::endl;
}
+#ifndef ANDROID
if(screen) //screen has been already initialized
SDL_QuitSubSystem(SDL_INIT_VIDEO);
SDL_InitSubSystem(SDL_INIT_VIDEO);
+#endif
if((screen = SDL_SetVideoMode(w, h, suggestedBpp, SDL_SWSURFACE|(fullscreen?SDL_FULLSCREEN:0))) == NULL)
{
@@ -607,14 +634,27 @@
setResolution = true;
}
+
static void listenForEvents()
{
- while(1) //main SDL events loop
- {
+ while(loopListenForEvents(true)); //main SDL events loop
+}
+
+static bool loopListenForEvents(bool block)
+{
SDL_Event *ev = new SDL_Event();
//tlog0 << "Waiting... ";
- int ret = SDL_WaitEvent(ev);
+ int ret = 1;
+ if( block )
+ ret = SDL_WaitEvent(ev);
+ else
+ {
+ if(!SDL_PollEvent(ev)) {
+ delete ev;
+ return false;
+ }
+ }
//tlog0 << "got " << (int)ev->type;
if (ret == 0 || (ev->type==SDL_QUIT) ||
(ev->type == SDL_KEYDOWN && ev->key.keysym.sym==SDLK_F4 && (ev->key.keysym.mod & KMOD_ALT)))
@@ -633,7 +673,7 @@
SDL_Delay(750);
SDL_Quit();
tlog0 << "Ending...\n";
- break;
+ return false;
}
else if(LOCPLINT && ev->type == SDL_KEYDOWN && ev->key.keysym.sym==SDLK_F4)
{
@@ -642,7 +682,7 @@
setScreenRes(conf.cc.screenx, conf.cc.screeny, conf.cc.bpp, full);
GH.totalRedraw();
delete ev;
- continue;
+ return true;
}
else if(ev->type == SDL_USEREVENT)
{
@@ -672,7 +712,7 @@
}
delete ev;
- continue;
+ return true;
}
//tlog0 << " pushing ";
@@ -680,7 +720,7 @@
events.push(ev);
eventsM.unlock();
//tlog0 << " done\n";
- }
+ return true;
}
void startGame(StartInfo * options, CConnection *serv/* = NULL*/)
@@ -741,3 +781,4 @@
ev.user.code = 1;
SDL_PushEvent(&ev);
}
+
Index: client/CDefHandler.cpp
===================================================================
--- client/CDefHandler.cpp (revision 2183)
+++ client/CDefHandler.cpp (working copy)
@@ -50,10 +50,19 @@
SDL_FreeSurface(ourImages[i].bitmap);
}
+#define CHECK_LOD_MEM_BLOCK_SIZE1(S, FF, F, L) { \
+ if( CLodHandler::dbgLastFileSize < (S) ) \
+ tlog1<<"ERROR in " << FF << " " << F << ":" << L << ": reading past the end of LOD mem block at " << \
+ (S) << " memblock " << CLodHandler::dbgLastFileSize << " fname " << CLodHandler::dbgLastFileName << std::endl; }
+#define CHECK_LOD_MEM_BLOCK_SIZE(S) CHECK_LOD_MEM_BLOCK_SIZE1(S, __FUNCTION__, __FILE__, __LINE__)
+
void CDefHandler::openFromMemory(unsigned char *table, const std::string & name)
{
+ //tlog0<<"openFromMemory ptr " << (void *)table <<std::endl;
+
BMPPalette palette[256];
- SDefEntry &de = * reinterpret_cast<SDefEntry *>(table);
+ SDefEntry de;
+ memcpy(&de, table, sizeof(de));
unsigned char *p;
defName = name;
@@ -61,6 +70,8 @@
width = SDL_SwapLE32(de.width);
height = SDL_SwapLE32(de.height);
unsigned int totalBlocks = SDL_SwapLE32(de.totalBlocks);
+
+ //tlog0<<"openFromMemory w " << width << " h " << height << " totalBlocks " << totalBlocks <<std::endl;
for (unsigned int it=0;it<256;it++)
{
@@ -71,13 +82,15 @@
}
// The SDefEntryBlock starts just after the SDefEntry
- p = reinterpret_cast<unsigned char *>(&de);
+ p = table;
p += sizeof(de);
-
+
int totalEntries=0;
for (unsigned int z=0; z<totalBlocks; z++)
{
- SDefEntryBlock &block = * reinterpret_cast<SDefEntryBlock *>(p);
+ //tlog0<<"Megadebug 443 - read size " << p - table <<std::endl;
+ SDefEntryBlock block;
+ memcpy(&block, p, sizeof(block));
unsigned int totalInBlock;
totalInBlock = SDL_SwapLE32(read_unaligned_u32(&block.totalInBlock));
@@ -85,7 +98,8 @@
for (unsigned int j=SEntries.size(); j<totalEntries+totalInBlock; j++)
SEntries.push_back(SEntry());
- p = block.data;
+ p += sizeof(block);
+ //tlog0<<"Megadebug 444 - read size " << p - table << " totalInBlock " << totalInBlock <<std::endl;
for (unsigned int j=0; j<totalInBlock; j++)
{
char Buffer[13];
@@ -93,11 +107,13 @@
Buffer[12] = 0;
SEntries[totalEntries+j].name=Buffer;
p += 13;
+ //tlog0<<"Megadebug 445 - read size " << p - table <<std::endl;
}
for (unsigned int j=0; j<totalInBlock; j++)
{
SEntries[totalEntries+j].offset = SDL_SwapLE32(read_unaligned_u32(p));
p += 4;
+ //tlog0<<"Megadebug 446 - read size " << p - table <<std::endl;
}
//totalEntries+=totalInBlock;
for(unsigned int hh=0; hh<totalInBlock; ++hh)
@@ -105,21 +121,30 @@
SEntries[totalEntries].group = z;
++totalEntries;
}
+ CHECK_LOD_MEM_BLOCK_SIZE(p - table);
}
+ //tlog0<<"Megadebug 448" << std::endl;
for(unsigned int j=0; j<SEntries.size(); ++j)
{
- SEntries[j].name = SEntries[j].name.substr(0, SEntries[j].name.find('.')+4);
+ std::string::size_type pos = SEntries[j].name.find('.');
+ if(pos != std::string::npos)
+ pos += 4;
+ SEntries[j].name = SEntries[j].name.substr(0, pos);
}
+ //tlog0<<"Megadebug 449" << std::endl;
//RWEntries = new unsigned int[height];
for(unsigned int i=0; i < SEntries.size(); ++i)
{
Cimage nimg;
+ //tlog0<<"Megadebug 4491" << std::endl;
nimg.bitmap = getSprite(i, table, palette);
+ //tlog0<<"Megadebug 4492" << std::endl;
nimg.imName = SEntries[i].name;
nimg.groupNumber = SEntries[i].group;
ourImages.push_back(nimg);
}
+ //tlog0<<"Megadebug 4499" << std::endl;
}
void CDefHandler::expand(unsigned char N,unsigned char & BL, unsigned char & BR)
@@ -128,9 +153,17 @@
BR = N & 0x1F;
}
+
+#define CHECK_OUTBUF_MEM_BLOCK_SIZE1(S, FF, F, L) { \
+ if( FullHeight*FullWidth < (S) ) \
+ tlog1<<"ERROR in " << FF << " " << F << ":" << L << ": writing past the end of SDL surface at " << \
+ (S) << " memblock " << FullHeight*FullWidth << " fname " << CLodHandler::dbgLastFileName << std::endl; }
+#define CHECK_OUTBUF_MEM_BLOCK_SIZE(S) CHECK_LOD_MEM_BLOCK_SIZE1(S, __FUNCTION__, __FILE__, __LINE__)
+
SDL_Surface * CDefHandler::getSprite (int SIndex, const unsigned char * FDef, const BMPPalette * palette) const
{
SDL_Surface * ret=NULL;
+ //tlog0<<"getSprite ptr " << (void *)FDef << std::endl;
unsigned int BaseOffset,
SpriteWidth, SpriteHeight, //format of sprite
@@ -145,7 +178,10 @@
unsigned char SegmentType;//, BL, BR; //TODO use me
BaseOffset = SEntries[SIndex].offset;
- SSpriteDef sd = * reinterpret_cast<const SSpriteDef *>(FDef + BaseOffset);
+ SSpriteDef sd;
+ CHECK_LOD_MEM_BLOCK_SIZE(BaseOffset + sizeof(sd));
+
+ memcpy(&sd, FDef + BaseOffset, sizeof(sd));
prSize = SDL_SwapLE32(sd.prSize); //TODO use me
defType2 = SDL_SwapLE32(sd.defType2);
@@ -170,12 +206,14 @@
if (add==4)
add=0;
+ //tlog0<<"getSprite: 11: SDL_CreateRGBSurface " << FullWidth << ":" << FullHeight << std::endl;
ret = SDL_CreateRGBSurface(SDL_SWSURFACE, FullWidth, FullHeight, 8, 0, 0, 0, 0);
//int tempee2 = readNormalNr(0,4,((unsigned char *)tempee.c_str()));
BaseOffset += sizeof(SSpriteDef);
int BaseOffsetor = BaseOffset;
+ //tlog0<<"getSprite: 12: set palette" << std::endl;
for(int i=0; i<256; ++i)
{
SDL_Color pr;
@@ -188,6 +226,7 @@
int ftcp=0;
+ //tlog0<<"getSprite: 13" << std::endl;
// If there's a margin anywhere, just blank out the whole surface.
if (TopMargin > 0 || BottomMargin > 0 || LeftMargin > 0 || RightMargin > 0) {
memset( reinterpret_cast<char*>(ret->pixels), 0, FullHeight*FullWidth);
@@ -197,6 +236,7 @@
if (TopMargin > 0)
ftcp += TopMargin*(FullWidth+add);
+ //tlog0<<"getSprite: 14: defType2 " << defType2 << std::endl;
switch(defType2)
{
case 0:
@@ -206,6 +246,8 @@
if (LeftMargin>0)
ftcp += LeftMargin;
+ CHECK_LOD_MEM_BLOCK_SIZE(BaseOffset + SpriteWidth);
+ CHECK_OUTBUF_MEM_BLOCK_SIZE(ftcp + SpriteWidth);
memcpy(reinterpret_cast<char*>(ret->pixels)+ftcp, &FDef[BaseOffset], SpriteWidth);
ftcp += SpriteWidth;
BaseOffset += SpriteWidth;
@@ -218,11 +260,12 @@
case 1:
{
- const unsigned int * RWEntriesLoc = reinterpret_cast<const unsigned int *>(FDef+BaseOffset);
+ unsigned int RWEntriesLoc = BaseOffset;
BaseOffset += sizeof(int) * SpriteHeight;
for (unsigned int i=0;i<SpriteHeight;i++)
{
- BaseOffset=BaseOffsetor + SDL_SwapLE32(read_unaligned_u32(RWEntriesLoc + i));
+ CHECK_LOD_MEM_BLOCK_SIZE(RWEntriesLoc + i*4 + 4);
+ BaseOffset=BaseOffsetor + SDL_SwapLE32(read_unaligned_u32(FDef+RWEntriesLoc + i*4));
if (LeftMargin>0)
ftcp += LeftMargin;
@@ -230,17 +273,22 @@
do
{
unsigned int SegmentLength;
+
+ CHECK_LOD_MEM_BLOCK_SIZE(BaseOffset + 4);
SegmentType=FDef[BaseOffset++];
SegmentLength=FDef[BaseOffset++] + 1;
-
+
if (SegmentType==0xFF)
{
+ CHECK_LOD_MEM_BLOCK_SIZE(BaseOffset + SegmentLength);
+ CHECK_OUTBUF_MEM_BLOCK_SIZE(ftcp + SegmentLength);
memcpy(reinterpret_cast<char*>(ret->pixels)+ftcp, FDef + BaseOffset, SegmentLength);
BaseOffset+=SegmentLength;
}
else
{
+ CHECK_OUTBUF_MEM_BLOCK_SIZE(ftcp + SegmentLength);
memset(reinterpret_cast<char*>(ret->pixels)+ftcp, SegmentType, SegmentLength);
}
ftcp += SegmentLength;
@@ -260,6 +308,7 @@
case 2:
{
+ CHECK_LOD_MEM_BLOCK_SIZE(BaseOffsetor+2);
BaseOffset = BaseOffsetor + SDL_SwapLE16(read_unaligned_u16(FDef + BaseOffsetor));
for (unsigned int i=0;i<SpriteHeight;i++)
@@ -272,17 +321,21 @@
do
{
+ CHECK_LOD_MEM_BLOCK_SIZE(BaseOffset+1);
SegmentType=FDef[BaseOffset++];
unsigned char code = SegmentType / 32;
unsigned char value = (SegmentType & 31) + 1;
if(code==7)
{
+ CHECK_LOD_MEM_BLOCK_SIZE(BaseOffset + value);
+ CHECK_OUTBUF_MEM_BLOCK_SIZE(ftcp + value);
memcpy(reinterpret_cast<char*>(ret->pixels)+ftcp, &FDef[BaseOffset], value);
ftcp += value;
BaseOffset += value;
}
else
{
+ CHECK_OUTBUF_MEM_BLOCK_SIZE(ftcp + value);
memset(reinterpret_cast<char*>(ret->pixels)+ftcp, code, value);
ftcp += value;
}
@@ -304,6 +357,7 @@
{
for (unsigned int i=0;i<SpriteHeight;i++)
{
+ CHECK_LOD_MEM_BLOCK_SIZE(BaseOffsetor+i*2*(SpriteWidth/32+2));
BaseOffset = BaseOffsetor + SDL_SwapLE16(read_unaligned_u16(FDef + BaseOffsetor+i*2*(SpriteWidth/32)));
if (LeftMargin>0)
ftcp += LeftMargin;
@@ -312,6 +366,7 @@
do
{
+ CHECK_LOD_MEM_BLOCK_SIZE(BaseOffset+1);
SegmentType=FDef[BaseOffset++];
unsigned char code = SegmentType / 32;
unsigned char value = (SegmentType & 31) + 1;
@@ -321,12 +376,15 @@
if(code==7)
{
+ CHECK_LOD_MEM_BLOCK_SIZE(BaseOffset + len);
+ CHECK_OUTBUF_MEM_BLOCK_SIZE(ftcp + len);
memcpy((ui8*)ret->pixels + ftcp, FDef + BaseOffset, len);
ftcp += len;
BaseOffset += len;
}
else
{
+ CHECK_OUTBUF_MEM_BLOCK_SIZE(ftcp + len);
memset((ui8*)ret->pixels + ftcp, code, len);
ftcp += len;
}
@@ -345,6 +403,7 @@
break;
default:
+ tlog1<<"getSprite: Unknown sprite format."<< std::endl;
throw std::string("Unknown sprite format.");
break;
}
@@ -365,9 +424,12 @@
CDefHandler * CDefHandler::giveDef(const std::string & defName)
{
+ tlog0<<"giveDef " << defName <<std::endl;
unsigned char * data = spriteh->giveFile(defName, FILE_ANIMATION);
- if(!data)
- throw "bad def name!";
+ if(!data) {
+ tlog0<<"Bad def name: " << defName <<std::endl;
+ throw std::runtime_error("bad def name!");
+ }
CDefHandler * nh = new CDefHandler();
nh->openFromMemory(data, defName);
delete [] data;
Index: client/GUIBase.h
===================================================================
--- client/GUIBase.h (revision 2183)
+++ client/GUIBase.h (working copy)
@@ -546,6 +546,8 @@
CGuiHandler();
~CGuiHandler();
void run(); // holds the main loop for the whole program after initialization and manages the update/rendering system
+ void loopInitFromMainThread();
+ bool loopFromMainThread();
void totalRedraw(); //forces total redraw (using showAll), sets a flag, method gets called at the end of the rendering
void simpleRedraw(); //update only top interface and draw background from buffer, sets a flag, method gets called at the end of the rendering
Reference in New Issue View Git Blame Copy Permalink