void greenAndRed(void){
greenDirection = 1;
interval = 2800;
level = 0;
extTIrqHandler = gnrTIrqHandler;
extKIrqHandler = gnrKIrqHandler;
lcdSetCursor(0,0);
lcdPixelsDraw(240*320, BACKGROUND_COLOUR);
lcdSetBackgroundColour(BACKGROUND_COLOUR);
lcdSetFontColour(BRICK_COLOUR);
lcdPrint(10,10, "LEVEL 0");
objectDraw(&brick, 50, 152);
objectDraw(&flier, 150, 10);
greenCounter = 0;
redCounter = 0;
timerSetMatch(interval);
while(1){
irqDisableSec();
lcdSetFontColour(BRICK_COLOUR);
lcdDrawChar(10, 246, (char)(greenCounter+48));
lcdSetFontColour(63, 0, 0);
lcdDrawChar(10, 294, (char)(redCounter+48));
irqEnableSec();
waitCycles(0x6fffff);
lcdFillWindow(10, 26, 246, 310, BACKGROUND_COLOUR);
waitCycles(0x6fffff);
}
}
void gnrKIrqHandler(){
if (kBuffer == 1 && brick.x > 0) {
objectMoveUp(&brick);
wait(1500);
} else if (kBuffer == 5 && brick.x < 224) {
objectMoveDown(&brick);
wait(1500);
}
if(brick.x>=150){
redCounter++;
wait(500000);
lcdFillWindow(brick.x, brick.x+brick.width - 1, brick.y, brick.y + brick.width - 1, BACKGROUND_COLOUR);
objectDraw(&brick, 50, 152);
}
if(kBuffer == 0) lcdDrawChar(30, 10, (char)150);
if(kBuffer == 4) lcdFillWindow(30, 46, 10, 26, BACKGROUND_COLOUR);
if(kBuffer == 8){
timerSetMatch(9800);
}
kBuffer = 16;
/*else if (kBuffer == 6 && brick.y < 304) {
objectMoveRight(&brick);
wait(750);
} else if (kBuffer == 4 && brick.y > 0) {
objectMoveLeft(&brick);
wait(750);
}*/
}
void gnrTIrqHandler()
{
if(greenDirection==0) objectMoveLeft(&flier);
else objectMoveRight(&flier);
if(flier.y==10) greenDirection=1;
else if(flier.y== (310-flier.width) && greenDirection!=0) greenDirection=0;
if(detectCollision(&brick, &flier)){
greenCounter++;
wait(500000);
lcdFillWindow(brick.x, brick.x+brick.width - 1, brick.y, brick.y + brick.width - 1, BACKGROUND_COLOUR);
objectDraw(&brick, 50, 152);
}
if(greenCounter>=5 || redCounter >= 5){
lcdSetFontColour(63, 0, 0);
if(greenCounter>=redCounter){
lcdPrint(112, 96, "SEHR GUT");
lcdFillWindow(10, 26, 106, 122, BACKGROUND_COLOUR);
lcdSetFontColour(BRICK_COLOUR);
if(flier.width >= 11){
flier.width-=10;
level++;
}
lcdDrawChar(10, 106, (char)(level+48));
}
else
lcdPrint(112, 56, "SEHR SCHLECHT");
wait(3000000);
lcdFillWindow(112, 128, 56, 264, BACKGROUND_COLOUR);
redCounter = 0;
greenCounter = 0;
}
return;
}
int startGame(SDL_Surface *screen, SDL_Event event, struct resolution res, int level)
{
// ============================== LEVEL-DATEI ==============================
char filepath[50];
sprintf(filepath, "resources/maps/level%d.map", level);
FILE *worldFile = fopen(filepath, "r");
if (worldFile == NULL)
return FAILURE;
char *line = NULL;
size_t len = 0;
char *tok = NULL;
// ============================== HINTERGRUND ==============================
Uint32 color = SDL_MapRGB( screen->format, 208, 244, 247 );
// ============================== WELT ==============================
// LEVEL-Block suchen
do
{getline(&line, &len, worldFile);}
while(strcmp(line, "==LEVEL==\n") != 0);
// erste Zeile: Größe des Levels
getline(&line, &len, worldFile);
tok = strtok(line, ",");
sscanf(tok, "%d", &worldSizeY);
tok = strtok(NULL, ",");
sscanf(tok, "%d", &worldSizeX);
unsigned char world[worldSizeY][worldSizeX];
int column = 0;
int row = 0;
// lese restliche Zeilen: das eigentliche Level
while (row < worldSizeY)
{
getline(&line, &len, worldFile);
tok = strtok(line, ",");
column = 0;
// lese einzelnen Elemente ein
while (tok)
{
sscanf(tok, "%d", (int *)&world[row][column]);
column++;
tok = strtok(NULL, ",");
}
row++;
}
// berechne Blockgröße
blockSize = res.height / worldSizeY;
// Gravitation
a = 0.6 * ((double) blockSize / 48);
// Counter zum Zeichnen der Welt
int x;
int y;
// Lade Grafik für die Blöcke
SDL_Surface *tmp = IMG_Load("resources/images/blockset.png");
if (tmp == NULL)
{
printf("Surface nicht geladen!\n");
printf("%s\n", SDL_GetError());
exit(-1);
}
else
printf("Surface wurde geladen\n");
// skaliere Grafik
SDL_Surface *blockset = shrinkSurface(tmp, blockSize * BLOCK_SET_WIDTH, blockSize * BLOCK_SET_HEIGHT);
SDL_FreeSurface(tmp);
// ============================== OBJEKTE ==============================
struct objectListElement *objectList = NULL;
// Variable zum Bearbeiten der Liste
struct objectListElement *liste;
// ============================== SPIELER ==============================
struct object player;
player.type = 0;
player.posX = 0;
player.posY = 0;
player.sizeX = ((double) 36/48) * blockSize;
player.sizeY = blockSize;
player.v = 0;
player.moveDir = 1;
player.moveSpeed = 0;
player.frame = 0;
// lade Grafik für den Spieler
SDL_Surface *tmp1 = IMG_Load("resources/images/player_final.png");
player.sprite = shrinkSurface(tmp1, (int)((double) 36/48 * blockSize * 10), blockSize*2);
SDL_FreeSurface(tmp1);
// ===== Position aus Leveldatei laden =====
// PLAYER-Block suchen
do
{getline(&line, &len, worldFile);}
while(strcmp(line, "==PLAYER==\n") != 0);
// erste Zeile: Position des Spielers
getline(&line, &len, worldFile);
tok = strtok(line, ",");
sscanf(tok, "%d", &player.posX);
player.posX *= blockSize;
tok = strtok(NULL, ",");
sscanf(tok, "%d", &player.posY);
player.posY *= blockSize;
objectAppend(&objectList, &player);
short playMoveLeft = 0;
short playMoveRight = 0;
unsigned int playerBlockX = 0;
unsigned int playerBlockY = 0;
unsigned int playerBlockXold = 0;
unsigned int playerBlockYold = 0;
unsigned char hitbox = 0;
// ============================== GEGNER ==============================
struct object *enemy;
// Lade Grafik für die Gegner
SDL_Surface *tmp2 = IMG_Load("resources/images/enemy.png");
SDL_Surface *enemySprite = shrinkSurface(tmp2, (int)((double) 36/48 * blockSize * 10), blockSize*2);
SDL_FreeSurface(tmp2);
// ENEMYS-Block suchen
do
{getline(&line, &len, worldFile);}
while(strcmp(line, "==ENEMYS==\n") != 0);
getline(&line, &len, worldFile);
while(strcmp(line, "\n") != 0)
{
enemy = (struct object*) malloc(sizeof(*enemy));
enemy->type = 1;
enemy->sizeX = (int) ((double) 36 / 48 * blockSize);
enemy->sizeY = blockSize;
enemy->v = 0;
enemy->moveDir = 1;
enemy->moveSpeed = 3;
enemy->frame = 0;
enemy->sprite = enemySprite;
// Zeile: Position des Gegners
tok = strtok(line, ",");
sscanf(tok, "%d", &enemy->posX);
enemy->posX *= blockSize;
tok = strtok(NULL, ",");
sscanf(tok, "%d", &enemy->posY);
enemy->posY *= blockSize;
objectAppend(&objectList, enemy);
getline(&line, &len, worldFile);
}
// ============================== TRIGGER ==============================
struct trigger *triggerList = NULL;
// TRIGGERS-Block suchen
do
{getline(&line, &len, worldFile);}
while(strcmp(line, "==TRIGGERS==\n") != 0);
getline(&line, &len, worldFile);
while(strcmp(line, "\n") != 0)
{
unsigned int triggerX;
unsigned int triggerY;
unsigned int targetX;
unsigned int targetY;
unsigned int targetBlock;
tok = strtok(line, ",");
sscanf(tok, "%u", &triggerX);
tok = strtok(NULL, ",");
sscanf(tok, "%u", &triggerY);
tok = strtok(NULL, ",");
sscanf(tok, "%u", &targetX);
tok = strtok(NULL, ",");
sscanf(tok, "%u", &targetY);
tok = strtok(NULL, ",");
sscanf(tok, "%u", &targetBlock);
triggerAppend(&triggerList, triggerX, triggerY, targetX, targetY, (unsigned char) targetBlock);
getline(&line, &len, worldFile);
}
// ============================== KAMERA ==============================
// Variable ist Global
camPosition.x = 0;
int camPositionXold = 0;
// ============================== PUNKTE ==============================
score = 0;
int scoreRender = 0;
SDL_Color scoreColor = {100,100,100,0};
char scoreString[7];
SDL_Surface *scoreText;
SDL_Rect scorePosition;
scorePosition.y = blockSize/2;
scorePosition.x = blockSize/2;
// Main-Loop
while(SDL_WaitEvent (&event))
{
switch(event.type)
{
// Quit-Event: quit-Flag setzen
case SDL_QUIT:
{
exitCode = EXIT_GAME;
goto cleanGame;
break;
}
// Timer-Event: Bildschirm neu zeichnen
case SDL_USEREVENT:
{
// ============================== LOGIK ==============================
// Spielersteuerung
if(playMoveLeft && playMoveRight == 0)
{player.moveDir = -1; player.moveSpeed = 3; }
else if(playMoveRight && playMoveLeft == 0)
{player.moveDir = 1; player.moveSpeed = 3;}
else
{player.moveSpeed = 0;}
// Bewegung für alle Objekte
liste=objectList;
objectCollisionAndGravity( liste->object, &world[0][0]);
while (liste->next != NULL)
{
liste=liste->next;
objectCollisionAndGravity( liste->object, &world[0][0]);
}
// Spieler in vertikaler Richtung aus der Welt
if(player.posY < 0-blockSize || player.posY > worldSizeY*blockSize)
{
exitCode = GAME_OVER;
goto cleanGame;
}
// Blocklogik
// Körpermitte
playerBlockX = (player.posX + player.sizeX / 2) / blockSize;
playerBlockY = (player.posY + player.sizeY / 2) / blockSize;
// spiele Block sound ab
playBlockSound(world[playerBlockY][playerBlockX]);
switch(world[playerBlockY][playerBlockX])
{
// Goldene Münze
case 50:
world[playerBlockY][playerBlockX] = 255;
score += 50;
break;
// Silberne Münze
case 51:
world[playerBlockY][playerBlockX] = 255;
score += 30;
break;
// Bronzefarbene Münze
case 52:
world[playerBlockY][playerBlockX] = 255;
score += 15;
break;
// Roter Schalter
case 53:
if(player.v > 0)
{
playBlockSound(BLOCKS);
world[playerBlockY][playerBlockX] = 54;
triggerRun(triggerList, &world[0][0], playerBlockX, playerBlockY);
score += 10;
}
break;
// Levelausgang
case 55:
exitCode = score;
goto cleanGame;
break;
// Leere Blöcke
case 255:
if(playerBlockX != playerBlockXold || playerBlockY != playerBlockYold)
{
triggerRun(triggerList, &world[0][0], playerBlockX, playerBlockY);
}
break;
}
playerBlockXold = playerBlockX;
playerBlockYold = playerBlockY;
// Füße
playerBlockX = (player.posX + player.sizeX / 2) / blockSize;
playerBlockY = (player.posY + player.sizeY - 1) / blockSize;
switch(world[playerBlockY][playerBlockX])
{
// Sprungfeder (Unten)
case 57:
playBlockSound(BLOCKS + 2);
player.v = 2 * -9 * ((double) blockSize / 48);
world[playerBlockY][playerBlockX] = 56;
break;
// Sprungfeder (Oben)
case 56:
if(player.v > 0)
{world[playerBlockY][playerBlockX] = 57;}
break;
}
// Kollision zwischen Spieler und Objekten
liste=objectList->next;
while (liste != NULL)
{
hitbox = objectCollisionToObject(&player, liste->object);
if(hitbox)
{
if((hitbox == 4 || hitbox == 8 || hitbox == 12) && player.v > 0)
{
playBlockSound(BLOCKS + 1);
player.v = -9 * ((double) blockSize / 48);
struct objectListElement *tmp = liste->next;
objectDelete(&objectList, liste);
liste = tmp;
score += 25;
}
else
{
exitCode = GAME_OVER;
goto cleanGame;
}
}
else
{
liste=liste->next;
}
}
// Kamera
camPositionXold = camPosition.x;
camPosition.x += ((player.posX - res.width / 2 + blockSize / 2) - camPosition.x) / 10;
if(camPosition.x < 0)
{camPosition.x = 0;}
else if(camPosition.x > worldSizeX*blockSize-res.width)
{camPosition.x = worldSizeX*blockSize-res.width;}
// ============================== RENDERN ==============================
// Lösche den Hintergrund
SDL_FillRect( screen, NULL, color );
// Wolken
renderClouds(screen, camPosition.x - camPositionXold);
// Zeichne alle Blöcke
for(y = 0; y < res.height/blockSize; y++)
{
for(x = camPosition.x/blockSize; x < camPosition.x/blockSize+res.width/blockSize+2; x++)
{
blockDraw(screen, blockset, x, y, blockGet(&world[0][0], x, y));
}
}
// Zeichne alle Objekte
liste=objectList;
objectDraw( screen, liste->object );
while (liste->next != NULL)
{
liste=liste->next;
objectDraw( screen, liste->object );
}
// Zeichne die Punktzahl
// Punktzahl einzeln Hochzählen
if(scoreRender < score)
{scoreRender++;}
sprintf(scoreString, "%06d", scoreRender);
scoreText = TTF_RenderText_Solid(font, scoreString, scoreColor);
SDL_BlitSurface(scoreText, NULL, screen, &scorePosition);
// Zeichne das berechnete Bild
SDL_Flip( screen );
break;
}
// Tasten gedrückt
case SDL_KEYDOWN:
{
switch(event.key.keysym.sym)
{
// Pfeil-Links
case SDLK_LEFT:
playMoveLeft = 1;
break;
// Pfeil-Rechts
case SDLK_RIGHT:
playMoveRight = 1;
break;
// Springen
case SDLK_SPACE:
if(player.v == 0)
{player.v = -9 * ((double) blockSize / 48);}
break;
case SDLK_UP:
if(player.v == 0)
{player.v = -9 * ((double) blockSize / 48);}
break;
#ifdef DEBUG
// Schwerkraft umkehren
case SDLK_q:
a *= -1;
break;
// W
case SDLK_w:
if(world[(player.posY + player.sizeY / 2) / blockSize - 1][(player.posX + player.sizeX / 2) / blockSize ] < 50)
{ world[(player.posY + player.sizeY / 2) / blockSize - 1][(player.posX + player.sizeX / 2) / blockSize ] = 255;}
else
{ world[(player.posY + player.sizeY / 2) / blockSize - 1][(player.posX + player.sizeX / 2) / blockSize ] = 4;}
break;
// S
case SDLK_s:
if(world[(player.posY + player.sizeY / 2) / blockSize + 1][(player.posX + player.sizeX / 2) / blockSize ] < 50)
{ world[(player.posY + player.sizeY / 2) / blockSize + 1][(player.posX + player.sizeX / 2) / blockSize ] = 255;}
else
{ world[(player.posY + player.sizeY / 2) / blockSize + 1][(player.posX + player.sizeX / 2) / blockSize ] = 4;}
break;
// A
case SDLK_a:
if(world[(player.posY + player.sizeY / 2) / blockSize ][(player.posX + player.sizeX / 2) / blockSize - 1] < 50)
{ world[(player.posY + player.sizeY / 2) / blockSize ][(player.posX + player.sizeX / 2) / blockSize - 1] = 255;}
else
{ world[(player.posY + player.sizeY / 2) / blockSize ][(player.posX + player.sizeX / 2) / blockSize - 1] = 4;}
break;
// D
case SDLK_d:
if(world[(player.posY + player.sizeY / 2) / blockSize ][(player.posX + player.sizeX / 2) / blockSize + 1] < 50)
{ world[(player.posY + player.sizeY / 2) / blockSize ][(player.posX + player.sizeX / 2) / blockSize + 1] = 255;}
else
{ world[(player.posY + player.sizeY / 2) / blockSize ][(player.posX + player.sizeX / 2) / blockSize + 1] = 4;}
break;
#endif
// Escape
case SDLK_ESCAPE:
exitCode = EXIT_LEVEL;
goto cleanGame;
break;
// alles andere ignorieren
default:
break;
}
break;
}
// Taste losgelassen
case SDL_KEYUP:
{
switch(event.key.keysym.sym)
{
case SDLK_LEFT:
playMoveLeft = 0;
break;
case SDLK_RIGHT:
playMoveRight = 0;
break;
default:
break;
}
break;
}
}
}
cleanGame:
// ============================== AUFRÄUMEN ==============================
printf("Gebe Speicher frei ...");
SDL_FreeSurface(blockset);
SDL_FreeSurface(player.sprite);
SDL_FreeSurface(enemySprite);
printf(" done\n");
return exitCode;
}
tMenuOption playAnimation(int id) {
/* Declare variables */
int imgCount, objCount, sndCount, i;
animImage* img; animObject* obj; animSound* snd;
titleImage* imgArray; titleObject* objArray; /*animSound* sndArray;*/
int imgsActive=0; int objsActive=0; /*int sndsActive=0;*/
int imgTotal, objTotal, sndTotal;
tKey key=inputCreateKey();
tKey nullKey=inputCreateKey();
/* Initialize animation and allocate memory */
animStart(id,&imgTotal,&objTotal,&sndTotal);
imgArray=(titleImage*)malloc(imgTotal*sizeof(titleImage));
objArray=(titleObject*)malloc(objTotal*sizeof(titleObject));
/*sndArray=(animSound*)malloc(sndTotal*sizeof(animSound));*/
/* main animation kernel loop */
while (animGetFrame(&imgCount,&objCount,&sndCount,&img,&obj,&snd)) {
int reprocessInput=1;
while(reprocessInput) {
if (!inputGetEvent(&key)) {
/* key pressed */
/* if there is an action and the action wasn't control key */
if (key.actionPerformed!=none && !(inputGetCtrl(key.status)&&key.actionPerformed==other))
return getAction(key);
} else {
reprocessInput=0;
/* create new images/objects/sounds */
for (i=0;i<imgCount;i++) { /*images*/
imgArray[imgsActive].img=resLoad(img[i].res);
if (!imgArray[imgsActive].img) {
fprintf(stderr,"resource coudn't be loaded.");
return menuQuit;
}
imgArray[imgsActive].y=img[i].y;
imgArray[imgsActive].x=img[i].x;
imgArray[imgsActive].layer=img[i].layer;
imgArray[imgsActive].duration=img[i].duration;
imgsActive++;
}
for (i=0;i<objCount;i++) { /*objects*/
objArray[objsActive].obj=objectCreate(obj[i].location,obj[i].floor,DIR_LEFT,obj[i].state,obj[i].res,obj[i].cacheMirror,oGeneric);
objArray[objsActive].active=1;
objArray[objsActive].duration=obj[i].duration;
objsActive++;
}
/* TODO: code sounds
* for (i=0;i<sndCount;i++) {
sndArray[sndsActive]=snd[i];
sndsActive++;
}*/
outputClearScreen();
/* The bottom layer */
for (i=0;i<imgsActive;i++) {
if (imgArray[i].layer==ANIMS_LAYERTYPE_BOTTOM)
outputDrawBitmap(imgArray[i].img->pFrames[0], imgArray[i].x, imgArray[i].y);
}
/* move objects */
for (i=0;i<objsActive;i++) {
/*TODO: detect exits */
if (objArray[i].active) {
int exitCode;
exitCode=objectMove(&(objArray[i].obj),nullKey,NULL);
if (objArray[i].duration) objArray[i].duration--;
/* detect exited states and destroy them */
/* if the time is over or exit code detected */
if ((objArray[i].duration==1)||(exitCode<0)) {
/*printf("exit Code detected: i=%d exit=%d \n",i,exitCode);*/
objectFree(&objArray[i].obj);
objArray[i].active=0; /* remember it is destroyed */
} else {
objectDraw(&objArray[i].obj);
}
}
}
/* The top layer */
for (i=0;i<imgsActive;i++) {
if (imgArray[i].layer==ANIMS_LAYERTYPE_TOP) {
outputDrawBitmap(imgArray[i].img->pFrames[0], imgArray[i].x, imgArray[i].y);
}
}
outputUpdateScreen();
/* caducied backgrounds destruction */
i=imgsActive;
while(i) {
i--;
if (imgArray[i].duration) { /* if not 0 (infinite) */
imgArray[i].duration--;
if (!imgArray[i].duration) { /* time is over for this images */
imgsActive--;
resFree(imgArray[i].img);
imgArray[i]=imgArray[imgsActive];
}
}
} }
}
}
for (i=0;i<objsActive;i++) if (objArray[i].active) objectFree(&objArray[i].obj);
for (i=0;i<imgsActive;i++) resFree(imgArray[i].img);
free(imgArray);
free(objArray);
/*free(sndArray);*/
return menuQuit;
}
