예제 #1
0
void Clouds::display(float timeSinceLastFrame, const Matrix4& inverseViewProjection, const Matrix4& view,
						const Vector3& cameraDirection, const Vector3& cameraPosition, const Vector3& lightDir)
{
	glDisable(GL_DEPTH_TEST); 

	// through all the following passes the "read" buffer will be read

	// in the "write" buffer comes new data, that will be sorted
	// i'am hoping to maximes parallism this way: first the data will be upated, but everyone uses the old
	// then (still rendering) the upated particles will be sorted - frame ended, buffer switch
	// (so new data is used with a delay!)
	
	// move clouds
	moveClouds();
	// render fom
	renderFOM(inverseViewProjection, cameraDirection, cameraPosition, lightDir);
	// render clouds
	renderClouds(lightDir, view);
	// sort the new hopefully ready particles, while hopefully the screen itself is drawing
	particleSorting();

	// rotate read/write buffer
	swap(vao_cloudParticleBuffer_Read, vao_cloudParticleBuffer_Write);
	swap(vbo_cloudParticleBuffer_Read[0], vbo_cloudParticleBuffer_Write[0]);
	swap(vbo_cloudParticleBuffer_Read[1], vbo_cloudParticleBuffer_Write[1]);
	swap(vbo_cloudParticleBuffer_Read[2], vbo_cloudParticleBuffer_Write[2]);
}
예제 #2
0
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;
}