allegro4r 0.0.1

data/ext/a4r_API_misc.c

@@ -0,0 +1,133 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   MIN(x, y) -> num
+ *
+ */
+VALUE a4r_API_MIN(VALUE self, VALUE x, VALUE y)
+{
+  return INT2NUM(MIN(NUM2INT(x), NUM2INT(y)));
+}
+
+/*
+ * call-seq:
+ *   ABS(x) -> num
+ *
+ */
+VALUE a4r_API_ABS(VALUE self, VALUE x)
+{
+  return INT2NUM(ABS(NUM2INT(x)));
+}
+
+/*
+ * call-seq:
+ *   AL_RAND -> num
+ *
+ * On platforms that require it, this macro does a simple shift transformation
+ * of the libc rand() function, in order to improve the perceived randomness of
+ * the output series in the lower 16 bits. Where not required, it directly
+ * translates into a rand() call.
+ */
+VALUE a4r_API_AL_RAND(VALUE self)
+{
+  return INT2NUM(AL_RAND());
+}
+
+/*
+ * call-seq:
+ *   gfx_driver -> gfx_driver
+ *
+ * Global reference to the graphics driver.
+ */
+VALUE a4r_API_gfx_driver(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  GFX_DRIVER *driver = gfx_driver;
+  VALUE obj = Data_Wrap_Struct(cAPI_GFX_DRIVER, 0, 0, driver);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   mouse_driver -> mouse_driver
+ *
+ * Global reference to the mouse driver.
+ */
+VALUE a4r_API_mouse_driver(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  MOUSE_DRIVER *driver = mouse_driver;
+  VALUE obj = Data_Wrap_Struct(cAPI_MOUSE_DRIVER, 0, 0, driver);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   timer_driver -> timer_driver
+ *
+ * Global reference to the timer driver.
+ */
+VALUE a4r_API_timer_driver(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  TIMER_DRIVER *driver = timer_driver;
+  VALUE obj = Data_Wrap_Struct(cAPI_TIMER_DRIVER, 0, 0, driver);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   keyboard_driver -> keyboard_driver
+ *
+ * Global reference to the keyboard driver.
+ */
+VALUE a4r_API_keyboard_driver(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  KEYBOARD_DRIVER *driver = keyboard_driver;
+  VALUE obj = Data_Wrap_Struct(cAPI_KEYBOARD_DRIVER, 0, 0, driver);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   joystick_driver -> joystick_driver
+ *
+ * Global reference to the joystick driver.
+ */
+VALUE a4r_API_joystick_driver(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  JOYSTICK_DRIVER *driver = joystick_driver;
+  VALUE obj = Data_Wrap_Struct(cAPI_JOYSTICK_DRIVER, 0, 0, driver);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   digi_driver -> digi_driver
+ *
+ * Global reference to the digital driver.
+ */
+VALUE a4r_API_digi_driver(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  DIGI_DRIVER *driver = digi_driver;
+  VALUE obj = Data_Wrap_Struct(cAPI_DIGI_DRIVER, 0, 0, driver);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   midi_driver -> midi_driver
+ *
+ * Global reference to the MIDI driver.
+ */
+VALUE a4r_API_midi_driver(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  MIDI_DRIVER *driver = midi_driver;
+  VALUE obj = Data_Wrap_Struct(cAPI_MIDI_DRIVER, 0, 0, driver);
+  return obj;
+}

data/ext/a4r_API_mouse_routines.c

@@ -0,0 +1,220 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   install_mouse -> int
+ *
+ * Installs the Allegro mouse handler. You must do this before using any other
+ * mouse functions.
+ *
+ * Return value: Returns -1 on failure, zero if the mouse handler is already
+ * installed (in which case this function does nothing) and the number of
+ * buttons on the mouse if the mouse handler has successfully been installed
+ * (ie. this is the first time a handler is installed or you have removed the
+ * previous one).
+ *
+ * Note that the number of mouse buttons returned by this function is more an
+ * indication than a physical reality. With most devices there is no way of
+ * telling how many buttons there are, and any user can override the number of
+ * mouse buttons returned by this function with a custom configuration file and
+ * the variable num_buttons. Even if this value is overridden by the user, the
+ * global mouse variables will still report whatever the hardware is sending.
+ */
+VALUE a4r_API_install_mouse(VALUE self)
+{
+  return INT2FIX(install_mouse());
+}
+
+/*
+ * call-seq:
+ *   poll_mouse -> int
+ *
+ * Wherever possible, Allegro will read the mouse input asynchronously (ie. from
+ * inside an interrupt handler), but on some platforms that may not be possible,
+ * in which case you must call this routine at regular intervals to update the
+ * mouse state variables. To help you test your mouse polling code even if you
+ * are programming on a platform that doesn't require it, after the first time
+ * that you call this function Allegro will switch into polling mode, so from
+ * that point onwards you will have to call this routine in order to get any
+ * mouse input at all, regardless of whether the current driver actually needs
+ * to be polled or not.
+ *
+ * Return value: Returns zero on success, or a negative number on failure (ie.
+ * no mouse driver installed).
+ */
+VALUE a4r_API_poll_mouse(VALUE self)
+{
+  return INT2FIX(poll_mouse());
+}
+
+/*
+ * call-seq:
+ *   mouse_x -> int
+ *
+ * Global variables containing the current mouse position and button state.
+ * Wherever possible these values will be updated asynchronously, but if
+ * mouse_needs_poll returns true, you must manually call poll_mouse to update
+ * them with the current input state. The 'mouse_x' and 'mouse_y' positions are
+ * integers ranging from zero to the bottom right corner of the screen. The
+ * 'mouse_z' and 'mouse_w' variables hold the current vertical and horizontal
+ * wheel position, when using an input driver that supports wheel mice. The
+ * 'mouse_b' variable is a bitfield indicating the state of each button: bit 0
+ * is the left button, bit 1 the right, and bit 2 the middle button. Additional
+ * non standard mouse buttons might be available as higher bits in this
+ * variable. Usage example:
+ *   printf("Left button is pressed\n") if (mouse_b & 1) > 0
+ *
+ *   printf("Right button is not pressed\n") if (mouse_b & 2) != 0
+ *
+ * The 'mouse_pos' variable has the current X coordinate in the upper 16 bits
+ * and the Y in the lower 16 bits. This may be useful in tight polling loops
+ * where a mouse interrupt could occur between your reading of the two separate
+ * variables, since you can copy this value into a local variable with a single
+ * instruction and then split it up at your leisure. Example:
+ *   pos = mouse_pos
+ *   x = pos >> 16
+ *   y = pos & 0x0000ffff
+ */
+VALUE a4r_API_mouse_x(VALUE self)
+{
+  return INT2FIX(mouse_x);
+}
+
+/*
+ * call-seq:
+ *   mouse_y -> int
+ *
+ * See mouse_x.
+ */
+VALUE a4r_API_mouse_y(VALUE self)
+{
+  return INT2FIX(mouse_y);
+}
+
+/*
+ * call-seq:
+ *   mouse_z -> int
+ *
+ * See mouse_x.
+ */
+VALUE a4r_API_mouse_z(VALUE self)
+{
+  return INT2FIX(mouse_z);
+}
+
+/*
+ * call-seq:
+ *   mouse_w -> int
+ *
+ * See mouse_x.
+ */
+VALUE a4r_API_mouse_w(VALUE self)
+{
+  return INT2FIX(mouse_w);
+}
+
+/*
+ * call-seq:
+ *   mouse_b -> int
+ *
+ * See mouse_x.
+ */
+VALUE a4r_API_mouse_b(VALUE self)
+{
+  return INT2FIX(mouse_b);
+}
+
+/*
+ * call-seq:
+ *   show_mouse(bmp) -> nil
+ *
+ * Tells Allegro to display a mouse pointer on the screen. This will only work
+ * if the timer module has been installed. The mouse pointer will be drawn onto
+ * the specified bitmap, which should normally be 'screen' (see later for
+ * information about bitmaps). To hide the mouse pointer, call show_mouse(nil).
+ *
+ * Warning: if you draw anything onto the screen while the pointer is visible, a
+ * mouse movement interrupt could occur in the middle of your drawing operation.
+ * If this happens the mouse buffering and graphics drawing code will get
+ * confused and will leave 'mouse droppings' all over the screen. To prevent
+ * this, you must make sure you turn off the mouse pointer whenever you draw
+ * onto the screen. This is not needed if you are using a hardware cursor.
+ *
+ * Note: you must not be showing a mouse pointer on a bitmap at the time that
+ * the bitmap is destroyed with destroy_bitmap, e.g. call show_mouse(nil) before
+ * destroying the bitmap. This does not apply to 'screen' since you never
+ * destroy 'screen' with destroy_bitmap.
+ */
+VALUE a4r_API_show_mouse(VALUE self, VALUE bmp)
+{
+  BITMAP *b;
+  if (bmp == Qnil)
+    b = NULL;
+  else
+    Data_Get_Struct(bmp, BITMAP, b);
+  show_mouse(b);
+  return Qnil;
+}
+
+/*
+ * call_seq:
+ *   get_mouse_mickeys -> [int_x, int_y]
+ *
+ * Measures how far the mouse has moved since the last call to this function.
+ * The values of mickeyx and mickeyy will become negative if the mouse is moved
+ * left or up, respectively. The mouse will continue to generate movement
+ * mickeys even when it reaches the edge of the screen, so this form of input
+ * can be useful for games that require an infinite range of mouse movement.
+ *
+ * Note that the infinite movement may not work in windowed mode, since under
+ * some platforms the mouse would leave the window, and may not work at all if
+ * the hardware cursor is in use.
+ *
+ * *** The Ruby method signature differs from the Allegro method signature. The
+ * Allegro signature take int_x and int_y by reference, but the Ruby signature
+ * returns an array containing the values of int_x and int_y.
+ */
+VALUE a4r_API_get_mouse_mickeys(VALUE self)
+{
+  int x, y;
+  get_mouse_mickeys(&x, &y);
+  return rb_ary_new3(2, INT2FIX(x), INT2FIX(y));
+}
+
+/*
+ * call-seq:
+ *   set_mouse_sprite(bmp) -> nil
+ *
+ * You don't like Allegro's mouse pointer? No problem. Use this function to
+ * supply an alternative of your own. If you change the pointer and then want to
+ * get Allegro's lovely arrow back again, call set_mouse_sprite(nil).
+ *
+ * As a bonus, set_mouse_sprite(nil) uses the current palette in choosing colors
+ * for the arrow. So if your arrow mouse sprite looks ugly after changing the
+ * palette, call set_mouse_sprite(nil).
+ */
+VALUE a4r_API_set_mouse_sprite(VALUE self, VALUE bmp)
+{
+  BITMAP *b;
+  if (bmp == Qnil)
+    b = NULL;
+  else
+    Data_Get_Struct(bmp, BITMAP, b);
+  set_mouse_sprite(b);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   set_mouse_sprite_focus(x, y) -> nil
+ *
+ * The mouse focus is the bit of the pointer that represents the actual mouse
+ * position, ie. the (mouse_x, mouse_y) position. By default this is the top
+ * left corner of the arrow, but if you are using a different mouse pointer you
+ * might need to alter it.
+ */
+VALUE a4r_API_set_mouse_sprite_focus(VALUE self, VALUE x, VALUE y)
+{
+  set_mouse_sprite_focus(FIX2INT(x), FIX2INT(y));
+  return Qnil;
+}

data/ext/a4r_API_music_routines_midi.c

@@ -0,0 +1,147 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   load_midi(filename) -> a_midi
+ *
+ * Loads a MIDI file (handles both format 0 and format 1). Example:
+ *   music = load_midi("backmus.mid")
+ *   abort_on_error("Couldn't load background music!") if music.nil?
+ *
+ * Return value: Returns a reference to a MIDI structure, or nil on error.
+ * Remember to free this MIDI file later to avoid memory leaks.
+ */
+VALUE a4r_API_load_midi(VALUE self, VALUE filename)
+{
+  MIDI *m = load_midi(StringValuePtr(filename));
+  if (m == NULL)
+    return Qnil;
+
+  VALUE obj = Data_Wrap_Struct(cAPI_MIDI, 0, 0, m);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   destroy_midi(midi) -> nil
+ *
+ * Destroys a MIDI structure when you are done with it. It is safe to call this
+ * even when the MIDI file might be playing, because it checks and will kill it
+ * off if it is active. Use this to avoid memory leaks in your program.
+ */
+VALUE a4r_API_destroy_midi(VALUE self, VALUE midi)
+{
+  MIDI *m;
+  Data_Get_Struct(midi, MIDI, m);
+  destroy_midi(m);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   play_midi(midi, loop) -> int
+ *
+ * Starts playing the specified MIDI file, first stopping whatever music was
+ * previously playing. If the loop flag is set to true, the data will be
+ * repeated until replaced with something else, otherwise it will stop at the
+ * end of the file. Passing a nil will stop whatever music is currently playing.
+ *
+ * Return value: Returns non-zero if an error occurs (this may happen if a
+ * patch-caching wavetable driver is unable to load the required samples, or at
+ * least it might in the future when somebody writes some patch-caching
+ * wavetable drivers :-)
+ */
+VALUE a4r_API_play_midi(VALUE self, VALUE midi, VALUE loop)
+{
+  MIDI *m;
+  if (midi == Qnil)
+    m = NULL;
+  else
+    Data_Get_Struct(midi, MIDI, m);
+
+  return INT2FIX(play_midi(m, RTEST(loop)));
+}
+
+/*
+ * call-seq:
+ *   midi_pause -> nil
+ *
+ * Pauses the MIDI player.
+ */
+VALUE a4r_API_midi_pause(VALUE self)
+{
+  midi_pause();
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   midi_resume -> nil
+ *
+ * Resumes playback of a paused MIDI file.
+ */
+VALUE a4r_API_midi_resume(VALUE self)
+{
+  midi_resume();
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   get_midi_length(midi) -> int
+ *
+ * This function will simulate playing the given MIDI, from start to end, to
+ * determine how long it takes to play. After calling this function, midi_pos
+ * will contain the negative number of beats, and midi_time the length of the
+ * midi, in seconds.
+ *
+ * Note that any currently playing midi is stopped when you call this function.
+ * Usually you would call it before play_midi, to get the length of the midi to
+ * be played, like in this example:
+ *   length = get_midi_length(my_midi)
+ *   play_midi(my_midi)
+ *   loop do
+ *     pos = midi_time
+ *     textprintf_ex(screen, font, 0, 0, c, -1, "%d:%02d / %d:%02d\n" %
+ *       [pos / 60, pos % 60, length / 60, length % 60])
+ *     rest(100)
+ *     break unless pos <= length
+ *   end
+ *
+ * Return value: Returns the value of midi_time, the length of the midi.
+ */
+VALUE a4r_API_get_midi_length(VALUE self, VALUE midi)
+{
+  MIDI *m;
+  Data_Get_Struct(midi, MIDI, m);
+  return INT2FIX(get_midi_length(m));
+}
+
+/*
+ * call-seq:
+ *   midi_pos -> int
+ *
+ * Stores the current position (beat number) in the MIDI file, or contains a
+ * negative number if no music is currently playing. Useful for synchronising
+ * animations with the music, and for checking whether a MIDI file has finished
+ * playing.
+ */
+VALUE a4r_API_midi_pos(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  return LONG2FIX(midi_pos);
+}
+
+/*
+ * call-seq:
+ *   midi_time -> int
+ *
+ * Contains the position in seconds in the currently playing midi. This is
+ * useful if you want to display the current song position in seconds, not as
+ * beat number.
+ */
+VALUE a4r_API_midi_time(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  return LONG2FIX(midi_time);
+}