--- /dev/null
+// SVG Spacewar is copyright 2005 by Nigel Tao: nigel.tao@myrealbox.com
+// Licenced under the GNU GPL.
+// Developed on cairo version 0.4.0.
+//
+// 2005-03-31: Version 0.1.
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
+#include <sys/timeb.h>
+
+#define WIDTH 800
+#define HEIGHT 600
+
+#define TWO_PI (2*M_PI)
+#define PI (M_PI)
+
+// trig computations (and x, y, velocity, etc). are made in fixed point arithmetic
+#define FIXED_POINT_SCALE_FACTOR 1024
+#define FIXED_POINT_HALF_SCALE_FACTOR 32
+
+// discretization of 360 degrees
+#define NUMBER_OF_ROTATION_ANGLES 60
+#define RADIANS_PER_ROTATION_ANGLE (TWO_PI / NUMBER_OF_ROTATION_ANGLES)
+
+// equivalent to 25 fps
+#define MILLIS_PER_FRAME 40
+
+// a shot every 9/25 seconds = 8 ticks between shots
+#define TICKS_BETWEEN_FIRE 8
+
+// fudge this for bigger or smaller ships
+#define GLOBAL_SHIP_SCALE_FACTOR 0.8
+
+#define SHIP_ACCELERATION_FACTOR 1
+#define SHIP_MAX_VELOCITY (10 * FIXED_POINT_SCALE_FACTOR)
+#define SHIP_RADIUS ((int) (38 * FIXED_POINT_SCALE_FACTOR * GLOBAL_SHIP_SCALE_FACTOR))
+
+#define SHIP_MAX_ENERGY 1000
+#define DAMAGE_PER_MISSILE 200
+#define ENERGY_PER_MISSILE 10
+
+// bounce damage depends on how fast you're going
+#define DAMAGE_PER_SHIP_BOUNCE_DIVISOR 3
+
+#define NUMBER_OF_STARS 20
+
+#define MAX_NUMBER_OF_MISSILES 60
+
+#define MISSILE_RADIUS (4 * FIXED_POINT_SCALE_FACTOR)
+#define MISSILE_SPEED 8
+#define MISSILE_TICKS_TO_LIVE 60
+#define MISSILE_EXPLOSION_TICKS_TO_LIVE 6
+
+//------------------------------------------------------------------------------
+
+typedef struct
+{
+ gdouble r, g, b;
+}
+RGB_t;
+
+typedef struct
+{
+ int x, y;
+ int vx, vy;
+
+ // 0 is straight up, (NUMBER_OF_ROTATION_ANGLES / 4) is pointing right
+ int rotation;
+
+ // used for collision detection - we presume that an object is equivalent
+ // to its bounding circle, rather than trying to do something fancy.
+ int radius;
+}
+physics_t;
+
+typedef struct
+{
+ physics_t p;
+
+ gboolean is_thrusting;
+ gboolean is_turning_left;
+ gboolean is_turning_right;
+ gboolean is_firing;
+
+ RGB_t primary_color;
+ RGB_t secondary_color;
+
+ int ticks_until_can_fire;
+ int energy;
+
+ gboolean is_hit;
+ gboolean is_dead;
+}
+player_t;
+
+typedef struct
+{
+ gboolean is_alive;
+
+ physics_t p;
+
+ RGB_t primary_color;
+ RGB_t secondary_color;
+
+ int ticks_to_live;
+ gboolean has_exploded;
+}
+missile_t;
+
+typedef struct
+{
+ int x, y;
+ float rotation;
+ float scale;
+}
+star_t;
+
+//------------------------------------------------------------------------------
+// Forward definitions of functions
+
+static void apply_physics (physics_t *);
+static void apply_physics_to_player (player_t *);
+static gboolean check_for_collision (physics_t *, physics_t *);
+static void draw_energy_bar (cairo_t *, player_t *);
+static void draw_flare (cairo_t *, RGB_t);
+static void draw_missile (cairo_t *, missile_t *);
+static void draw_exploded_missile (cairo_t *, missile_t *);
+static void draw_ship_body (cairo_t *, player_t *);
+static void draw_star (cairo_t * cr);
+static void draw_turning_flare (cairo_t *, RGB_t, int);
+static void enforce_minimum_distance (physics_t *, physics_t *);
+static long get_time_millis (void);
+static void init_missiles_array (void);
+static void init_stars_array (void);
+static void init_trigonometric_tables (void);
+static void on_collision (player_t *, missile_t *);
+static gint on_expose_event (GtkWidget *, GdkEventExpose *);
+static gint on_key_event (GtkWidget *, GdkEventKey *, gboolean);
+static gint on_key_press (GtkWidget *, GdkEventKey *);
+static gint on_key_release (GtkWidget *, GdkEventKey *);
+static gint on_timeout (gpointer);
+static void reset ();
+static void scale_for_aspect_ratio (cairo_t *, int, int);
+static void show_text_message (cairo_t *, int, int, const char *);
+
+//------------------------------------------------------------------------------
+
+static player_t player1;
+static player_t player2;
+
+//------------------------------------------------------------------------------
+
+static missile_t missiles[MAX_NUMBER_OF_MISSILES];
+static int next_missile_index = 0;
+
+static void
+init_missiles_array ()
+{
+ int i;
+
+ for (i = 0; i < MAX_NUMBER_OF_MISSILES; i++)
+ {
+ missiles[i].p.radius = MISSILE_RADIUS;
+ missiles[i].is_alive = FALSE;
+ }
+}
+
+//------------------------------------------------------------------------------
+
+static star_t stars[NUMBER_OF_STARS];
+
+#ifdef WIN32
+// For Windows.
+double drand48 ()
+{
+ return (double) rand () / RAND_MAX;
+}
+
+int random ()
+{
+ return rand () * 32768 + rand ();
+}
+#endif
+
+static void
+init_stars_array ()
+{
+ int i;
+
+ for (i = 0; i < NUMBER_OF_STARS; i++)
+ {
+ stars[i].x = random () % WIDTH;
+ stars[i].y = random () % HEIGHT;
+ stars[i].rotation = drand48 () * TWO_PI;
+ stars[i].scale = 0.5 + (drand48 ());
+ }
+}
+
+//------------------------------------------------------------------------------
+
+static gboolean show_fps = TRUE;
+static int number_of_frames = 0;
+static long millis_taken_for_frames = 0;
+static float debug_scale_factor = 1.0f;
+static const char *game_over_message = NULL;
+
+//------------------------------------------------------------------------------
+
+static int cos_table[NUMBER_OF_ROTATION_ANGLES];
+static int sin_table[NUMBER_OF_ROTATION_ANGLES];
+
+static void
+init_trigonometric_tables ()
+{
+ int i;
+ int q = (NUMBER_OF_ROTATION_ANGLES / 4);
+
+ for (i = 0; i < NUMBER_OF_ROTATION_ANGLES; i++)
+ {
+ // our angle system is "true north" - 0 is straight up, whereas
+ // cos & sin take 0 as east (and in radians).
+ double angle_in_radians = (q - i) * TWO_PI / NUMBER_OF_ROTATION_ANGLES;
+ cos_table[i] =
+ +(int) (cos (angle_in_radians) * FIXED_POINT_SCALE_FACTOR);
+
+ // also, our graphics system is "y axis down", although in regular math,
+ // the y axis is "up", so we have to multiply sin by -1.
+ sin_table[i] =
+ -(int) (sin (angle_in_radians) * FIXED_POINT_SCALE_FACTOR);
+ }
+}
+
+//------------------------------------------------------------------------------
+
+gint
+main (gint argc, gchar ** argv)
+{
+ GtkWidget *window;
+
+ srand ((unsigned int) time (NULL));
+
+ init_trigonometric_tables ();
+ reset ();
+
+ gtk_init (&argc, &argv);
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ g_signal_connect (G_OBJECT (window), "delete-event",
+ G_CALLBACK (gtk_main_quit), NULL);
+
+ gtk_window_set_default_size (GTK_WINDOW (window), WIDTH, HEIGHT);
+
+ g_signal_connect (G_OBJECT (window), "expose_event",
+ G_CALLBACK (on_expose_event), NULL);
+ g_signal_connect (G_OBJECT (window), "key_press_event",
+ G_CALLBACK (on_key_press), NULL);
+ g_signal_connect (G_OBJECT (window), "key_release_event",
+ G_CALLBACK (on_key_release), NULL);
+ g_timeout_add (MILLIS_PER_FRAME, (GSourceFunc) on_timeout, window);
+
+ gtk_widget_show_all (window);
+ gtk_main ();
+
+ return 0;
+}
+
+//------------------------------------------------------------------------------
+
+static long
+get_time_millis (void)
+{
+ struct timeb tp;
+ ftime (&tp);
+ return (long) ((tp.time * 1000) + tp.millitm);
+}
+
+//------------------------------------------------------------------------------
+
+static gint
+on_expose_event (GtkWidget * widget, GdkEventExpose * event)
+{
+ cairo_t *cr = gdk_cairo_create (widget->window);
+ int i;
+ long start_time = 0;
+ if (show_fps)
+ {
+ start_time = get_time_millis ();
+ }
+
+ cairo_save (cr);
+
+ scale_for_aspect_ratio (cr, widget->allocation.width,
+ widget->allocation.height);
+
+ cairo_scale (cr, debug_scale_factor, debug_scale_factor);
+
+ /* draw background space color */
+ cairo_set_source_rgb (cr, 0.1, 0.0, 0.1);
+ cairo_paint (cr);
+
+ // draw any stars...
+ for (i = 0; i < NUMBER_OF_STARS; i++)
+ {
+ cairo_save (cr);
+ cairo_translate (cr, stars[i].x, stars[i].y);
+ cairo_rotate (cr, stars[i].rotation);
+ cairo_scale (cr, stars[i].scale, stars[i].scale);
+ draw_star (cr);
+ cairo_restore (cr);
+ }
+
+ // ... the energy bars...
+ cairo_save (cr);
+ cairo_translate (cr, 30, 30);
+ cairo_rotate (cr, 0);
+ draw_energy_bar (cr, &player1);
+ cairo_restore (cr);
+
+ cairo_save (cr);
+ cairo_translate (cr, WIDTH - 30, 30);
+ cairo_rotate (cr, PI);
+ draw_energy_bar (cr, &player2);
+ cairo_restore (cr);
+
+ // ... the two ships...
+ cairo_save (cr);
+ cairo_translate (cr, player1.p.x / FIXED_POINT_SCALE_FACTOR,
+ player1.p.y / FIXED_POINT_SCALE_FACTOR);
+ cairo_rotate (cr, player1.p.rotation * RADIANS_PER_ROTATION_ANGLE);
+ draw_ship_body (cr, &player1);
+ cairo_restore (cr);
+
+ cairo_save (cr);
+ cairo_translate (cr, player2.p.x / FIXED_POINT_SCALE_FACTOR,
+ player2.p.y / FIXED_POINT_SCALE_FACTOR);
+ cairo_rotate (cr, player2.p.rotation * RADIANS_PER_ROTATION_ANGLE);
+ draw_ship_body (cr, &player2);
+ cairo_restore (cr);
+
+ // ... and any missiles.
+ for (i = 0; i < MAX_NUMBER_OF_MISSILES; i++)
+ {
+ if (missiles[i].is_alive)
+ {
+ cairo_save (cr);
+ cairo_translate (cr, missiles[i].p.x / FIXED_POINT_SCALE_FACTOR,
+ missiles[i].p.y / FIXED_POINT_SCALE_FACTOR);
+ cairo_rotate (cr,
+ missiles[i].p.rotation * RADIANS_PER_ROTATION_ANGLE);
+ draw_missile (cr, &(missiles[i]));
+ cairo_restore (cr);
+ }
+ }
+
+ if (game_over_message == NULL)
+ {
+ if (player1.is_dead)
+ {
+ game_over_message = (player2.is_dead) ? "DRAW" : "RED wins";
+ }
+ else
+ {
+ game_over_message = (player2.is_dead) ? "BLUE wins" : NULL;
+ }
+ }
+ if (game_over_message != NULL)
+ {
+ show_text_message (cr, 80, -30, game_over_message);
+ show_text_message (cr, 30, +40, "Press [SPACE] to restart");
+ }
+
+ cairo_restore (cr);
+
+ if (show_fps)
+ {
+ number_of_frames++;
+ millis_taken_for_frames += get_time_millis () - start_time;
+ if (number_of_frames >= 100)
+ {
+ double fps =
+ 1000.0 * ((double) number_of_frames) /
+ ((double) millis_taken_for_frames);
+ printf ("%d frames in %ldms (%.3ffps)\n", number_of_frames,
+ millis_taken_for_frames, fps);
+ number_of_frames = 0;
+ millis_taken_for_frames = 0L;
+ }
+ }
+
+ cairo_destroy (cr);
+ return TRUE;
+}
+
+//------------------------------------------------------------------------------
+
+static void
+scale_for_aspect_ratio (cairo_t * cr, int widget_width, int widget_height)
+{
+ double scale;
+ int playfield_width, playfield_height;
+ int tx, ty;
+ gboolean is_widget_wider;
+
+ is_widget_wider = (widget_width * HEIGHT) > (WIDTH * widget_height);
+
+ if (is_widget_wider)
+ {
+ scale = ((double) widget_height) / HEIGHT;
+ playfield_width = (WIDTH * widget_height) / HEIGHT;
+ playfield_height = widget_height;
+ tx = (widget_width - playfield_width) / 2;
+ ty = 0;
+ }
+ else
+ {
+ scale = ((double) widget_width) / WIDTH;
+ playfield_width = widget_width;
+ playfield_height = (HEIGHT * widget_width) / WIDTH;
+ tx = 0;
+ ty = (widget_height - playfield_height) / 2;
+ }
+
+ cairo_translate (cr, tx, ty);
+ cairo_rectangle (cr, 0, 0, playfield_width, playfield_height);
+ cairo_clip (cr);
+
+ cairo_scale (cr, scale, scale);
+}
+
+//------------------------------------------------------------------------------
+
+static void
+draw_energy_bar (cairo_t * cr, player_t * p)
+{
+ cairo_pattern_t *pat;
+ double alpha = 0.6;
+
+ cairo_save (cr);
+
+ cairo_rectangle (cr, 0, -5, p->energy / 5, 10);
+
+ pat = cairo_pattern_create_linear (0, 0, SHIP_MAX_ENERGY / 5, 0);
+ cairo_pattern_add_color_stop_rgba (pat, 0,
+ p->secondary_color.r,
+ p->secondary_color.g,
+ p->secondary_color.b, alpha);
+ cairo_pattern_add_color_stop_rgba (pat, 1, p->primary_color.r,
+ p->primary_color.g, p->primary_color.b,
+ alpha);
+
+ cairo_set_source (cr, pat);
+ cairo_fill_preserve (cr);
+ cairo_pattern_destroy (pat);
+
+ cairo_set_source_rgb (cr, 0, 0, 0);
+ cairo_stroke (cr);
+ cairo_restore (cr);
+}
+
+//------------------------------------------------------------------------------
+
+static void
+draw_ship_body (cairo_t * cr, player_t * p)
+{
+ cairo_pattern_t *pat;
+
+ if (p->is_hit)
+ {
+ cairo_set_source_rgba (cr, p->primary_color.r, p->primary_color.g,
+ p->primary_color.b, 0.5);
+ cairo_arc (cr, 0, 0, SHIP_RADIUS / FIXED_POINT_SCALE_FACTOR, 0, TWO_PI);
+ cairo_stroke (cr);
+ }
+
+ cairo_save (cr);
+ cairo_scale (cr, GLOBAL_SHIP_SCALE_FACTOR, GLOBAL_SHIP_SCALE_FACTOR);
+
+ if (!p->is_dead)
+ {
+
+ if (p->is_thrusting)
+ {
+ draw_flare (cr, p->primary_color);
+ }
+
+ if (p->is_turning_left && !p->is_turning_right)
+ {
+ draw_turning_flare (cr, p->primary_color, -1.0);
+ }
+
+ if (!p->is_turning_left && p->is_turning_right)
+ {
+ draw_turning_flare (cr, p->primary_color, 1.0);
+ }
+ }
+
+ cairo_move_to (cr, 0, -33);
+ cairo_curve_to (cr, 2, -33, 3, -34, 4, -35);
+ cairo_curve_to (cr, 8, -10, 6, 15, 15, 15);
+ cairo_line_to (cr, 20, 15);
+ cairo_line_to (cr, 20, 7);
+ cairo_curve_to (cr, 25, 10, 28, 22, 25, 28);
+ cairo_curve_to (cr, 20, 26, 8, 24, 0, 24);
+ // half way point
+ cairo_curve_to (cr, -8, 24, -20, 26, -25, 28);
+ cairo_curve_to (cr, -28, 22, -25, 10, -20, 7);
+ cairo_line_to (cr, -20, 15);
+ cairo_line_to (cr, -15, 15);
+ cairo_curve_to (cr, -6, 15, -8, -10, -4, -35);
+ cairo_curve_to (cr, -3, -34, -2, -33, 0, -33);
+
+ pat = cairo_pattern_create_linear (-30.0, -30.0, 30.0, 30.0);
+ cairo_pattern_add_color_stop_rgba (pat, 0,
+ p->primary_color.r, p->primary_color.g,
+ p->primary_color.b, 1);
+ cairo_pattern_add_color_stop_rgba (pat, 1, p->secondary_color.r,
+ p->secondary_color.g,
+ p->secondary_color.b, 1);
+
+ cairo_set_source (cr, pat);
+ cairo_fill_preserve (cr);
+ cairo_pattern_destroy (pat);
+
+ cairo_set_source_rgb (cr, 0, 0, 0);
+ cairo_stroke (cr);
+ cairo_restore (cr);
+}
+
+//------------------------------------------------------------------------------
+
+static void
+draw_flare (cairo_t * cr, RGB_t color)
+{
+ cairo_pattern_t *pat;
+
+ cairo_save (cr);
+ cairo_translate (cr, 0, 22);
+ pat = cairo_pattern_create_radial (0, 0, 2, 0, 5, 12);
+
+ cairo_pattern_add_color_stop_rgba (pat, 0.0, color.r, color.g, color.b, 1);
+ cairo_pattern_add_color_stop_rgba (pat, 0.3, 1, 1, 1, 1);
+ cairo_pattern_add_color_stop_rgba (pat, 1.0, color.r, color.g, color.b, 0);
+ cairo_set_source (cr, pat);
+ cairo_arc (cr, 0, 0, 20, 0, TWO_PI);
+ cairo_fill (cr);
+ cairo_pattern_destroy (pat);
+ cairo_restore (cr);
+}
+
+//------------------------------------------------------------------------------
+
+static void
+draw_turning_flare (cairo_t * cr, RGB_t color, int right_hand_side)
+{
+ cairo_pattern_t *pat;
+ cairo_save (cr);
+
+ cairo_translate (cr, -23 * right_hand_side, 28);
+ pat = cairo_pattern_create_radial (0, 0, 1, 0, 0, 7);
+ cairo_pattern_add_color_stop_rgba (pat, 0.0, 1, 1, 1, 1);
+ cairo_pattern_add_color_stop_rgba (pat, 1.0, color.r, color.g, color.b, 0);
+ cairo_set_source (cr, pat);
+ cairo_arc (cr, 0, 0, 7, 0, TWO_PI);
+ cairo_fill (cr);
+ cairo_pattern_destroy (pat);
+
+ cairo_translate (cr, 42 * right_hand_side, -22);
+ pat = cairo_pattern_create_radial (0, 0, 1, 0, 0, 7);
+ cairo_pattern_add_color_stop_rgba (pat, 0.0, 1, 1, 1, 1);
+ cairo_pattern_add_color_stop_rgba (pat, 1.0, color.r, color.g, color.b, 0);
+ cairo_set_source (cr, pat);
+ cairo_arc (cr, 0, 0, 5, 0, TWO_PI);
+ cairo_fill (cr);
+ cairo_pattern_destroy (pat);
+
+ cairo_restore (cr);
+}
+
+//------------------------------------------------------------------------------
+
+static void
+draw_missile (cairo_t * cr, missile_t * m)
+{
+ cairo_save (cr);
+ cairo_scale (cr, GLOBAL_SHIP_SCALE_FACTOR, GLOBAL_SHIP_SCALE_FACTOR);
+
+ if (m->has_exploded)
+ {
+ draw_exploded_missile (cr, m);
+ }
+ else
+ {
+ cairo_pattern_t *pat;
+
+ double alpha = ((double) m->ticks_to_live) / MISSILE_TICKS_TO_LIVE;
+ // non-linear scaling so things don't fade out too fast
+ alpha = 1.0 - (1.0 - alpha) * (1.0 - alpha);
+
+ cairo_save (cr);
+ cairo_move_to (cr, 0, -4);
+ cairo_curve_to (cr, 3, -4, 4, -2, 4, 0);
+ cairo_curve_to (cr, 4, 4, 2, 10, 0, 18);
+ // half way point
+ cairo_curve_to (cr, -2, 10, -4, 4, -4, 0);
+ cairo_curve_to (cr, -4, -2, -3, -4, 0, -4);
+
+ pat = cairo_pattern_create_linear (0.0, -5.0, 0.0, 5.0);
+ cairo_pattern_add_color_stop_rgba (pat, 0,
+ m->primary_color.r,
+ m->primary_color.g,
+ m->primary_color.b, alpha);
+ cairo_pattern_add_color_stop_rgba (pat, 1, m->secondary_color.r,
+ m->secondary_color.g,
+ m->secondary_color.b, alpha);
+
+ cairo_set_source (cr, pat);
+ cairo_fill (cr);
+ cairo_pattern_destroy (pat);
+ cairo_restore (cr);
+
+ cairo_save (cr);
+ cairo_arc (cr, 0, 0, 3, 0, TWO_PI);
+
+ pat = cairo_pattern_create_linear (0, 3, 0, -3);
+ cairo_pattern_add_color_stop_rgba (pat, 0,
+ m->primary_color.r,
+ m->primary_color.g,
+ m->primary_color.b, alpha);
+ cairo_pattern_add_color_stop_rgba (pat, 1, m->secondary_color.r,
+ m->secondary_color.g,
+ m->secondary_color.b, alpha);
+
+ cairo_set_source (cr, pat);
+ cairo_fill (cr);
+ cairo_pattern_destroy (pat);
+ cairo_restore (cr);
+ }
+
+ cairo_restore (cr);
+}
+
+//------------------------------------------------------------------------------
+
+static void
+draw_exploded_missile (cairo_t * cr, missile_t * m)
+{
+ double alpha;
+ cairo_pattern_t *pat;
+
+ cairo_save (cr);
+ cairo_scale (cr, GLOBAL_SHIP_SCALE_FACTOR, GLOBAL_SHIP_SCALE_FACTOR);
+
+ alpha = ((double) m->ticks_to_live) / MISSILE_EXPLOSION_TICKS_TO_LIVE;
+ alpha = 1.0 - (1.0 - alpha) * (1.0 - alpha);
+
+ cairo_arc (cr, 0, 0, 30, 0, TWO_PI);
+
+ pat = cairo_pattern_create_radial (0, 0, 0, 0, 0, 30);
+ cairo_pattern_add_color_stop_rgba (pat, 0,
+ m->primary_color.r, m->primary_color.g,
+ m->primary_color.b, alpha);
+ cairo_pattern_add_color_stop_rgba (pat, 0.5, m->secondary_color.r,
+ m->secondary_color.g,
+ m->secondary_color.b, alpha * 0.75);
+ cairo_pattern_add_color_stop_rgba (pat, 1, 0, 0, 0, 0);
+
+ cairo_set_source (cr, pat);
+ cairo_fill (cr);
+ cairo_pattern_destroy (pat);
+ cairo_restore (cr);
+}
+
+//------------------------------------------------------------------------------
+
+static void
+draw_star (cairo_t * cr)
+{
+ int a = NUMBER_OF_ROTATION_ANGLES / 10;
+ float r1 = 5.0;
+ float r2 = 2.0;
+ float c;
+ int i;
+
+ cairo_save (cr);
+ cairo_move_to (cr, r1 * cos_table[0] / FIXED_POINT_SCALE_FACTOR,
+ r1 * sin_table[0] / FIXED_POINT_SCALE_FACTOR);
+
+ for (i = 0; i < 5; i++) {
+ cairo_line_to (cr, r1 * cos_table[0] / FIXED_POINT_SCALE_FACTOR,
+ r1 * sin_table[0] / FIXED_POINT_SCALE_FACTOR);
+ cairo_line_to (cr, r2 * cos_table[a] / FIXED_POINT_SCALE_FACTOR,
+ r2 * sin_table[a] / FIXED_POINT_SCALE_FACTOR);
+ cairo_rotate (cr, 4*a*PI/NUMBER_OF_ROTATION_ANGLES);
+ }
+
+ cairo_close_path (cr);
+ cairo_restore (cr);
+
+ c = 0.5;
+ cairo_set_source_rgb (cr, c, c, c);
+ cairo_fill (cr);
+}
+
+//------------------------------------------------------------------------------
+
+static gint
+on_timeout (gpointer data)
+{
+ int i;
+
+ player1.is_hit = FALSE;
+ player2.is_hit = FALSE;
+
+ apply_physics_to_player (&player1);
+ apply_physics_to_player (&player2);
+
+ if (check_for_collision (&(player1.p), &(player2.p)))
+ {
+ int p1vx;
+ int p1vy;
+ int p2vx;
+ int p2vy;
+
+ int dvx;
+ int dvy;
+ int dv2;
+ int damage;
+
+ enforce_minimum_distance (&(player1.p), &(player2.p));
+
+ p1vx = player1.p.vx;
+ p1vy = player1.p.vy;
+ p2vx = player2.p.vx;
+ p2vy = player2.p.vy;
+
+ dvx = (p1vx - p2vx) / FIXED_POINT_HALF_SCALE_FACTOR;
+ dvy = (p1vy - p2vy) / FIXED_POINT_HALF_SCALE_FACTOR;
+ dv2 = (dvx * dvx) + (dvy * dvy);
+ damage = ((int)(sqrt (dv2))) / DAMAGE_PER_SHIP_BOUNCE_DIVISOR;
+
+ player1.energy -= damage;
+ player2.energy -= damage;
+ player1.is_hit = TRUE;
+ player2.is_hit = TRUE;
+
+ player1.p.vx = (p1vx * -2 / 8) + (p2vx * +5 / 8);
+ player1.p.vy = (p1vy * -2 / 8) + (p2vy * +5 / 8);
+ player2.p.vx = (p1vx * +5 / 8) + (p2vx * -2 / 8);
+ player2.p.vy = (p1vy * +5 / 8) + (p2vy * -2 / 8);
+ }
+
+ for (i = 0; i < MAX_NUMBER_OF_MISSILES; i++)
+ {
+ if (missiles[i].is_alive)
+ {
+ apply_physics (&(missiles[i].p));
+
+ if (!missiles[i].has_exploded)
+ {
+ if (check_for_collision (&(missiles[i].p), &(player1.p)))
+ {
+ on_collision (&player1, &(missiles[i]));
+ }
+
+ if (check_for_collision (&(missiles[i].p), &(player2.p)))
+ {
+ on_collision (&player2, &(missiles[i]));
+ }
+ }
+
+ missiles[i].ticks_to_live--;
+ if (missiles[i].ticks_to_live <= 0)
+ {
+ missiles[i].is_alive = FALSE;
+ }
+ }
+ }
+
+ if (player1.energy <= 0)
+ {
+ player1.energy = 0;
+ player1.is_dead = TRUE;
+ }
+ else
+ {
+ player1.energy = MIN (SHIP_MAX_ENERGY, player1.energy + 1);
+ }
+
+ if (player2.energy <= 0)
+ {
+ player2.energy = 0;
+ player2.is_dead = TRUE;
+ }
+ else
+ {
+ player2.energy = MIN (SHIP_MAX_ENERGY, player2.energy + 1);
+ }
+
+ gtk_widget_queue_draw ((GtkWidget *) data);
+ return TRUE;
+}
+
+//------------------------------------------------------------------------------
+
+static void
+apply_physics_to_player (player_t * player)
+{
+ int v2, m2;
+ physics_t *p = &(player->p);
+
+ if (!player->is_dead)
+ {
+ // check if player is turning left, ...
+ if (player->is_turning_left)
+ {
+ p->rotation--;
+ while (p->rotation < 0)
+ {
+ p->rotation += NUMBER_OF_ROTATION_ANGLES;
+ }
+ }
+
+ // ... or right.
+ if (player->is_turning_right)
+ {
+ p->rotation++;
+ while (p->rotation >= NUMBER_OF_ROTATION_ANGLES)
+ {
+ p->rotation -= NUMBER_OF_ROTATION_ANGLES;
+ }
+ }
+
+ // check if accelerating
+ if (player->is_thrusting)
+ {
+ p->vx += SHIP_ACCELERATION_FACTOR * cos_table[p->rotation];
+ p->vy += SHIP_ACCELERATION_FACTOR * sin_table[p->rotation];
+ }
+
+ // apply velocity upper bound
+ v2 = ((p->vx) * (p->vx)) + ((p->vy) * (p->vy));
+ m2 = SHIP_MAX_VELOCITY * SHIP_MAX_VELOCITY;
+ if (v2 > m2)
+ {
+ p->vx = (int) (((double) (p->vx) * m2) / v2);
+ p->vy = (int) (((double) (p->vy) * m2) / v2);
+ }
+
+ // check if player is shooting
+ if (player->ticks_until_can_fire == 0)
+ {
+ if ((player->is_firing) && (player->energy > ENERGY_PER_MISSILE))
+ {
+ int xx = cos_table[p->rotation];
+ int yy = sin_table[p->rotation];
+
+ missile_t *m = &(missiles[next_missile_index++]);
+
+ player->energy -= ENERGY_PER_MISSILE;
+
+ if (next_missile_index == MAX_NUMBER_OF_MISSILES)
+ {
+ next_missile_index = 0;
+ }
+
+ m->p.x =
+ p->x +
+ (((SHIP_RADIUS +
+ MISSILE_RADIUS) / FIXED_POINT_SCALE_FACTOR) * xx);
+ m->p.y =
+ p->y +
+ (((SHIP_RADIUS +
+ MISSILE_RADIUS) / FIXED_POINT_SCALE_FACTOR) * yy);
+ m->p.vx = p->vx + (MISSILE_SPEED * xx);
+ m->p.vy = p->vy + (MISSILE_SPEED * yy);
+ m->p.rotation = p->rotation;
+ m->ticks_to_live = MISSILE_TICKS_TO_LIVE;
+ m->primary_color = player->primary_color;
+ m->secondary_color = player->secondary_color;
+ m->is_alive = TRUE;
+ m->has_exploded = FALSE;
+
+ player->ticks_until_can_fire += TICKS_BETWEEN_FIRE;
+ }
+ }
+ else
+ {
+ player->ticks_until_can_fire--;
+ }
+ }
+
+ // apply velocity deltas to displacement
+ apply_physics (p);
+}
+
+//------------------------------------------------------------------------------
+
+static void
+apply_physics (physics_t * p)
+{
+ p->x += p->vx;
+ while (p->x > (WIDTH * FIXED_POINT_SCALE_FACTOR))
+ {
+ p->x -= (WIDTH * FIXED_POINT_SCALE_FACTOR);
+ }
+ while (p->x < 0)
+ {
+ p->x += (WIDTH * FIXED_POINT_SCALE_FACTOR);
+ }
+
+ p->y += p->vy;
+ while (p->y > (HEIGHT * FIXED_POINT_SCALE_FACTOR))
+ {
+ p->y -= (HEIGHT * FIXED_POINT_SCALE_FACTOR);
+ }
+ while (p->y < 0)
+ {
+ p->y += (HEIGHT * FIXED_POINT_SCALE_FACTOR);
+ }
+}
+
+//------------------------------------------------------------------------------
+
+static gboolean
+check_for_collision (physics_t * p1, physics_t * p2)
+{
+ int dx = (p1->x - p2->x) / FIXED_POINT_HALF_SCALE_FACTOR;
+ int dy = (p1->y - p2->y) / FIXED_POINT_HALF_SCALE_FACTOR;
+ int r = (p1->radius + p2->radius) / FIXED_POINT_HALF_SCALE_FACTOR;
+ int d2 = (dx * dx) + (dy * dy);
+ return (d2 < (r * r)) ? TRUE : FALSE;
+}
+
+//------------------------------------------------------------------------------
+
+static void
+enforce_minimum_distance (physics_t * p1, physics_t * p2)
+{
+ int dx = p1->x - p2->x;
+ int dy = p1->y - p2->y;
+ double d2 = (((double) dx) * dx) + (((double) dy) * dy);
+ int d = (int) sqrt (d2);
+
+ int r = p1->radius + p2->radius;
+
+ // normalize dx and dy to length = ((r - d) / 2) + fudge_factor
+ int desired_vector_length = ((r - d) * 5) / 8;
+
+ dx *= desired_vector_length;
+ dy *= desired_vector_length;
+ dx /= d;
+ dy /= d;
+
+ p1->x += dx;
+ p1->y += dy;
+ p2->x -= dx;
+ p2->y -= dy;
+}
+
+//------------------------------------------------------------------------------
+
+static void
+on_collision (player_t * p, missile_t * m)
+{
+ p->energy -= DAMAGE_PER_MISSILE;
+ p->is_hit = TRUE;
+ m->has_exploded = TRUE;
+ m->ticks_to_live = MISSILE_EXPLOSION_TICKS_TO_LIVE;
+ m->p.vx = 0;
+ m->p.vy = 0;
+}
+
+//------------------------------------------------------------------------------
+
+static void
+show_text_message (cairo_t * cr, int font_size, int dy, const char *message)
+{
+ double x, y;
+ cairo_text_extents_t extents;
+
+ cairo_save (cr);
+
+ cairo_select_font_face (cr, "Serif",
+ CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+
+ cairo_set_font_size (cr, font_size);
+ cairo_text_extents (cr, message, &extents);
+ x = (WIDTH / 2) - (extents.width / 2 + extents.x_bearing);
+ y = (HEIGHT / 2) - (extents.height / 2 + extents.y_bearing);
+
+ cairo_set_source_rgba (cr, 1, 1, 1, 1);
+ cairo_move_to (cr, x, y + dy);
+ cairo_show_text (cr, message);
+ cairo_restore (cr);
+}
+
+//------------------------------------------------------------------------------
+
+static void
+reset ()
+{
+ player1.p.x = 200 * FIXED_POINT_SCALE_FACTOR;
+ player1.p.y = 200 * FIXED_POINT_SCALE_FACTOR;
+ player1.p.vx = 0;
+ player1.p.vy = 0;
+ player1.p.rotation = random () % NUMBER_OF_ROTATION_ANGLES;
+ player1.p.radius = SHIP_RADIUS;
+ player1.is_thrusting = FALSE;
+ player1.is_turning_left = FALSE;
+ player1.is_turning_right = FALSE;
+ player1.is_firing = FALSE;
+ player1.primary_color.r = 0.3;
+ player1.primary_color.g = 0.5;
+ player1.primary_color.b = 0.9;
+ player1.secondary_color.r = 0.1;
+ player1.secondary_color.g = 0.3;
+ player1.secondary_color.b = 0.3;
+ player1.ticks_until_can_fire = 0;
+ player1.energy = SHIP_MAX_ENERGY;
+ player1.is_hit = FALSE;
+ player1.is_dead = FALSE;
+
+ player2.p.x = 600 * FIXED_POINT_SCALE_FACTOR;
+ player2.p.y = 400 * FIXED_POINT_SCALE_FACTOR;
+ player2.p.vx = 0;
+ player2.p.vy = 0;
+ player2.p.rotation = random () % NUMBER_OF_ROTATION_ANGLES;
+ player2.p.radius = SHIP_RADIUS;
+ player2.is_thrusting = FALSE;
+ player2.is_turning_left = FALSE;
+ player2.is_turning_right = FALSE;
+ player2.is_firing = FALSE;
+ player2.primary_color.r = 0.9;
+ player2.primary_color.g = 0.2;
+ player2.primary_color.b = 0.3;
+ player2.secondary_color.r = 0.5;
+ player2.secondary_color.g = 0.2;
+ player2.secondary_color.b = 0.3;
+ player2.ticks_until_can_fire = 0;
+ player2.energy = SHIP_MAX_ENERGY;
+ player2.is_hit = FALSE;
+ player2.is_dead = FALSE;
+
+ init_stars_array ();
+ init_missiles_array ();
+
+ game_over_message = NULL;
+}
+
+//------------------------------------------------------------------------------
+
+static gint
+on_key_press (GtkWidget * widget, GdkEventKey * event)
+{
+ return on_key_event (widget, event, TRUE);
+}
+
+//------------------------------------------------------------------------------
+
+static gint
+on_key_release (GtkWidget * widget, GdkEventKey * event)
+{
+ return on_key_event (widget, event, FALSE);
+}
+
+//------------------------------------------------------------------------------
+
+static gint
+on_key_event (GtkWidget * widget, GdkEventKey * event, gboolean key_is_on)
+{
+ switch (event->keyval)
+ {
+ case GDK_Escape:
+ gtk_main_quit ();
+ break;
+
+ case GDK_bracketleft:
+ if (key_is_on)
+ {
+ debug_scale_factor /= 1.25f;
+ printf ("Scale: %f\n", debug_scale_factor);
+ }
+ break;
+ case GDK_bracketright:
+ if (key_is_on)
+ {
+ debug_scale_factor *= 1.25f;
+ printf ("Scale: %f\n", debug_scale_factor);
+ }
+ break;
+
+ case GDK_space:
+ if (game_over_message != NULL)
+ {
+ reset ();
+ }
+ break;
+
+ case GDK_a:
+ player1.is_turning_left = key_is_on;
+ break;
+ case GDK_d:
+ player1.is_turning_right = key_is_on;
+ break;
+ case GDK_w:
+ player1.is_thrusting = key_is_on;
+ break;
+ case GDK_Control_L:
+ player1.is_firing = key_is_on;
+ break;
+
+ case GDK_Left:
+ case GDK_KP_Left:
+ player2.is_turning_left = key_is_on;
+ break;
+ case GDK_Right:
+ case GDK_KP_Right:
+ player2.is_turning_right = key_is_on;
+ break;
+ case GDK_Up:
+ case GDK_KP_Up:
+ player2.is_thrusting = key_is_on;
+ break;
+ case GDK_Control_R:
+ case GDK_KP_Insert:
+ player2.is_firing = key_is_on;
+ break;
+ }
+ return TRUE;
+}
git.annexia.org / fedora-mingw.git / commitdiff