Debian Codegraph @

src/brain.cpp

raw
1 /**
2 * Brains - Sprites AI
3
4 * Copyright (C) 1997, 1998, 1999, 2002, 2003 Seth A. Robinson
5 * Copyright (C) 2005, 2007, 2008, 2009, 2014, 2015 Sylvain Beucler
6
7 * This file is part of GNU FreeDink
8
9 * GNU FreeDink is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License as
11 * published by the Free Software Foundation; either version 3 of the
12 * License, or (at your option) any later version.
13
14 * GNU FreeDink is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18
19 * You should have received a copy of the GNU General Public License
20 * along with this program. If not, see
21 * <http://www.gnu.org/licenses/>.
22 */
23
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include "brain.h"
29 #include "live_sprites_manager.h"
30 #include "game_engine.h" /* smooth_follow */
31 #include "dinkc.h"
32 #include "gfx_sprites.h"
33 #include "log.h"
34
35 /*bool*/int check_for_kill_script(int i)
36 {
37 if (spr[i].script > 0)
38 {
39 //if ( (spr[i].brain == 0) | (spr[i].brain == 5) | (spr[i].brain == 6) | (spr[i].brain == 7))
40
41 if (locate(spr[i].script, "DIE")) run_script(spr[i].script);
42
43 return(/*true*/1);
44 }
45
46 return(/*false*/0);
47 }
48
49 void add_kill_sprite(int h)
50 {
51 if ( (spr[h].dir > 9) || (spr[h].dir < 1) )
52 {
53 log_error("Changing sprites dir from %d (!?) to 3.", spr[h].dir);
54 spr[h].dir = 3;
55
56 }
57
58
59 int dir = spr[h].dir;
60 int base = spr[h].base_die;
61
62 //Msg("Base die is %d", base);
63 if (base == -1)
64 {
65
66 if (seq[spr[h].base_walk+5].is_active)
67 {
68 add_exp(spr[h].exp, h);
69
70 int crap2 = add_sprite(spr[h].x,spr[h].y,5,spr[h].base_walk +5,1);
71 spr[crap2].speed = 0;
72 spr[crap2].seq = spr[h].base_walk + 5;
73 // set corpse size to the original sprite size
74 spr[crap2].size = spr[h].size;
75 return;
76 } else
77 {
78 dir = 0;
79 base = 164;
80
81 }
82 }
83
84
85
86 if (!seq[base+dir].is_active)
87 {
88
89 if (dir == 1) dir = 9;
90 else if (dir == 3) dir = 7;
91 else if (dir == 7) dir = 3;
92 else if (dir == 9) dir = 1;
93
94 else if (dir == 4) dir = 6;
95 else if (dir == 6) dir = 4;
96 else if (dir == 8) dir = 2;
97 else if (dir == 2) dir = 8;
98
99
100 }
101 if (!seq[base+dir].is_active)
102
103 {
104 log_error("Can't make a death sprite for dir %d!", base+dir);
105 }
106
107
108
109 int crap2 = add_sprite(spr[h].x,spr[h].y,5,base +dir,1);
110 spr[crap2].speed = 0;
111 spr[crap2].base_walk = 0;
112 spr[crap2].seq = base + dir;
113
114 if (base == 164) spr[crap2].brain = 7;
115
116 spr[crap2].size = spr[h].size;
117
118 add_exp(spr[h].exp, h);
119
120 }
121
122
123 int get_distance_and_dir_smooth(int h, int h1, int *dir)
124 {
125 unsigned int x_diff = abs(spr[h].x - spr[h1].x);
126 unsigned int y_diff = abs(spr[h].y - spr[h1].y);
127
128 if (spr[h].x < spr[h1].x)
129 {
130 if (spr[h].y < spr[h1].y)
131 {
132 // 6, 3, 2
133 if (y_diff * 4 < x_diff)
134 *dir = 6;
135 else if (x_diff * 4 < y_diff)
136 *dir = 2;
137 else
138 *dir = 3;
139 }
140 else if (spr[h].y > spr[h1].y)
141 {
142 // 4, 9, 8
143 if (y_diff * 4 < x_diff)
144 *dir = 6;
145 else if (x_diff * 4 < y_diff)
146 *dir = 8;
147 else
148 *dir = 9;
149 }
150 else
151 {
152 *dir = 6;
153 }
154 }
155 else if (spr[h].x > spr[h1].x)
156 {
157 if (spr[h].y < spr[h1].y)
158 {
159 // 4, 1, 2
160 if (y_diff * 4 < x_diff)
161 *dir = 4;
162 else if (x_diff * 4 < y_diff)
163 *dir = 2;
164 else
165 *dir = 1;
166 }
167 else if (spr[h].y > spr[h1].y)
168 {
169 // 4, 7, 8
170 if (y_diff * 4 < x_diff)
171 *dir = 4;
172 else if (x_diff * 4 < y_diff)
173 *dir = 8;
174 else
175 *dir = 7;
176 }
177 else
178 {
179 *dir = 4;
180 }
181 }
182 else
183 {
184 if (spr[h].y < spr[h1].y)
185 *dir = 2;
186 else if (spr[h].y > spr[h1].y)
187 *dir = 8;
188 }
189
190 return (x_diff > y_diff) ? x_diff : y_diff;
191 }
192
193 int get_distance_and_dir_nosmooth(int h, int h1, int *dir)
194 {
195 int distancex = 5000;
196 int distancey = 5000;
197 /* Arbitrarily set to 6 to avoid uninitialized values; don't set to
198 5, because *dir is added to e.g. base_attack to get the right
199 sequence - with 5, you get the dead/corpse sequence instead of an
200 attack sequence.. */
201 int dirx = 6;
202 int diry = 6;
203
204 if ((spr[h].x > spr[h1].x) && ((spr[h].x - spr[h1].x) < distancex))
205 {
206 distancex = spr[h].x - spr[h1].x;
207 dirx = 4;
208 }
209 if ((spr[h].x < spr[h1].x) && ((spr[h1].x - spr[h].x) < distancex))
210 {
211 distancex = spr[h1].x - spr[h].x;
212 dirx = 6;
213 }
214
215 if ((spr[h].y > spr[h1].y) && ((spr[h].y - spr[h1].y) < distancey))
216 {
217 distancey = spr[h].y - spr[h1].y;
218 diry = 8;
219 }
220 if ((spr[h].y < spr[h1].y) && ((spr[h1].y - spr[h].y) < distancey))
221 {
222 distancey = spr[h1].y - spr[h].y;
223 diry = 2;
224 }
225
226 if (distancex > distancey)
227 {
228 *dir = dirx;
229 return distancex;
230 }
231 else
232 {
233 *dir = diry;
234 return distancey;
235 }
236 }
237 int get_distance_and_dir(int h, int h1, int *dir)
238 {
239 if (smooth_follow == 1)
240 return get_distance_and_dir_smooth(h, h1, dir);
241 else
242 return get_distance_and_dir_nosmooth(h, h1, dir);
243 }
244
245
246 void change_dir_to_diag( int *dir)
247 {
248 if (*dir == 8) *dir = 7;
249 if (*dir == 4) *dir = 1;
250 if (*dir == 2) *dir = 3;
251 if (*dir == 6) *dir = 9;
252 }
253
254
255
256 void process_follow(int h)
257 {
258 if (spr[h].follow > 299)
259 {
260 log_error("Sprite %d cannot 'follow' sprite %d??",h,spr[h].follow);
261 return;
262 }
263
264 if (!spr[spr[h].follow].active)
265 {
266 log_debug("Killing follow");
267 spr[h].follow = 0;
268 return;
269 }
270
271 int dir;
272 int distance = get_distance_and_dir(h, spr[h].follow, &dir);
273
274 if (distance < 40) return;
275
276 changedir(dir,h,spr[h].base_walk);
277 automove(h);
278 }
279
280
281
282 void done_moving(int h)
283 {
284
285 spr[h].move_active = /*false*/0;
286
287 spr[h].move_nohard = /*false*/0;
288
289 if (spr[h].move_script > 0)
290 {
291 // Msg("mover running script %d..", spr[h].move_script);
292 run_script(spr[h].move_script);
293 }
294
295
296
297 }
298
299 void process_move(int h)
300 {
301
302 // Msg("Proccesing sprite %d, dir %d (script is %d)", h, spr[h].dir, spr[h].move_script);
303
304
305
306 if ((spr[h].move_dir == 4) | (spr[h].move_dir == 1) | (spr[h].move_dir == 7) )
307 {
308 if (spr[h].x <= spr[h].move_num)
309 {
310 //done moving
311 done_moving(h);
312 return;
313 }
314 changedir(spr[h].move_dir,h,spr[h].base_walk);
315 automove(h);
316 }
317
318 if ( (spr[h].move_dir == 6) | (spr[h].move_dir == 9) | (spr[h].move_dir == 3))
319 {
320 if (spr[h].x >= spr[h].move_num)
321 {
322 //done moving
323 done_moving(h);
324 return;
325 }
326 changedir(spr[h].move_dir,h,spr[h].base_walk);
327 automove(h);
328 }
329
330
331 if (spr[h].move_dir == 2)
332 {
333 if (spr[h].y >= spr[h].move_num)
334 {
335 //done moving
336 done_moving(h);
337 return;
338 }
339 changedir(spr[h].move_dir,h,spr[h].base_walk);
340 automove(h);
341 }
342
343
344 if (spr[h].move_dir == 8)
345 {
346 if (spr[h].y <= spr[h].move_num)
347 {
348 //done moving
349 done_moving(h);
350 return;
351 }
352 changedir(spr[h].move_dir,h,spr[h].base_walk);
353 automove(h);
354 }
355 }
356
357 void draw_damage(int h)
358 {
359 int crap2 = add_sprite(spr[h].x,spr[h].y,8,0,0);
360
361 spr[crap2].y -= k[seq[spr[h].pseq].frame[spr[h].pframe]].yoffset;
362 spr[crap2].x -= k[seq[spr[h].pseq].frame[spr[h].pframe]].xoffset;
363 spr[crap2].y -= k[seq[spr[h].pseq].frame[spr[h].pframe]].box.bottom / 3;
364 spr[crap2].x += k[seq[spr[h].pseq].frame[spr[h].pframe]].box.right / 5;
365
366 spr[crap2].speed = 1;
367 spr[crap2].hard = 1;
368 spr[crap2].brain_parm = h;
369 spr[crap2].my = -1;
370 spr[crap2].kill_ttl = 1000;
371 spr[crap2].dir = 8;
372 spr[crap2].damage = spr[h].damage;
373 }
374
375
376
377 void changedir( int dir1, int k,int base)
378 {
379 int hspeed;
380 int speed_hold = spr[k].speed;
381 if (k > 1) if (spr[k].brain != 9) if (spr[k].brain != 10)
382 {
383 hspeed = spr[k].speed * (base_timing / 4);
384 if (hspeed > 49)
385 {
386 log_debug("Speed was %d", hspeed);
387 spr[k].speed = 49;
388 } else
389 spr[k].speed = hspeed;
390 }
391 int old_seq = spr[k].seq;
392 spr[k].dir = dir1;
393
394 if (dir1 == 1)
395 {
396 spr[k].mx = (0 - spr[k].speed ) + (spr[k].speed / 3);
397 spr[k].my = spr[k].speed - (spr[k].speed / 3);
398
399 if (base != -1)
400 {
401
402
403 spr[k].seq = base + 1;
404 if (!seq[spr[k].seq].is_active)
405 {
406 spr[k].seq = base + 9;
407
408 }
409
410 }
411
412 if (old_seq != spr[k].seq)
413 {
414 spr[k].frame = 0;
415 spr[k].delay = 0;
416 }
417
418
419 }
420
421 if (dir1 == 2)
422 {
423 spr[k].mx = 0;
424 spr[k].my = spr[k].speed;
425 if (base != -1)
426 spr[k].seq = base + 2;
427
428 if (!seq[spr[k].seq].is_active && seq[base+3].is_active)
429 spr[k].seq = base + 3;
430 if (!seq[spr[k].seq].is_active && seq[base+1].is_active)
431 spr[k].seq = base + 1;
432
433
434 if (old_seq != spr[k].seq)
435 {
436 spr[k].frame = 0;
437 spr[k].delay = 0;
438 }
439
440
441 }
442 if (dir1 == 3)
443 {
444 spr[k].mx = spr[k].speed - (spr[k].speed / 3);
445 spr[k].my = spr[k].speed - (spr[k].speed / 3);
446 if (base != -1)
447 {
448 spr[k].seq = base + 3;
449 if (!seq[spr[k].seq].is_active)
450 spr[k].seq = base + 7;
451
452 }
453
454 if (old_seq != spr[k].seq)
455 {
456 spr[k].frame = 0;
457 spr[k].delay = 0;
458 }
459
460
461 }
462
463 if (dir1 == 4)
464 {
465
466 //Msg("Changing %d to four..",k);
467 spr[k].mx = (0 - spr[k].speed);
468 spr[k].my = 0;
469 if (base != -1)
470 spr[k].seq = base + 4;
471 if (!seq[spr[k].seq].is_active && seq[base+7].is_active)
472 spr[k].seq = base + 7;
473 if (!seq[spr[k].seq].is_active && seq[base+1].is_active)
474 spr[k].seq = base + 1;
475 }
476
477 if (dir1 == 6)
478 {
479 spr[k].mx = spr[k].speed;
480 spr[k].my = 0;
481 if (base != -1)
482 spr[k].seq = base + 6;
483
484 if (!seq[spr[k].seq].is_active && seq[base+3].is_active)
485 spr[k].seq = base + 3;
486 if (!seq[spr[k].seq].is_active && seq[base+9].is_active)
487 spr[k].seq = base + 9;
488
489 }
490
491 if (dir1 == 7)
492 {
493 spr[k].mx = (0 - spr[k].speed) + (spr[k].speed / 3);
494 spr[k].my = (0 - spr[k].speed)+ (spr[k].speed / 3);
495 if (base != -1)
496 {
497 spr[k].seq = base + 7;
498
499
500 if (!seq[spr[k].seq].is_active)
501 spr[k].seq = base + 3;
502 }
503
504 }
505 if (dir1 == 8)
506 {
507 spr[k].mx = 0;
508 spr[k].my = (0 - spr[k].speed);
509 if (base != -1)
510 spr[k].seq = base + 8;
511
512 if (!seq[spr[k].seq].is_active && seq[base+7].is_active)
513 spr[k].seq = base + 7;
514 if (!seq[spr[k].seq].is_active && seq[base+9].is_active)
515 spr[k].seq = base + 9;
516
517 }
518
519
520 if (dir1 == 9)
521 {
522 spr[k].mx = spr[k].speed- (spr[k].speed / 3);
523 spr[k].my = (0 - spr[k].speed)+ (spr[k].speed / 3);
524 if (base != -1)
525 {
526 spr[k].seq = base + 9;
527 if (!seq[spr[k].seq].is_active)
528 spr[k].seq = base + 1;
529 }
530 }
531
532
533
534 if (old_seq != spr[k].seq)
535 {
536 spr[k].frame = 0;
537 spr[k].delay = 0;
538 }
539
540
541 if (!seq[spr[k].seq].is_active)
542 {
543 //spr[k].mx = 0;
544 //spr[k].my = 0;
545 spr[k].seq = old_seq;
546
547 }
548
549 //Msg("Leaving with %d..", spr[k].dir);
550
551 //Msg("Changedir: Tried to switch sprite %d to dir %d",k,dir1);
552
553 spr[k].speed = speed_hold;
554
555 }
556
557 void automove (int j)
558 {
559
560 char kindx,kindy;
561 int speedx = 0;
562 int speedy = 0;
563
564
565
566
567 if (spr[j].mx != 0)
568 {
569 if (spr[j].mx < 0)
570 kindx = '-'; else kindx = '+';
571 if (kindx == '-') speedx = (spr[j].mx - (spr[j].mx * 2)); else
572 speedx = spr[j].mx;
573 } else kindx = '0';
574
575 if (spr[j].my != 0)
576 {
577 if (spr[j].my < 0)
578 kindy = '-'; else kindy = '+';
579 if (kindy == '-') speedy = (spr[j].my - (spr[j].my * 2)); else
580 speedy = spr[j].my;
581
582 } else kindy = '0';
583
584 int speed = speedx;
585 if (speedy > speedx) speed = speedy;
586 if (speed > 0)
587 move(j,speed,kindx,kindy);
588 //move(j, 1, '+','+');
589
590 }
591
592 void move(int u, int amount, char kind, char kindy)
593 {
594 int mx = 0;
595 int my = 0;
596 int i;
597 /*bool*/int clearx;
598 /*bool*/int cleary;
599 clearx = /*false*/0;
600 cleary = /*false*/0;
601
602 for (i = 1; i <= amount; i++)
603 {
604 spr[u].moveman++;
605 if (mx >= spr[u].mx) clearx = /*true*/1;
606 if (my >= spr[u].my) clearx = /*true*/1;
607
608 if ((clearx) && (cleary))
609 {
610 mx = 0;
611 my = 0;
612 clearx = /*false*/0;
613 cleary = /*false*/0;
614
615 }
616
617
618 if (kind == '+')
619 {
620 if (mx < spr[u].mx)
621 spr[u].x++;
622 mx++;
623
624 }
625 if (kind == '-')
626 {
627
628
629 if (mx < (spr[u].mx - (spr[u].mx * 2)))
630 spr[u].x--;
631 mx++;
632 }
633
634 if (kindy == '+')
635 {
636
637 if (my < spr[u].my)
638 spr[u].y++;
639 my++;
640 }
641 if (kindy == '-')
642 {
643
644 if (my < (spr[u].my - (spr[u].my * 2)))
645 spr[u].y--;
646 my++;
647 }
648
649 spr[u].lpx[spr[u].moveman] = spr[u].x;
650 spr[u].lpy[spr[u].moveman] = spr[u].y;
651 }
652
653
654 }
655
656
657 int autoreverse(int j)
658 {
659 //Msg("reversing die %d",spr[j].dir);
660 int r = ((rand() % 2)+1);
661 if ( (spr[j].dir == 1) || (spr[j].dir == 2) )
662 {
663 if (r == 1)
664 return(8);
665 if (r == 2)
666 return(6);
667
668 }
669
670 if ( (spr[j].dir == 3) || (spr[j].dir == 6) )
671 {
672 if (r == 1)
673 return(2);
674 if (r == 2)
675
676 return(4);
677
678 }
679
680 if ( (spr[j].dir == 9) || (spr[j].dir == 8) )
681 {
682 if (r == 1)
683 return(2);
684 if (r == 2)
685
686 return(6);
687
688
689 }
690
691 if ( (spr[j].dir == 7) || (spr[j].dir == 4) )
692 {
693 if (r == 1)
694 return(8);
695 if (r == 2)
696 return(6);
697
698 }
699
700 return(0);
701 }
702
703
704 int autoreverse_diag(int j)
705 {
706 if (spr[j].dir == 0) spr[j].dir = 7;
707 int r = ((rand() % 2)+1);
708
709 if ( (spr[j].dir == 1) || (spr[j].dir == 3) )
710 {
711
712 if (r == 1)
713 return(9);
714 if (r == 2)
715 return(7);
716 }
717
718 if ( (spr[j].dir == 3) || (spr[j].dir == 6) )
719 {
720 if (r == 1)
721 return(7);
722 if (r == 2)
723 return(1);
724
725 }
726
727 if ( (spr[j].dir == 9) || (spr[j].dir == 8) )
728 {
729 if (r == 1)
730 return(1);
731 if (r == 2)
732 return(7);
733 }
734
735 if ( (spr[j].dir == 7) || (spr[j].dir == 4) )
736 {
737 if (r == 1)
738 return(3);
739 if (r == 2)
740 return(9);
741
742 }
743
744 log_debug("Auto Reverse Diag was sent a dir %d sprite, base %d walk.",spr[j].dir, spr[j].base_walk);
745 return(0);
746 }