summaryrefslogtreecommitdiff
path: root/powermanga
diff options
context:
space:
mode:
Diffstat (limited to 'powermanga')
-rw-r--r--powermanga/powermanga-0.79/linuxroutines.cpp845
-rw-r--r--powermanga/powermanga-0.79/powermanga.desktop6
-rw-r--r--powermanga/powermanga-0.79/powermanga.pro64
3 files changed, 915 insertions, 0 deletions
diff --git a/powermanga/powermanga-0.79/linuxroutines.cpp b/powermanga/powermanga-0.79/linuxroutines.cpp
index e69de29bb2..39394eb026 100644
--- a/powermanga/powermanga-0.79/linuxroutines.cpp
+++ b/powermanga/powermanga-0.79/linuxroutines.cpp
@@ -0,0 +1,845 @@
+//*****************************************************************************
+// copyright (c) 1998-2003 TLK Games all rights reserved
+//-----------------------------------------------------------------------------
+// file : "linuxroutines.cpp"
+// created : 1999-08-19
+// updates : 2004-08-01
+//------------------------------------------------------------------------------
+// functions : int mem_initialise(unsigned int _iNombreZones)
+// char* reserveMemoire(unsigned int _iTailleMemoire)
+// void libereMemoire(char* _pMemoire)
+// void mem_libereTous()
+// int load_pcx(char*, char*) ;
+// sDescriptionGfx* load_pcx(char*) ;
+// unsigned int littleWord(char* _pMem) ;
+// short litMot16bits(short* _pMem) ;
+// int litMot32bits(int* _pMem) ;
+// int chaine_cmp(char* _pChaine1, char* _pChaine2, unsigned int _iTaille) ;
+// char* chargeFichier(char* _pNomFichier)
+// char* chargeFichier(char* _pNomFichier, unsigned int* pTaille)
+// int chargeFichier(char* _pNomFichier, char* _pMemoire)
+// void fps_init()
+// void fps_affiche()
+// void afficheErreur(char* _pErreur1, char* _pErreur2)
+// int synchro_processusPause(int _iTemps)
+// int synchro_CalculDifference()
+// int synchro_CalculDifference2()
+//-----------------------------------------------------------------------------
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+// Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+//*****************************************************************************
+
+#include "powermanga.hpp"
+#include <errno.h>
+
+#ifndef SDL_TLK
+#include <sys/types.h>
+#include <sys/stat.h>
+#endif
+
+//..............................................................................
+extern unsigned int iVerbeux; //1=affiche les arguments / 1=verbose mode
+
+//gestion de la memoire .........................................................
+typedef struct
+{ char *pMemoire; //pointeur sur la zone memoire / pointer to memory zone
+ int iTailleMemoire; //taille de la zone en octets / size of memory zone in bytes
+}
+sListeMemoire;
+char *pZoneListeMemoire;
+sListeMemoire *pZoneListeBase;
+sListeMemoire *pZoneListeLibre;
+unsigned int iTailleListe; //taille de la liste memoire / size of memory table
+unsigned int iNombreZonesMaximum; //nombre de zones memoires maxi / number maximum of memory zone
+unsigned int iNombreZones; //nombre de zone actuelle / number of memroy zone
+unsigned int iOctetsTotal; //taille prise en octets / total memory size allocated
+unsigned int iNombreZonesMax; //nombre maximum de zones reserves
+
+//..............................................................................
+unsigned int iCompteurBoucle;
+#ifdef SDL_TLK
+Uint32 time_begin;
+Uint32 temps_actuel;
+Uint32 temps_sauve;
+Uint32 temps_actuel2;
+Uint32 temps_sauve2;
+#else
+static struct timeval time_begin;
+static struct timeval temps_actuel;
+static struct timeval temps_sauve;
+static struct timeval temps_actuel2;
+static struct timeval temps_sauve2;
+#endif
+
+//..............................................................................
+short litMot16bitsBig(short *_pMem);
+unsigned short litMot16bits(unsigned short *_pMem);
+extern const char nomprefix[];
+extern unsigned int iFrame3;
+//------------------------------------------------------------------------------
+// initialise la liste memoire / initialise memory table
+// input => _iNombreZones : nombre de zones memoire possibles au maximum / number maximum of memory zone
+// ouput <= 0=erreur / 0=error
+//------------------------------------------------------------------------------
+int mem_initialise(unsigned int _iNombreZones)
+{
+ unsigned int _iIndex;
+ iNombreZones = 0; // nombre de zones reservees a zero
+ pZoneListeMemoire = 0;
+ iNombreZonesMaximum = _iNombreZones; // nombre maximum de zones pouvant etre reservees
+ iNombreZonesMax = 0;
+ iTailleListe = iNombreZonesMaximum * sizeof(sListeMemoire);
+ iOctetsTotal = iTailleListe;
+ pZoneListeMemoire = (char *)malloc(iTailleListe);
+ if(!pZoneListeMemoire)
+ { afficheErreur("malloc() failed", "linuxroutines/mem_initialise()");
+ return 0;
+ }
+ pZoneListeBase = (sListeMemoire *) pZoneListeMemoire;
+ pZoneListeLibre = pZoneListeBase;
+ sListeMemoire *_pMem = pZoneListeBase;
+
+ for(_iIndex = 0; _iIndex < iNombreZonesMaximum; _iIndex++, _pMem++) //clean memory table
+ { _pMem->pMemoire = 0x0;
+ _pMem->iTailleMemoire = 0x0;
+ }
+ return 1;
+}
+
+//------------------------------------------------------------------------------
+// reserve une zone memoire / allocate memory
+// input => _iTailleMemoire : taille memoire en octets souhaitee / size of bytes
+// output <= _pMem : adresse memoire (0=erreur) / pointer to memory
+//------------------------------------------------------------------------------
+char *reserveMemoire(unsigned int _iTailleMemoire)
+{
+ char *_pMem = 0x0;
+ char *_pMemoire = 0x0;
+ char _cZero = 0;
+ unsigned int _iIndex;
+ if(iNombreZones >= iNombreZonesMaximum)
+ { printf ("linuxroutines.cpp/reserveMemoire(unsigned int) : table overflow ; size request %i bytes ; total allocate : % i in %i zones\n", _iTailleMemoire, iOctetsTotal, iNombreZones);
+ return 0;
+ }
+ _pMem = (char *)malloc(_iTailleMemoire);
+ if(!_pMem)
+ { printf ("linuxroutines.cpp/reserveMemoire(unsigned int) : malloc(int) return 0 ; size request %i bytes ; total allocate : % i in %i zones\n", _iTailleMemoire, iOctetsTotal, iNombreZones);
+ return 0;
+ }
+ iOctetsTotal += _iTailleMemoire;
+ pZoneListeLibre->pMemoire = _pMem; //pointeur memoire
+ pZoneListeLibre->iTailleMemoire = _iTailleMemoire; //taille en octets
+ pZoneListeLibre += 1;
+ iNombreZones++;
+ if(iNombreZones > iNombreZonesMax)
+ iNombreZonesMax = iNombreZones;
+ _pMemoire = _pMem;
+ for(_iIndex = 0; _iIndex < _iTailleMemoire; _iIndex++)
+ *(_pMemoire++) = _cZero; //efface memoire
+ return (_pMem);
+}
+
+//------------------------------------------------------------------------------
+// liberation d'une zone memoire / free memory
+// input => _pMemoire : adresse de la zone a liberer / pointer to memory
+//------------------------------------------------------------------------------
+void libereMemoire(char *_pMemoire)
+{
+ sListeMemoire *_pListeMem;
+ sListeMemoire *_pListeMemSource;
+ unsigned int _iCompteur;
+ if(_pMemoire)
+ { _pListeMem = pZoneListeBase;
+ for(_iCompteur = 0; _iCompteur < iNombreZones; _iCompteur++, _pListeMem++)
+ { if(_pListeMem->pMemoire == _pMemoire) //on a trouve l'adresse dans la table ?
+ { free(_pMemoire); //oui, libere la memoire
+ _pListeMemSource = _pListeMem + 1;
+ iOctetsTotal -= _pListeMem->iTailleMemoire;
+ iNombreZones--;
+ pZoneListeLibre--;
+ while (_iCompteur < iNombreZones)
+ { _pListeMem->pMemoire = _pListeMemSource->pMemoire;
+ _pListeMem->iTailleMemoire = _pListeMemSource->iTailleMemoire;
+ _iCompteur++;
+ _pListeMem++;
+ _pListeMemSource++;
+ }
+ _pListeMem->pMemoire = 0x0;
+ _pListeMem->iTailleMemoire = 0x0;
+ _pMemoire = 0;
+ break;
+ }
+ }
+ if(_pMemoire > 0)
+ { fprintf(stderr, "libereMemoire() : can't release the address %x\n", (int)_pMemoire);
+ }
+ }
+ else
+ { fprintf(stderr, "libereMemoire() : try to release a null address!\n");
+ }
+}
+
+//------------------------------------------------------------------------------
+// retourne la taille d'une adresse memoire reservee / get memory zone's size
+// input => _pMem : pointeur sur une zone memoire / pointer to memory
+//------------------------------------------------------------------------------
+int mem_retourneTaille(char *_pMem)
+{
+ unsigned int _iCompteur;
+ sListeMemoire *_pListeMem = pZoneListeBase;
+ if(_pMem)
+ { for(_iCompteur = 0; _iCompteur < iNombreZones; _iCompteur++, _pListeMem++)
+ { if(_pListeMem->pMemoire == _pMem)
+ return _pListeMem->iTailleMemoire;
+ }
+ }
+ return 0;
+}
+
+//------------------------------------------------------------------------------
+// libere toutes les zones memoires / free all memory
+//------------------------------------------------------------------------------
+void mem_libereTous()
+{
+ unsigned int _iCompteur;
+ char *_pMemoire;
+ sListeMemoire *_pListeMem = pZoneListeBase;
+#ifdef _VERBEUX_
+ if(iVerbeux > 0)
+ fprintf(stdout, "> linuxroutines.cpp/mem_libereTous(): maximum of memory which were allocated during the game : %i\n", iNombreZonesMax);
+#endif
+ if(iNombreZones >0)
+ {
+#ifdef _VERBEUX_
+ if(iVerbeux > 0)
+ fprintf(stdout, "> linuxroutines.cpp/mem_libereTous() : %i zones were not released.\n", iNombreZones);
+#endif
+ for(_iCompteur = 0; _iCompteur < iNombreZones; _iCompteur++, _pListeMem++)
+ { _pMemoire = _pListeMem->pMemoire;
+ if(_pMemoire)
+ { /* fprintf(stderr, "mem_libereTous: adresseMem =%x ; taille_mem=%ld\n",
+ (int)_pListeMem->pMemoire, _pListeMem->iTailleMemoire); */
+ free(_pMemoire); //libere la memoire
+ _pListeMem->pMemoire = 0;
+ _pListeMem->iTailleMemoire = 0;
+ }
+ }
+ if(pZoneListeMemoire)
+ { free(pZoneListeMemoire);
+ pZoneListeMemoire = 0x0;
+ }
+ iNombreZones = 0;
+ }
+}
+
+//------------------------------------------------------------------------------
+// decompress pcx file
+// input => _pFichier : filename
+// output <= _pStructureGfx : pointer to the "sDescriptionGfx" structure / 0=error
+//------------------------------------------------------------------------------
+sDescriptionGfx *load_pcx(char *_pNomFichier)
+{
+ unsigned int iLongeur;
+ unsigned int ptr = 128;
+ unsigned char nbr_bytes;
+ unsigned char val;
+ unsigned int i1, i, total;
+ unsigned char *_pFichier, *_pAdresseMem;
+ sDescriptionGfx *_pDescripGfx = 0x0;
+ _pFichier = (unsigned char *)chargeFichier(_pNomFichier, &iLongeur); //load file in memory
+ if(!_pFichier) return 0;
+ unsigned short *_p16 = (unsigned short *)_pFichier;
+ unsigned int _iLarge = (litMot16bits(_p16 + 4) - litMot16bits(_p16 + 2)) + 1; //image width
+ unsigned int _iHaut = (litMot16bits(_p16 + 5) - litMot16bits(_p16 + 3)) + 1; //image height
+ unsigned int _iProfondeur = _pFichier[3]; //bits per pixel
+
+ _pDescripGfx = (sDescriptionGfx *) reserveMemoire(sizeof(sDescriptionGfx)); //allocate structure memory
+ if(!_pDescripGfx)
+ { afficheErreur("_pDescripGfx out of memory", "linuxroutines.cpp/load_pcx()");
+ return 0;
+ }
+ _pDescripGfx->iLargeur = _iLarge;
+ _pDescripGfx->iHauteur = _iHaut;
+ _pDescripGfx->iProfond = _iProfondeur;
+ _pDescripGfx->iTaille = _iLarge * _iHaut * (_iProfondeur >> 3);
+ _pDescripGfx->pAdresse = reserveMemoire(_pDescripGfx->iTaille); //allocate image memory
+ if(!_pDescripGfx->pAdresse)
+ { libereMemoire((char *)_pDescripGfx);
+ printf("linuxroutines.cpp/load_pcx() : height=%i / width=%i \n", _iLarge, _iHaut);
+ afficheErreur("_pDescripGfx->iTaille : out of memory\n", "linuxroutines.cpp/reserveMemoire()");
+ return 0;
+ }
+ //decompress rle
+ _pAdresseMem = (unsigned char *)_pDescripGfx->pAdresse;
+ total = 0;
+ i = iLongeur - 768;
+ while (ptr < i)
+ { if((_pFichier[ptr] & 0xC0) == 0xC0)
+ { nbr_bytes = _pFichier[ptr] & 0x3F;
+ ptr++;
+ }
+ else
+ nbr_bytes = 1;
+ val = _pFichier[ptr];
+ total += nbr_bytes; // Samuel Hocevar
+ if(total >= _pDescripGfx->iTaille)
+ break;
+ for(i1 = 0; i1 < nbr_bytes; i1++)
+ { *_pAdresseMem = val;
+ _pAdresseMem++;
+ }
+ ptr++;
+ }
+ libereMemoire((char *)_pFichier);
+#ifdef _VERBEUX_
+ if(iVerbeux > 0)
+ fprintf (
+ stdout,
+ "> linuxroutines.cpp/load_pcx(): \"%s\"; height=%i; width=%i; size=%i\n",
+ _pNomFichier,
+ _iLarge,
+ _iHaut,
+ _pDescripGfx->iTaille);
+#endif
+ return _pDescripGfx;
+}
+
+//------------------------------------------------------------------------------
+// lecture d'un mot de 16 bits code en memoire en little-endian
+// input => _pMem : pointeur sur le mot en memoire
+// output <= _iValeur : valeur utilisale
+//------------------------------------------------------------------------------
+unsigned int littleWord(char *_pMem)
+{
+ unsigned short *t = (unsigned short *)_pMem;
+ return *t;
+}
+
+//------------------------------------------------------------------------------
+// lecture d'un long mot signe de 16 bits little-endian (compatible little-endian/big-endian)
+// input => _pMem : pointeur sur le mot en memoire
+// output <= _iValeur : valeur utilisale
+//------------------------------------------------------------------------------
+short litMot16bits(short *_pMem)
+{
+ short _iValeur = 0;
+ unsigned char *_pMemoire = (unsigned char *)_pMem;
+ _iValeur = _pMemoire[1]; //lit du little endian pour un powerpc
+ _iValeur <<= 8;
+ _iValeur += _pMemoire[0];
+ return (_iValeur);
+}
+
+//------------------------------------------------------------------------------
+// lecture d'un long mot signe de 16 bits little-endian (compatible little-endian/big-endian)
+// input => _pMem : pointeur sur le mot en memoire
+// output <= _iValeur : valeur utilisale
+//------------------------------------------------------------------------------
+unsigned short litMot16bits(unsigned short *_pMem)
+{
+ unsigned short _iValeur = 0;
+ unsigned char *_pMemoire = (unsigned char *)_pMem;
+ _iValeur = _pMemoire[1]; //lit du little endian pour un powerpc
+ _iValeur <<= 8;
+ _iValeur += _pMemoire[0];
+ return (_iValeur);
+}
+
+//------------------------------------------------------------------------------
+// lecture d'un long mot signe de 16 bits big-endian (compatible little-endian/big-endian)
+// input => _pMem : pointeur sur le mot en memoire
+// output <= _iValeur : valeur utilisale
+//------------------------------------------------------------------------------
+short litMot16bitsBig(short *_pMem)
+{
+ short _iValeur = 0;
+ unsigned char *_pMemoire = (unsigned char *)_pMem;
+ _iValeur = _pMemoire[0]; //lit du big endian pour un 80x86
+ _iValeur <<= 8;
+ _iValeur += _pMemoire[1];
+ return (_iValeur);
+}
+
+//------------------------------------------------------------------------------
+//lecture d'un long mot signe de 32 bits little-endian(compatible little-endian/big-endian)
+// input => _pMem : pointeur sur le mot 32 bits en memoire
+// output <= _iValeur : valeur utilisale
+//------------------------------------------------------------------------------
+int litMot32bits(int *_pMem)
+{
+ int _iValeur = 0;
+ unsigned char *_pMemoire = (unsigned char *)_pMem;
+ _iValeur = _pMemoire[3];
+ _iValeur <<= 8;
+ _iValeur += _pMemoire[2];
+ _iValeur <<= 8;
+ _iValeur = _pMemoire[1];
+ _iValeur <<= 8;
+ _iValeur += _pMemoire[0];
+ return (_iValeur);
+}
+
+//------------------------------------------------------------------------------
+// convertit un long mot de 32 bits en memoire little-endian => big-endian
+//------------------------------------------------------------------------------
+void convert32bits_2bigendian (unsigned char* memory)
+{ unsigned char b0, b1, b2, b3;
+ b0 = memory[1];
+ b1 = memory[0];
+ b2 = memory[3];
+ b3 = memory[2];
+ memory[0] = b2;
+ memory[1] = b3;
+ memory[2] = b0;
+ memory[3] = b1;
+}
+
+//------------------------------------------------------------------------------
+//comparaison de deux chaines de caracteres
+// input => _pChaine1 : pointeur sur la premiere chaine
+// => _pChaine1 : pointeur sur la deuxieme chaine
+// => _iTaille : longeurs en octets de chaines
+// output <= 0les chaines ont au moins une difference / 1=les chaines sont identiques
+//------------------------------------------------------------------------------
+int chaine_cmp(char *_pChaine1, char *_pChaine2, unsigned int _iTaille)
+{
+ unsigned int _iLongeur = _iTaille;
+ char *_pMem1 = _pChaine1;
+ char *_pMem2 = _pChaine2;
+ unsigned int _iIndex;
+ char _cOctet1, _cOctet2;
+ for(_iIndex = 0; _iIndex < _iLongeur; _iIndex++)
+ { _cOctet1 = _pMem1[_iIndex];
+ _cOctet2 = _pMem2[_iIndex];
+ if(_cOctet2 != _cOctet1)
+ return (0);
+ }
+ return (1);
+}
+
+//------------------------------------------------------------------------------
+// locate a file under one of the data directories (thanx to Andre Majorel :-)
+// input => name : name of file relative to data directory
+// output <= 0 : could not locate file (not found, or not enough
+// memory, or the name given was absolute)
+// other : pointer to a malloc'd buffer containing the name
+// under which the file was found. free()-ing the
+// buffer is the responsibility of the caller.
+//------------------------------------------------------------------------------
+static const char *data_directories[]=
+{ ".", // Normally unused, except when running from the source directory...
+ "/opt/QtPalmtop/share/games/powermanga/",
+ 0 // Special value meaning "$(PREFIX)/share/games/powermanga/"
+ // Also marks end of list
+};
+static char pathstring[256];
+
+char *locate_data_file(const char *const name)
+{
+
+ for(int i = 0; i < 256; i++)
+ pathstring[i] = 0;
+
+ if(name == 0) return 0;
+ if(*name == '/') return strdup(name); // Guillaume Cottenceau (2001-03-15) replace "return 0;" by "strdup(name);"
+ // En effet, nous sommes dans le cas ou le programme recherche dans /usr/share/games/powermanga
+ for(const char **p = data_directories;; p++)
+ { char *pathname;
+ if(*p == 0)
+ { const char *subdir = "/share/games/powermanga/";
+ pathname = &pathstring[0];
+ /*pathname=(char *)malloc(strlen(nomprefix) + strlen(subdir) + strlen(name) + 1);
+ if(pathname == 0)
+ { fflush(stdout);
+ fprintf(stderr, "powermanga: not enough memory\n");
+ return 0;
+ }*/
+ strcpy(pathname, nomprefix);
+ strcat(pathname, subdir);
+ strcat(pathname, name);
+ }
+ else if(**p == '~') // Not used anymore
+ { static const char bogus = '\0';
+ static const char *home_dir = &bogus;
+ if(home_dir == &bogus) home_dir = getenv("HOME");
+ if(home_dir == 0) continue; // $HOME not set. Skip this directory.
+ pathname = &pathstring[0];
+
+ /*pathname = (char *)malloc(strlen(home_dir) + 1 + strlen(*p + 1) + 1 + strlen(name) + 1);
+ if(pathname == 0)
+ { fflush(stdout);
+ fprintf(stderr, "powermanga: not enough memory\n");
+ return 0;
+ }*/
+ strcpy(pathname, home_dir);
+ strcat(pathname, *p + 1);
+ strcat(pathname, "/");
+ strcat(pathname, name);
+ }
+ else
+ {
+ pathname = &pathstring[0];
+ /*pathname = (char *)malloc(strlen(*p) + 1 + strlen(name) + 1);
+ if(pathname == 0)
+ { fflush(stdout);
+ fprintf(stderr, "powermanga: not enough memory\n");
+ return 0;
+ }*/
+ strcpy(pathname, *p);
+ strcat(pathname, "/");
+ strcat(pathname, name);
+ }
+ //puts(pathname); // DEBUG
+#ifdef WIN32
+ struct _stat s;
+ if(_stat(pathname, &s) == 0 && !_S_ISDIR(s.st_mode))
+ return pathname;
+#else
+ struct stat s;
+ if(stat(pathname, &s) == 0 && !S_ISDIR(s.st_mode))
+ return pathname;
+#endif
+ //free(pathname);
+ if(*p == 0) break;
+ }
+ return 0; // Not found.
+}
+
+//------------------------------------------------------------------------------
+// load a file in memory / charge un fichier en memoire
+// input => _pNomFichier : nom du fichier
+// _pAdresse : adresse de chargemebt
+// _iTaille : taille a lire
+// output <= 1 : tout c'est bien passe
+// 0 : erreur
+//------------------------------------------------------------------------------
+char *chargeFichier(char *_pNomFichier)
+{
+ unsigned int _pTaille;
+ return chargeFichier(_pNomFichier, &_pTaille);
+}
+
+//------------------------------------------------------------------------------
+// load a file in memory
+// input => _pNomFichier : filename
+// sortie <= _pMemoire : ptr/integer
+//------------------------------------------------------------------------------
+char *chargeFichier(char *_pNomFichier, unsigned int *pTaille)
+{
+ int _iHandle;
+ char *_pMemoire;
+ struct stat sDescriptionFichier;
+ char *pathname = locate_data_file(_pNomFichier);
+ if(pathname == 0)
+ { printf("linuxroutines/chargeFichier() : can't locate file : %s\n\n", _pNomFichier);
+ return 0;
+ }
+#ifdef WIN32
+ _iHandle = open(pathname, O_RDONLY | O_BINARY, 0);
+#else
+ _iHandle = open(pathname, O_RDONLY, 0);
+#endif
+ if(_iHandle == -1)
+ { printf("linuxroutines/chargeFichier() : can't open file : %s (%s)\n\n", pathname, strerror(errno));
+ //free(pathname);
+ return 0;
+ }
+ if(fstat(_iHandle, &sDescriptionFichier))
+ { printf("linuxroutines/chargeFichier() : can't stat file : %s (%s)\n\n", pathname, strerror(errno));
+ close(_iHandle);
+ //free(pathname);
+ return 0;
+ }
+ (*pTaille) = sDescriptionFichier.st_size; //sauve taille
+ _pMemoire = reserveMemoire(sDescriptionFichier.st_size); //reserve la place en memoire pour lire le fichier
+ if(!_pMemoire)
+ { printf("linuxroutines/chargeFichier() %s : out of memory\n\n", pathname);
+ close(_iHandle);
+ //free(pathname);
+ return 0;
+ }
+ if(read(_iHandle, _pMemoire, sDescriptionFichier.st_size) != sDescriptionFichier.st_size)
+ { libereMemoire(_pMemoire);
+ printf("linuxroutines/chargeFichier() can't read file %s (%s)\n\n", pathname, strerror(errno));
+ close(_iHandle);
+ //free(pathname);
+ return 0;
+ }
+ close(_iHandle);
+#ifdef _VERBEUX_
+ if(iVerbeux > 1)
+ printf("linuxroutines/chargeFichier : file %s was loaded in memory\n", pathname);
+#endif
+ //free(pathname);
+ return _pMemoire;
+}
+
+//------------------------------------------------------------------------------
+// load a file in memory / charge un fichier en memoire
+// input => _pNomFichier : filename / nom du fichier
+// => _pMemoire : pointer to memory / pointeur sur la memoire
+// output <= 1 : 0 error/erreur
+//------------------------------------------------------------------------------
+int chargeFichier(char *_pNomFichier, char *_pMemoire)
+{
+ int _iHandle;
+ struct stat sDescriptionFichier;
+ char *pathname = locate_data_file(_pNomFichier);
+ if(pathname == 0)
+ { printf("linuxroutines/chargeFichier() : can't locate file : %s\n\n", _pNomFichier);
+ return 0;
+ }
+#ifdef WIN32
+ _iHandle = open(pathname, O_RDONLY | O_BINARY, 0);
+#else
+ _iHandle = open(pathname, O_RDONLY, 0);
+#endif
+ if(_iHandle == -1)
+ { printf ("linuxroutines.cpp/chargeFichier() : can't open file : %s (%s)\n\n", pathname, strerror(errno));
+ //free(pathname);
+ return 0;
+ }
+ if(fstat(_iHandle, &sDescriptionFichier))
+ { printf ("linuxroutines.cpp/chargeFichier() : can't stat file : %s (%s)\n\n", pathname, strerror(errno));
+ close(_iHandle);
+ //free(pathname);
+ return 0;
+ }
+ if(read(_iHandle, _pMemoire, sDescriptionFichier.st_size) != sDescriptionFichier.st_size)
+ { printf("linuxroutines.cpp/chargeFichier() can't read file %s (%s)\n\n", pathname, strerror(errno));
+ close(_iHandle);
+ //free(pathname);
+ return 0;
+ }
+ close(_iHandle);
+#ifdef _VERBEUX_
+ if(iVerbeux > 1) printf("linuxroutines/chargeFichier : file %s was loaded in memory\n", pathname);
+#endif
+ //free(pathname);
+ return 1;
+}
+
+//------------------------------------------------------------------------------
+// initialise le compteur de boucle et l'heure de depart du programme
+//------------------------------------------------------------------------------
+void fps_init()
+{
+#ifdef SDL_TLK
+ time_begin = SDL_GetTicks();
+ temps_sauve = SDL_GetTicks();
+ temps_sauve2 = SDL_GetTicks();
+#else
+ gettimeofday(&time_begin, NULL);
+ gettimeofday(&temps_sauve, NULL);
+ gettimeofday(&temps_sauve2, NULL);
+#endif
+ iCompteurBoucle = 0;
+}
+
+//------------------------------------------------------------------------------
+// affiche information sur le systeme
+//------------------------------------------------------------------------------
+void fps_affiche()
+{
+
+#ifdef SDL_TLK
+ double fps;
+ unsigned long duration;
+ Sint32 time_end;
+ time_end = SDL_GetTicks();
+ duration = time_end - time_begin;
+ fps = (1000.0 * iCompteurBoucle) / duration;
+ if(iVerbeux > 0)
+ { printf("> linuxroutines.cpp/number of loops : %i\n", iCompteurBoucle);
+ printf("> linuxroutines.cpp/running time : %li\n", duration);
+ printf("> linuxroutines.cpp/fps_affiche() : frames per seconde : %g \n", fps);
+ }
+#else
+ struct utsname kernel;
+ struct stat statmem;
+ unsigned long duration;
+ double fps;
+ double mem;
+ char os_name[32];
+ char os_vers[32];
+ char cpu[64];
+ char freq[32];
+ FILE *cpuinfo;
+ char txt[256];
+ static struct timeval time_end;
+
+ //calcul le temps total d'execution ............................................
+ gettimeofday(&time_end, NULL);
+ duration = (time_end.tv_sec - time_begin.tv_sec) * 1000 + (time_end.tv_usec - time_begin.tv_usec) / 1000;
+ fps = (1000.0 * iCompteurBoucle) / duration;
+
+ //version du systeme d'exploitation ............................................
+ if(uname(&kernel) < 0)
+ { strcpy(os_name, "?");
+ strcpy(os_vers, "");
+ }
+ else
+ { strncpy(os_name, kernel.sysname, 32);
+ strncpy(os_vers, kernel.release, 32);
+ }
+ //processeur & memoire physique du systeme .....................................
+ stat("/proc/kcore", &statmem);
+ mem = ((float)statmem.st_size) / 1024 / 1024;
+ strcpy(cpu, "Unknown");
+ strcpy(freq, "Unknown");
+ cpuinfo = fopen("/proc/cpuinfo", "r");
+ if(cpuinfo != NULL)
+ { while (fgets(txt, 255, cpuinfo))
+ { if(!strncmp(txt, "model", 5))
+ { int i = 0;
+ while (txt[i] != ':') i++;
+ i += 2;
+ for(int j = 0; j < 64;)
+ { if(txt[i++] != '\n') cpu[j++] = txt[i - 1];
+ }
+ }
+ if(!strncmp(txt, "cpu MHz", 7))
+ { int i = 0;
+ while (txt[i] != ':') i++;
+ i += 2;
+ sprintf(freq, "%d", atoi(txt + i));
+ }
+ }
+ }
+ //processeur & memoire physique du systeme .....................................
+ if(iVerbeux > 0)
+ { printf("operating system : %s %s\n", os_name, os_vers);
+ printf("processor : %s at %s Mhz with %.0f RAM\n", cpu, freq, mem);
+ printf("number of loops : %i\n", iCompteurBoucle);
+ printf("running time : %li\n", duration);
+ printf("frames per seconde : %g \n", fps);
+ //printf ( "Compilateur : %s\n" , COMPILO );
+ }
+#endif
+}
+
+//------------------------------------------------------------------------------
+// display error message
+// input => _Message : message
+//------------------------------------------------------------------------------
+void afficheMessage(char *_Message)
+{
+ printf("%s\n", _Message);
+}
+
+//------------------------------------------------------------------------------
+// display error message
+// input => _Message1 : message 1
+// => _Message2 : message 2
+//------------------------------------------------------------------------------
+void afficheMessage(char *_Message1, char *_Message2)
+{
+ printf("%s %s\n", _Message1, _Message2);
+}
+
+//------------------------------------------------------------------------------
+// display error message
+// input => _pErreur1 : error message
+// => _pErreur2 : title error
+//------------------------------------------------------------------------------
+void afficheErreur(char *_pErreur1, char *_pErreur2)
+{
+ printf("%s %s\n", _pErreur2, _pErreur1);
+}
+
+//------------------------------------------------------------------------------
+// display error message
+// input => _pErreur1 : error message
+// => _pErreur2 : title error
+// => _pErreur3 : error message
+//------------------------------------------------------------------------------
+void afficheErreur(char *_pErreur1, char *_pErreur2, char *_pErreur3)
+{
+ printf("%s %s %s\n", _pErreur2, _pErreur1, _pErreur3);
+}
+
+//------------------------------------------------------------------------------
+// display error message
+// input => _pErreur1 : error message
+// => _pErreur2 : title error
+// => _iErreur : error number
+//------------------------------------------------------------------------------
+void afficheErreur(char *_pErreur1, char *_pErreur2, int _iErreur)
+{
+ printf("%s %s error=%i\n", _pErreur2, _pErreur1, _iErreur);
+}
+
+//------------------------------------------------------------------------------
+// sleep process
+// input => i : time
+//------------------------------------------------------------------------------
+int synchro_processusPause(int _iTemps)
+{
+#ifdef SDL_TLK
+ if(_iTemps > (int)iFrame3)
+ _iTemps = iFrame3;
+ if(_iTemps > 0)
+ SDL_Delay(_iTemps);
+ return (_iTemps > 0 ? _iTemps : 0);
+#else
+ struct timeval temps;
+ if(_iTemps > (int)iFrame3)
+ _iTemps = iFrame3;
+ if(_iTemps > 0)
+ { temps.tv_usec = _iTemps % (unsigned long)1000000;
+ temps.tv_sec = _iTemps / (unsigned long)1000000;
+ //sleep for a time interval
+ select(0, NULL, NULL, NULL, &temps);
+ }
+ return (_iTemps > 0 ? _iTemps : 0);
+#endif
+}
+
+#ifdef SDL_TLK
+int synchro_CalculDifference()
+{
+ int _iDifference;
+ temps_actuel = SDL_GetTicks();
+ _iDifference = temps_actuel - temps_sauve;
+ temps_sauve = temps_actuel;
+ return _iDifference;
+}
+#else
+//------------------------------------------------------------------------------
+// calcul la difference entre deux heure differentes
+// sortie <= : _iDifference
+//------------------------------------------------------------------------------
+int synchro_CalculDifference()
+{
+ int _iDifference;
+ gettimeofday(&temps_actuel, NULL);
+ _iDifference = (1000000 * (temps_actuel.tv_sec - temps_sauve.tv_sec)) + (temps_actuel.tv_usec - temps_sauve.tv_usec);
+ temps_sauve = temps_actuel;
+ return _iDifference;
+}
+
+//------------------------------------------------------------------------------
+// calcul la difference entre deux heure differentes
+// sortie <= : _iDifference
+//------------------------------------------------------------------------------
+int synchro_CalculDifference2()
+{
+ int _iDifference;
+ gettimeofday(&temps_actuel2, NULL);
+ _iDifference = (1000000 * (temps_actuel2.tv_sec - temps_sauve2.tv_sec)) + (temps_actuel2.tv_usec - temps_sauve2.tv_usec);
+ temps_sauve2 = temps_actuel2;
+ return _iDifference;
+}
+#endif
diff --git a/powermanga/powermanga-0.79/powermanga.desktop b/powermanga/powermanga-0.79/powermanga.desktop
index e69de29bb2..afc0da21ea 100644
--- a/powermanga/powermanga-0.79/powermanga.desktop
+++ b/powermanga/powermanga-0.79/powermanga.desktop
@@ -0,0 +1,6 @@
+[Desktop Entry]
+Comment=Powermanga is an arcade 2D shoot-em-up game with 41 levels and more than 200 sprites.
+Exec=powermanga
+Icon=powermanga
+Type=Application
+Name=Powermanga
diff --git a/powermanga/powermanga-0.79/powermanga.pro b/powermanga/powermanga-0.79/powermanga.pro
index e69de29bb2..d6c90290a5 100644
--- a/powermanga/powermanga-0.79/powermanga.pro
+++ b/powermanga/powermanga-0.79/powermanga.pro
@@ -0,0 +1,64 @@
+TEMPLATE = app
+CONFIG = qt warn_on release
+HEADERS = \
+ src/caractere.hpp \
+ src/cercle.hpp \
+ src/chaine.hpp \
+ src/etbfonte1.hpp \
+ src/gfxroutines.hpp \
+ src/linux.hpp \
+ src/powermanga.hpp \
+ src/score.hpp
+
+SOURCES = \
+ src/afficheEtoiles.cpp \
+ src/bonus.cpp \
+ src/caractere.cpp \
+ src/chaine.cpp \
+ src/congratulations.cpp \
+ src/courbe.cpp \
+ src/displayFonte.cpp \
+ src/eclairExecution.cpp \
+ src/ennemis_execution.cpp \
+ src/etbfonte1.cpp \
+ src/explosionExecution.cpp \
+ src/fntscrol.cpp \
+ src/gardien12.cpp \
+ src/gardien13.cpp \
+ src/gardien14.cpp \
+ src/gardiens.cpp \
+ src/gfxbase.cpp \
+ src/gfxroutines.cpp \
+ src/grille.cpp \
+ src/initialiseGameOver.cpp \
+ src/inits_game.cpp \
+ src/keymap.cpp \
+ src/linuxroutines.cpp \
+ src/main.cpp \
+ src/menu.cpp \
+ src/metors.cpp \
+ src/onde.cpp \
+ src/options.cpp \
+ src/playanim.cpp \
+ src/powermanga.cpp \
+ src/powmangasub1.cpp \
+ src/powmangasub2.cpp \
+ src/score.cpp \
+ src/sdl_mixer.cpp \
+ src/sdl_tlk.cpp \
+ src/special_enemy.cpp \
+ src/tirsExecutions.cpp \
+ src/tirsJoueur.cpp \
+ src/touchesTriches.cpp \
+ src/vaisseau.cpp \
+ src/xwindow.cpp
+
+INCLUDEPATH += $(QPEDIR)/include
+DEPENDPATH += $(QPEDIR)/include
+
+CFLAGS += `$(QPEDIR)/bin/sdl-config --cflags`
+LIBS += -lSDLmain -lSDL -lSDL_mixer -lpthread -lqpe
+OBJECTS_DIR = obj
+MOC_DIR = moc
+TARGET = powermanga
+VERSION = 0.79
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-18 15:37:44 +0000