[rbdr/pico-engine] / game_overwatch.cpp

 #include "stdafx.h"


Game_overwatch::Game_overwatch(){
    //Initialize our population
	head = NULL;
	population = 0;
}


void Game_overwatch::move_out(Actor *npc){
    
    //Moving out means killing a citizen from the citizen linked list.
    
	citizen *curr, *prev;
	prev = NULL;
	
	for(curr=head;curr!=NULL;prev=curr,curr=curr->next){
		if (curr->val == npc) {
			if (prev == NULL) {
				head = curr->next;
				std::cout << "I have deleted an NPC from the top!\n";
			} else {
				prev->next = curr->next;
				std::cout << "I have deleted an NPC from the middle!\n";
			}
			
			delete curr;
			
		}
	}
	population--;
}

void Game_overwatch::move_in(Actor * npc){
    //Moving in means adding a citizen to the linkd list.
    
	citizen *curr;
	curr = new citizen;
	curr->val = npc;
	curr->next = head;
	head=curr;
	population++;
}

int Game_overwatch::get_population(){
	return population;
}

void Game_overwatch::draw(SDL_Surface *viewport, Map *mainmap){
    
    //Generic draw function, iterates over the list and draws
    //each one of them.
    
    //NOTE: Further along it may be wise to allow Lua scripts to
    //      override the draw function and just call curr->draw();
    
	citizen *curr;
	curr = head;
	while (curr != NULL){
		Gfx::drawsurface(curr->val->get_clip_x(),curr->val->get_clip_y(),
						 curr->val->get_w(),curr->val->get_h(),
						 curr->val->get_sprite(),
						 curr->val->get_x()-mainmap->get_sx(),curr->val->get_y()-mainmap->get_sy(),
						 viewport);
		curr = curr->next;
	}
}

void Game_overwatch::act(SDL_Surface *viewport, Map *mainmap, bool keys[323]){
    
    //Iterates over the list and runs the "act" function from the lua script.
    
	citizen *curr;
	curr = head;
	while (curr != NULL){
		curr->val->move();
		handleinput(curr->val, keys);
		
		//do the lua thing.
		curr->val->SelectScriptFunction ("act");
		curr->val->Go ();
		
		curr = curr->next;
	}
}

void Game_overwatch::handleinput(Actor *actor, bool keys[323]){
    
    //Right now these actions just map keys to variables the scripts can use
    //In the future it will be wise to abstract the keys to what they do
    //Also, take into account gamepads.
    //Preferably, let lua handle this somehow.
    
	if(keys[SDLK_LEFT]){                                             
		if(leftkey == 0){
			leftkey = SDL_GetTicks();
		}                                                                           
	}else{
		leftkey = 0;
	}
	
	if(keys[SDLK_RIGHT]){            
		
		if(rightkey == 0){                                                  
			rightkey = SDL_GetTicks();    
		}
	}else{
		rightkey = 0;   
	}
	
	if(keys[SDLK_z]){            
		if(zkey == 0){                                                  
			zkey = SDL_GetTicks();    
		}
	}else{
		zkey = 0;   
	}
	
	if(keys[SDLK_x]){            
		if(xkey == 0){                                                  
			xkey = SDL_GetTicks();    
		}
	}else{
		xkey = 0;   
	}
	
	if(keys[SDLK_c]){            
		if(ckey == 0){                                                  
			ckey = SDL_GetTicks();    
		}
	}else{
		ckey = 0;   
	}
	
	actor->set_leftkey(leftkey);
	actor->set_rightkey(rightkey);
	actor->set_zkey(zkey);
	actor->set_xkey(xkey);
	actor->set_ckey(ckey);
}

void Game_overwatch::animate(){
    //Iterate and run the animate method.
    
	citizen *curr;
	curr = head;
	while (curr != NULL){
		curr->val->animate();
		curr = curr->next;
	}
}

