summaryrefslogtreecommitdiff
path: root/render.c
blob: a972c45349ca6068cb72eea70c3ac07feae3d34a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143


/* Different areas of the entities.png image contain different things.
 * For example the first row are player pictures whilst the second are
 * of echidnas.
 * 
 * 'SDL_Rect's are simple structures containing the location and size
 * of these individual pictures inside of the larger 'entities.png'
 * 
 * The same thing is done for the different level graphics
 */
 
// Sets the SDL_Rect * crop to the location of specified echinida
// ( there are four echidna pictures, so which_echidna can be 0-3)
void get_pixmap_echidna(int which_echidna, SDL_Rect * crop )
{
	crop->x = which_echidna * TILE_SIZE;
	crop->y = 1 * TILE_SIZE; // all echidnas are in the second row
}

// Same as above, but for the player (lemon)
void get_pixmap_lemon(int which_lemon, SDL_Rect * crop )
{
	crop->x = which_lemon * TILE_SIZE;
	crop->y = 0; // all lemons are in the first row
}

// Getting the rectangle for level tiles is a little harder, as they are spread
// across multiple rows.  Otherwise this does similarly to above modules
void get_pixmap_level( char number, SDL_Rect * crop )
{
	int row, column;
	
	row = 0;
	column = (int)number;
	
	// Compensate for the fact these pictures span multiple rows
	while ( column >= 4 )
	{
		column = column - 4;
		row++; // add one to row's value
	}
	
	crop->x = column * TILE_SIZE;
	crop->y = row * TILE_SIZE;
}




// render() paints everything onto the screen when called
void render(SDL_Renderer* renderer, struct level_struct *currentlevel)
{
	/* The picture on-screen is made in three steps:
	 *   1) Draw the level onto the screen surface
	 *   2) Draw the player and echidnas ontop of this
	 *   3) 'flip' the screen, so the changes can be seen
	 */
	 
	SDL_Rect destination; // where the image is going to be painted to on-screen
	SDL_Rect pixmap_crop; // where the tile image is on the source image
	destination.w = TILE_SIZE;
	destination.h = TILE_SIZE;
	pixmap_crop.w = TILE_SIZE;
	pixmap_crop.h = TILE_SIZE;
	
	/// Level drawing

	// ieterate through each square of the level, drawing the appropriate
	// pictures for each onto the screen
	
	int tilex, tiley; // Where we are up to
	
	for ( tiley=0; tiley < SCREEN_WIDTH_SQUARES; tiley++ )
	{
		for ( tilex=0; tilex < SCREEN_WIDTH_SQUARES; tilex++ )
		{
			/// Determine which section of the entities image we are going to use
			get_pixmap_level( currentlevel->squares[tilex][tiley] , &pixmap_crop );
			// remember that the currentlevel structure contains the array of 
			// level squares/tiles
		
			/// Determine where we are going to draw this image on-screen
			destination.x = tilex * TILE_SIZE;
			destination.y = tiley * TILE_SIZE;

			/// Render this tile onto the screen
			int ret = SDL_RenderCopy(renderer, currentlevel->tiles,
								&pixmap_crop,
								&destination);
			if (ret < 0 ) {
					printf("Error (SDL): %s: %s\n", "could not render copy tiles", SDL_GetError());
			}
		}
	}

	/// Entity drawing
	// First of all the character
	get_pixmap_lemon( currentlevel->player_face, &pixmap_crop );
	destination.x = currentlevel->px * TILE_SIZE;
	destination.y = currentlevel->py * TILE_SIZE;
	
	// Render onto screen
	SDL_RenderCopy(renderer, currentlevel->entities,
			&pixmap_crop,
			&destination);
	
	// Now draw all of the echidnas
	int ech_no; // Echidna number	 
	for ( ech_no = 0; ech_no < 10; ech_no++ )
	{
		struct echidna current_echidna = currentlevel->echidnas[ech_no];
		
		if ( current_echidna.this_echidna_exists == 1 )
		{
			// This echidnas exists and is alive
			
			// Get its location and face
			get_pixmap_echidna( current_echidna.face, &pixmap_crop );
			destination.x = current_echidna.xpos * TILE_SIZE;
			destination.y = current_echidna.ypos * TILE_SIZE;
			
			// Render it onscreen
			SDL_RenderCopy(renderer, currentlevel->entities,
					&pixmap_crop,
					&destination);
		}
	}
	
	// Flip screen, so everything we have 'blitted' can now be seen
	SDL_RenderPresent(renderer);
}

void render_a_losingscreen(SDL_Renderer* renderer, struct level_struct *currentlevel)
{
	// Render a losing screen
	SDL_RenderClear(renderer);
	SDL_RenderCopy(renderer, currentlevel->winning_screen, NULL, NULL);
	SDL_RenderPresent(renderer);
	
	// Wait a second so the user can see the losing screen
	SDL_Delay(2000);
}