void Game_overwatch::check_collisions(Map *mainmap){
	citizen *curr, *others;
	
	bool collided = false;
	curr = head;
	others = head->next;
	Actor *ac1, *ac2;
	
	//now check everyone. Never with itself.
    //It does line collisions, not corner collisions.
    
	while (curr != NULL){
		ac1 = curr->val;
		while (others != NULL) {
			ac2 = others->val;
			collided = false;
			if (curr->val != others->val) {
				if(Game_overwatch::line_colliding(ac1->get_x(), ac1->get_w(), 
												  ac1->get_y(), ac1->get_h(),
												  ac2->get_x(), ac2->get_w(), 
												  ac2->get_y(), ac2->get_h(), 
												  UP)){
					
					ac2->set_collision(true, DOWN);
					ac2->set_speed(ac1->get_ownspeed());
					ac2->set_vertical_speed(ac2->get_vertical_speed()+ac1->get_vertical_speed());
					
					ac1->set_collision(true, UP);
					collided = true;
				}
				if(Game_overwatch::line_colliding(ac1->get_x(), ac1->get_w(), 
												  ac1->get_y(), ac1->get_h(),
												  ac2->get_x(), ac2->get_w(), 
												  ac2->get_y(), ac2->get_h(), 
												  DOWN)){
					
					ac2->set_collision(true, UP);
					ac1->set_collision(true, DOWN);
					collided = true;
				}
				if(Game_overwatch::line_colliding(ac1->get_x(), ac1->get_w(), 
												  ac1->get_y(), ac1->get_h(),
												  ac2->get_x(), ac2->get_w(), 
												  ac2->get_y(), ac2->get_h(),
												  LEFT)){
					
					ac2->set_collision(true, RIGHT);
					ac1->set_collision(true, LEFT);
					collided = true;
				}
				if(Game_overwatch::line_colliding(ac1->get_x(), ac1->get_w(), 
												  ac1->get_y(), ac1->get_h(),
												  ac2->get_x(), ac2->get_w(), 
												  ac2->get_y(), ac2->get_h(), 
												  RIGHT)){
					
					ac2->set_collision(true, LEFT);
					ac1->set_collision(true, RIGHT);
					collided = true;
				}
			}
			
			others = others->next;
			if(collided){
				collision_callback(ac1, ac2);
			}
			
		}
		
        curr = curr->next;
        if (curr !=  NULL){
            others = curr->next;
        }
	}
}

void Game_overwatch::collision_callback(Actor *ac1, Actor *ac2){
	
	std::cout << "The collision has called ";
	
	if (ac1->get_enemy() == WEAPON && !ac2->get_dying()) {
		if (ac2->get_enemy() == EVIL) {
			ac1->set_dying(true);
			ac2->set_dying(true);
			
			
			std::cout << "And the shot has destroyed the enemy.";
		}
	}
	
	if (ac1->get_enemy() == SUPEREVIL) {
			ac2->set_dying(true);
			std::cout << "And the shot has destroyed the enemy.";
	}
	
	if (ac1->get_controllable()) {
		if (ac2->get_enemy() == EVIL) {
			ac1->set_dying(true);
			
			
			std::cout << "And the enemy has destroyed the main actor.";
		}
	}
	
	if (ac1->get_enemy() == EVIL) {
		if (ac2->get_controllable()) {
			ac2->set_dying(true);
			
			
			std::cout << "And the enemy has destroyed the main actor.";
		}
	}
	
	
	std::cout << "\n";
}


bool Game_overwatch::line_colliding(int x1, int w1, int y1, int h1, int x2, int w2, int y2, int h2, int direction){
	switch (direction) {
		case UP:
			if (y1 <= y2+h2 && y1 >= y2+(h2/2) &&
				((x1 > x2 && x1 < x2+w2) ||
				 (x1+w1 > x2 && x1+w2 < x2+w2))) {
					std::cout << "Foo' is collidin' top\n";
					return true;
				}
			break;
		case DOWN:
			if (y1+h1 >= y2 && y1+h1 <= y2+(h2/2) &&
				((x1 > x2 && x1 < x2+w2) ||
				 (x1+w1 > x2 && x1+w2 < x2+w2))) {
					std::cout << "Foo' is collidin' bottom\n";
					return true;
				}
			break;
		case LEFT:
			if (x1 <= x2+w2 && x1 >= x2+(w2/2) &&
				((y1 > y2 && y1 < y2+h2) ||
				 (y1+h1 > y2 && y1+h1 < y2+h2))) {
					std::cout << "Foo' is collidin' left\n";
					return true;
				}
			break;
		case RIGHT:
			if (x1+w1 >= x2 && x1+w1 <= x2+(w2/2) &&
				((y1 > y2 && y1 < y2+h2) ||
				 (y1+h1 > y2 && y1+h1 < y2+h2))) {
					std::cout << "Foo' is collidin' right\n";
					return true;
				}
			break;
	}	
	
	return false;
}

void Game_overwatch::handlephysics(Map *mainmap, int ticks1, int ticks2){
	citizen *curr;
	curr = head;
	while (curr != NULL){
		
		//some are not affected by physics.
		if(curr->val->get_physics()){
			//can it fall?
			if(curr->val->can_move(DOWN, curr->val->get_x(), curr->val->get_y())){
				
				//change sprite to its jump.
				switch(curr->val->get_oldclip()){
					case 1:
						curr->val->set_clip_y(curr->val->get_h()*0);
						break;
					case 2:   
						curr->val->set_clip_y(curr->val->get_h()*3);  
						break;            
				}
				
				//start the fall process
				if(curr->val->get_falltime() == 0){
					curr->val->set_falltime(.5);
				}else{
					curr->val->set_falltime(curr->val->get_falltime()+(ticks2-ticks1)/1000);
				}
				
			}else{
				
				//stop falling.
				curr->val->set_clip_y(curr->val->get_h()*curr->val->get_oldclip());
				curr->val->set_falltime(0);
				if(curr->val->get_vertical_speed() > 0){
					curr->val->set_vertical_speed(0);
				}
			}
			
			//check for top collision
			if( !curr->val->can_move(UP, curr->val->get_x(), curr->val->get_y()) && curr->val->get_vertical_speed() < 0){
				curr->val->set_vertical_speed(0);
			}
			
			//Avoid falling through the ground
			while(!curr->val->can_move(DOWN, curr->val->get_x(), curr->val->get_y()+curr->val->get_vertical_speed()) && curr->val->get_vertical_speed() > 0){
				curr->val->set_vertical_speed( curr->val->get_vertical_speed() - 1 );
			}
			
			//V=Vo+at
			curr->val->set_vertical_speed( curr->val->get_vertical_speed() + (GRAVITY*curr->val->get_falltime()));
			
			//translate.
			curr->val->set_y( curr->val->get_y() + curr->val->get_vertical_speed());
		}
		
		//NEXT
		curr = curr->next;
	}
}

void Game_overwatch::reset_collisions(){
	citizen *curr;
	curr = head;
	while (curr != NULL){
		curr->val->set_collision(false, LEFT);
		curr->val->set_collision(false, RIGHT);
		curr->val->set_collision(false, DOWN);
		curr->val->set_collision(false, UP);
		curr = curr->next;
	}
}

void Game_overwatch::dieloop(){
    
    //The kill loop:
    //  Every frame, we find out who needs to be killed
    //  We kill them all.
    
	citizen *curr;
	curr = head;
	while (curr != NULL){
		bool killthis = false;
		if ( curr->val->get_dying() ){
			killthis = true;
		}
		
		if (killthis){
			Actor *victim = curr->val;
			curr = curr->next;
			this->kill(victim);
		}else{
			curr = curr->next;
		}
	}
}

void Game_overwatch::kill(Actor *actor){
    
    //This should probably delegate to the lua die function
    //So it can animate/change states.
    
	if ( actor->get_controllable() ){
		actor->set_x(50);
		actor->set_y(100);
		actor->set_dying(false);
	}else{
		delete actor;
		actor = NULL;
	}
}
Commit	Line	Data
f631762a	1	#include "stdafx.h"
10a0e290 BB	2
	3
	4	Game_overwatch::Game_overwatch(){
	5	//Initialize our population
	6	head = NULL;
	7	population = 0;
	8	}
	9
	10
	11	void Game_overwatch::move_out(Actor *npc){
	12
	13	//Moving out means killing a citizen from the citizen linked list.
	14
	15	citizen curr, prev;
	16	prev = NULL;
	17
	18	for(curr=head;curr!=NULL;prev=curr,curr=curr->next){
	19	if (curr->val == npc) {
	20	if (prev == NULL) {
	21	head = curr->next;
	22	std::cout << "I have deleted an NPC from the top!\n";
	23	} else {
	24	prev->next = curr->next;
	25	std::cout << "I have deleted an NPC from the middle!\n";
	26	}
	27
	28	delete curr;
	29
	30	}
	31	}
	32	population--;
	33	}
	34
	35	void Game_overwatch::move_in(Actor * npc){
	36	//Moving in means adding a citizen to the linkd list.
	37
	38	citizen *curr;
	39	curr = new citizen;
	40	curr->val = npc;
	41	curr->next = head;
	42	head=curr;
	43	population++;
	44	}
	45
	46	int Game_overwatch::get_population(){
	47	return population;
	48	}
	49
	50	void Game_overwatch::draw(SDL_Surface viewport, Map mainmap){
	51
	52	//Generic draw function, iterates over the list and draws
	53	//each one of them.
	54
	55	//NOTE: Further along it may be wise to allow Lua scripts to
	56	// override the draw function and just call curr->draw();
	57
	58	citizen *curr;
	59	curr = head;
	60	while (curr != NULL){
	61	Gfx::drawsurface(curr->val->get_clip_x(),curr->val->get_clip_y(),
	62	curr->val->get_w(),curr->val->get_h(),
	63	curr->val->get_sprite(),
	64	curr->val->get_x()-mainmap->get_sx(),curr->val->get_y()-mainmap->get_sy(),
	65	viewport);
66	curr = curr->next;
67	}
68	}
69
70	void Game_overwatch::act(SDL_Surface viewport, Map mainmap, bool keys[323]){
71
72	//Iterates over the list and runs the "act" function from the lua script.
73
74	citizen *curr;
75	curr = head;
76	while (curr != NULL){
77	curr->val->move();
78	handleinput(curr->val, keys);
79
80	//do the lua thing.
81	curr->val->SelectScriptFunction ("act");
82	curr->val->Go ();
83
84	curr = curr->next;
85	}
86	}
87
88	void Game_overwatch::handleinput(Actor *actor, bool keys[323]){
89
90	//Right now these actions just map keys to variables the scripts can use
91	//In the future it will be wise to abstract the keys to what they do
92	//Also, take into account gamepads.
93	//Preferably, let lua handle this somehow.
94
95	if(keys[SDLK_LEFT]){
96	if(leftkey == 0){
97	leftkey = SDL_GetTicks();
98	}
99	}else{
100	leftkey = 0;
101	}
102
103	if(keys[SDLK_RIGHT]){
104
105	if(rightkey == 0){
106	rightkey = SDL_GetTicks();
107	}
108	}else{
109	rightkey = 0;
110	}
111
112	if(keys[SDLK_z]){
113	if(zkey == 0){
114	zkey = SDL_GetTicks();
115	}
116	}else{
117	zkey = 0;
118	}
119
120	if(keys[SDLK_x]){
121	if(xkey == 0){
122	xkey = SDL_GetTicks();
123	}
124	}else{
125	xkey = 0;
126	}
127
128	if(keys[SDLK_c]){
129	if(ckey == 0){
130	ckey = SDL_GetTicks();
131	}
132	}else{
133	ckey = 0;
134	}
135
136	actor->set_leftkey(leftkey);
137	actor->set_rightkey(rightkey);
138	actor->set_zkey(zkey);
139	actor->set_xkey(xkey);
140	actor->set_ckey(ckey);
141	}
142
143	void Game_overwatch::animate(){
144	//Iterate and run the animate method.
145
146	citizen *curr;
147	curr = head;
148	while (curr != NULL){
149	curr->val->animate();
150	curr = curr->next;
151	}
152	}
153
154	void Game_overwatch::check_collisions(Map *mainmap){
155	citizen curr, others;
156
157	bool collided = false;
158	curr = head;
159	others = head->next;
160	Actor ac1, ac2;
161
162	//now check everyone. Never with itself.
163	//It does line collisions, not corner collisions.
164
165	while (curr != NULL){
166	ac1 = curr->val;
167	while (others != NULL) {
168	ac2 = others->val;
169	collided = false;
170	if (curr->val != others->val) {
171	if(Game_overwatch::line_colliding(ac1->get_x(), ac1->get_w(),
172	ac1->get_y(), ac1->get_h(),
173	ac2->get_x(), ac2->get_w(),
174	ac2->get_y(), ac2->get_h(),
175	UP)){
176
177	ac2->set_collision(true, DOWN);
178	ac2->set_speed(ac1->get_ownspeed());
179	ac2->set_vertical_speed(ac2->get_vertical_speed()+ac1->get_vertical_speed());
180
181	ac1->set_collision(true, UP);
182	collided = true;
183	}
184	if(Game_overwatch::line_colliding(ac1->get_x(), ac1->get_w(),
185	ac1->get_y(), ac1->get_h(),
186	ac2->get_x(), ac2->get_w(),
187	ac2->get_y(), ac2->get_h(),
188	DOWN)){
189
190	ac2->set_collision(true, UP);
191	ac1->set_collision(true, DOWN);
192	collided = true;
193	}
194	if(Game_overwatch::line_colliding(ac1->get_x(), ac1->get_w(),
195	ac1->get_y(), ac1->get_h(),
196	ac2->get_x(), ac2->get_w(),
197	ac2->get_y(), ac2->get_h(),
198	LEFT)){
199
200	ac2->set_collision(true, RIGHT);
201	ac1->set_collision(true, LEFT);
202	collided = true;
203	}
204	if(Game_overwatch::line_colliding(ac1->get_x(), ac1->get_w(),
205	ac1->get_y(), ac1->get_h(),
206	ac2->get_x(), ac2->get_w(),
207	ac2->get_y(), ac2->get_h(),
208	RIGHT)){
209
210	ac2->set_collision(true, LEFT);
211	ac1->set_collision(true, RIGHT);
212	collided = true;
213	}
214	}
215
216	others = others->next;
217	if(collided){
218	collision_callback(ac1, ac2);
219	}
220
221	}
222
223	curr = curr->next;
224	if (curr != NULL){
225	others = curr->next;
226	}
227	}
228	}
229
230	void Game_overwatch::collision_callback(Actor ac1, Actor ac2){
231
232	std::cout << "The collision has called ";
233
234	if (ac1->get_enemy() == WEAPON && !ac2->get_dying()) {
235	if (ac2->get_enemy() == EVIL) {
236	ac1->set_dying(true);
237	ac2->set_dying(true);
238
239
240	std::cout << "And the shot has destroyed the enemy.";
241	}
242	}
243
244	if (ac1->get_enemy() == SUPEREVIL) {
245	ac2->set_dying(true);
246	std::cout << "And the shot has destroyed the enemy.";
247	}
248
249	if (ac1->get_controllable()) {
250	if (ac2->get_enemy() == EVIL) {
251	ac1->set_dying(true);
252
253
254	std::cout << "And the enemy has destroyed the main actor.";
255	}
256	}
257
258	if (ac1->get_enemy() == EVIL) {
259	if (ac2->get_controllable()) {
260	ac2->set_dying(true);
261
262
263	std::cout << "And the enemy has destroyed the main actor.";
264	}
265	}
266
267
268	std::cout << "\n";
269	}
270
271
272	bool Game_overwatch::line_colliding(int x1, int w1, int y1, int h1, int x2, int w2, int y2, int h2, int direction){
273	switch (direction) {
274	case UP:
275	if (y1 <= y2+h2 && y1 >= y2+(h2/2) &&
276	((x1 > x2 && x1 < x2+w2) \|\|
277	(x1+w1 > x2 && x1+w2 < x2+w2))) {
278	std::cout << "Foo' is collidin' top\n";
279	return true;
280	}
281	break;
282	case DOWN:
283	if (y1+h1 >= y2 && y1+h1 <= y2+(h2/2) &&
284	((x1 > x2 && x1 < x2+w2) \|\|
285	(x1+w1 > x2 && x1+w2 < x2+w2))) {
286	std::cout << "Foo' is collidin' bottom\n";
287	return true;
288	}
289	break;
290	case LEFT:
291	if (x1 <= x2+w2 && x1 >= x2+(w2/2) &&
292	((y1 > y2 && y1 < y2+h2) \|\|
293	(y1+h1 > y2 && y1+h1 < y2+h2))) {
294	std::cout << "Foo' is collidin' left\n";
295	return true;
296	}
297	break;
298	case RIGHT:
299	if (x1+w1 >= x2 && x1+w1 <= x2+(w2/2) &&
300	((y1 > y2 && y1 < y2+h2) \|\|
301	(y1+h1 > y2 && y1+h1 < y2+h2))) {
302	std::cout << "Foo' is collidin' right\n";
303	return true;
304	}
305	break;
306	}
307
308	return false;
309	}
310
311	void Game_overwatch::handlephysics(Map *mainmap, int ticks1, int ticks2){
312	citizen *curr;
313	curr = head;
314	while (curr != NULL){
315
316	//some are not affected by physics.
317	if(curr->val->get_physics()){
318	//can it fall?
319	if(curr->val->can_move(DOWN, curr->val->get_x(), curr->val->get_y())){
320
321	//change sprite to its jump.
322	switch(curr->val->get_oldclip()){
323	case 1:
324	curr->val->set_clip_y(curr->val->get_h()*0);
325	break;
326	case 2:
327	curr->val->set_clip_y(curr->val->get_h()*3);
328	break;
329	}
330
331	//start the fall process
332	if(curr->val->get_falltime() == 0){
333	curr->val->set_falltime(.5);
334	}else{
335	curr->val->set_falltime(curr->val->get_falltime()+(ticks2-ticks1)/1000);
336	}
337
338	}else{
339
340	//stop falling.
341	curr->val->set_clip_y(curr->val->get_h()*curr->val->get_oldclip());
342	curr->val->set_falltime(0);
343	if(curr->val->get_vertical_speed() > 0){
344	curr->val->set_vertical_speed(0);
345	}
346	}
347
348	//check for top collision
349	if( !curr->val->can_move(UP, curr->val->get_x(), curr->val->get_y()) && curr->val->get_vertical_speed() < 0){
350	curr->val->set_vertical_speed(0);
351	}
352
353	//Avoid falling through the ground
354	while(!curr->val->can_move(DOWN, curr->val->get_x(), curr->val->get_y()+curr->val->get_vertical_speed()) && curr->val->get_vertical_speed() > 0){
355	curr->val->set_vertical_speed( curr->val->get_vertical_speed() - 1 );
356	}
357
358	//V=Vo+at
359	curr->val->set_vertical_speed( curr->val->get_vertical_speed() + (GRAVITY*curr->val->get_falltime()));
360
361	//translate.
362	curr->val->set_y( curr->val->get_y() + curr->val->get_vertical_speed());
363	}
364
365	//NEXT
366	curr = curr->next;
367	}
368	}
369
370	void Game_overwatch::reset_collisions(){
371	citizen *curr;
372	curr = head;
373	while (curr != NULL){
374	curr->val->set_collision(false, LEFT);
375	curr->val->set_collision(false, RIGHT);
376	curr->val->set_collision(false, DOWN);
377	curr->val->set_collision(false, UP);
378	curr = curr->next;
379	}
380	}
381
382	void Game_overwatch::dieloop(){
383
384	//The kill loop:
385	// Every frame, we find out who needs to be killed
386	// We kill them all.
387
388	citizen *curr;
389	curr = head;
390	while (curr != NULL){
391	bool killthis = false;
392	if ( curr->val->get_dying() ){
393	killthis = true;
394	}
395
396	if (killthis){
397	Actor *victim = curr->val;
398	curr = curr->next;
399	this->kill(victim);
400	}else{
401	curr = curr->next;
402	}
403	}
404	}
405
406	void Game_overwatch::kill(Actor *actor){
407
408	//This should probably delegate to the lua die function
409	//So it can animate/change states.
410
411	if ( actor->get_controllable() ){
412	actor->set_x(50);
413	actor->set_y(100);
414	actor->set_dying(false);
415	}else{
416	delete actor;
417	actor = NULL;
418	}
f631762a	419	}