allegro4r 0.0.1-x86-mswin32-60

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);
+}

data/ext/a4r_API_palette_routines.c

@@ -0,0 +1,112 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   set_palette(p) -> nil
+ *
+ * Sets the entire palette of 256 colors. You should provide an array of 256 RGB
+ * structures. Unlike set_color, there is no need to call vsync before this
+ * function. Example:
+ *   palette = PALETTE.new
+ *   ...
+ *   bmp = load_bitmap(filename, palette)
+ *   abort_on_error("Couldn't load bitmap!") if bmp.nil?
+ *   set_palette(palette)
+ */
+VALUE a4r_API_set_palette(VALUE self, VALUE p)
+{
+  // TODO: Check data type of palette? Also, allow array of 256 RGBs
+  PALETTE *pal;
+  Data_Get_Struct(p, PALETTE, pal);
+  set_palette(*pal);
+  return Qnil;
+}
+
+/*
+ * call_seq:
+ *   get_palette(p) -> nil
+ *
+ * Retrieves the entire palette of 256 colors. You should provide an array of
+ * 256 RGB structures to store it in. Example:
+ *   pal = PALETTE.new
+ *   ...
+ *   get_palette(pal)
+ */
+VALUE a4r_API_get_palette(VALUE self, VALUE p)
+{
+  // TODO: Check data type of p?
+  PALETTE *pal;
+  Data_Get_Struct(p, PALETTE, pal);
+  get_palette(*pal);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   default_palette -> pal
+ *
+ * The default IBM BIOS palette. This will be automatically selected whenever
+ * you set a new graphics mode. The palette contains 16 basic colors plus many
+ * gradients between them. If you want to see the values, you can write a small
+ * Allegro program which saves a screenshot with this palette, or open the
+ * grabber tool provided with Allegro and create a new palette object, which
+ * will use this palette by default.
+ */
+VALUE a4r_API_default_palette(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  PALETTE *pal = &default_palette;
+  VALUE obj = Data_Wrap_Struct(cAPI_PALETTE, 0, 0, pal);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   black_palette -> pal
+ *
+ * A palette containing solid black colors, used by the fade routines.
+ */
+VALUE a4r_API_black_palette(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  PALETTE *pal = &black_palette;
+  VALUE obj = Data_Wrap_Struct(cAPI_PALETTE, 0, 0, pal);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   desktop_palette -> pal
+ *
+ * The palette used by the Atari ST low resolution desktop. I'm not quite sure
+ * why this is still here, except that the grabber and test programs use it. It
+ * is probably the only Atari legacy code left in Allegro, and it would be a
+ * shame to remove it :-)
+ *
+ * The contents of this palette are 16 colors repeated 16 times. Color entry
+ * zero is equal to color entry 16, which is equal to color entry 24, etc.
+ *   Index      Color       RGB values
+ *     0     White          63  63  63
+ *     1     Red            63   0   0
+ *     2     Green           0  63   0
+ *     3     Yellow         63  63   0
+ *     4     Blue            0   0  63
+ *     5     Pink           63   0  63
+ *     6     Cyan            0  63  63
+ *     7     Grey           16  16  16
+ *     8     Light grey     31  31  31
+ *     9     Light red      63  31  31
+ *    10     Light green    31  63  31
+ *    11     Light yellow   63  63  31
+ *    12     Light blue     31  31  63
+ *    13     Light pink     63  31  63
+ *    14     Light cyan     31  63  63
+ *    15     Black           0   0   0
+ */
+VALUE a4r_API_desktop_palette(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  PALETTE *pal = &desktop_palette;
+  VALUE obj = Data_Wrap_Struct(cAPI_PALETTE, 0, 0, pal);
+  return obj;
+}

data/ext/a4r_API_sound_init_routines.c

@@ -0,0 +1,29 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   install_sound(digi, midi, cfg_path) -> int
+ *
+ * Initialises the sound module. You should normally pass DIGI_AUTODETECT and
+ * MIDI_AUTODETECT as the driver parameters to this function, in which case
+ * Allegro will read hardware settings from the current configuration file. This
+ * allows the user to select different values with the setup utility: see the
+ * config section for details. Alternatively, see the platform specific
+ * documentation for a list of the available drivers. The cfg_path parameter is
+ * only present for compatibility with previous versions of Allegro, and has no
+ * effect on anything.
+ *
+ * Return value: Returns zero if the sound is successfully installed, and -1 on
+ * failure. If it fails it will store a description of the problem in
+ * allegro_error.
+ */
+VALUE a4r_API_install_sound(VALUE self, VALUE digi, VALUE midi, VALUE cfg_path)
+{
+  char *c;
+  if (cfg_path == Qnil)
+    c = NULL;
+  else
+    c = StringValuePtr(cfg_path);
+
+  return INT2FIX(install_sound(FIX2INT(digi), FIX2INT(midi), c));
+}

data/ext/a4r_API_text_output.c

@@ -0,0 +1,178 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   font -> a_fnt
+ *
+ * A simple 8x8 fixed size font (the mode 13h BIOS default). If you want to
+ * alter the font used by the GUI routines, change this to point to one of your
+ * own fonts. This font contains the standard ASCII (U+20 to U+7F), Latin-1
+ * (U+A1 to U+FF), and Latin Extended-A (U+0100 to U+017F) character ranges.
+ */
+VALUE a4r_API_font(VALUE self)
+{
+  // TODO: Convert to data struct or cached or hooked variable?
+  FONT *fnt = font;
+  VALUE obj = Data_Wrap_Struct(cAPI_FONT, 0, 0, fnt);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   font = fnt -> fnt
+ *
+ * See font.
+ */
+VALUE a4r_API_font_set(VALUE self, VALUE f)
+{
+  FONT *fnt;
+  Data_Get_Struct(f, FONT, fnt);
+  font = fnt;
+  return f;
+}
+
+/*
+ * call-seq:
+ *   text_length(f, str) -> int
+ *
+ * Returns the length (in pixels) of a string in the specified font. Example:
+ *   width = text_length(font, "I love spam")
+ *   ...
+ *   bmp = create_bitmap(width, height)
+ */
+VALUE a4r_API_text_length(VALUE self, VALUE f, VALUE str)
+{
+  FONT *fnt;
+  Data_Get_Struct(f, FONT, fnt);
+  return INT2FIX(text_length(fnt, StringValuePtr(str)));
+}
+
+/*
+ * call-seq:
+ *   text_height(f) -> int
+ *
+ * Returns the height (in pixels) of the specified font. Example:
+ *   height = text_height(font)
+ *   ...
+ *   bmp = create_bitmap(width, height)
+ */
+VALUE a4r_API_text_height(VALUE self, VALUE f)
+{
+  FONT *fnt;
+  Data_Get_Struct(f, FONT, fnt);
+  return INT2FIX(text_height(fnt));
+}
+
+/*
+ * call-seq:
+ *   textout_ex(bmp, f, s, x, y, color, bg) -> nil
+ *
+ * Writes the string 's' onto the bitmap at position x, y, using the specified
+ * font, foreground color and background color. If the background color is -1,
+ * then the text is written transparently. If the foreground color is -1 and a
+ * color font is in use, it will be drawn using the colors from the original
+ * font bitmap (the one you imported into the grabber program), which allows
+ * multicolored text output. For high and true color fonts, the foreground color
+ * is ignored and always treated as -1. Example:
+ *   # Show the program's version in blue letters.
+ *   textout_ex(screen, font, "v4.2.0-beta2", 10, 10,
+ *              makecol(0, 0, 255), -1)
+ */
+VALUE a4r_API_textout_ex(VALUE self, VALUE bmp, VALUE f, VALUE s, VALUE x, VALUE y, VALUE color, VALUE bg)
+{
+  BITMAP *b;
+  Data_Get_Struct(bmp, BITMAP, b);
+  FONT *fnt;
+  Data_Get_Struct(f, FONT, fnt);
+  textout_ex(b, fnt, StringValuePtr(s), FIX2INT(x), FIX2INT(y), FIX2INT(color), FIX2INT(bg));
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   textout_centre_ex(bmp, f, s, x, y, color, bg) -> nil
+ *
+ * Like textout_ex, but interprets the x coordinate as the centre rather than
+ * the left edge of the string. Example:
+ *   # Important texts go in the middle.
+ *   width = text_length("GAME OVER")
+ *   textout_centre_ex(screen, font, "GAME OVER",
+ *                     SCREEN_W / 2, SCREEN_H / 2,
+ *                     makecol(255, 0, 0), makecol(0, 0, 0))
+ */
+VALUE a4r_API_textout_centre_ex(VALUE self, VALUE bmp, VALUE f, VALUE s, VALUE x, VALUE y, VALUE color, VALUE bg)
+{
+  BITMAP *b;
+  Data_Get_Struct(bmp, BITMAP, b);
+  FONT *fnt;
+  Data_Get_Struct(f, FONT, fnt);
+  textout_centre_ex(b, fnt, StringValuePtr(s), FIX2INT(x), FIX2INT(y), FIX2INT(color), FIX2INT(bg));
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   textprintf_ex(bmp, f, x, y, color, by, fmt) -> nil
+ *
+ * Formatted text output, using a printf style format string. Due to an internal
+ * limitation, this function can't be used for extremely long texts. If you
+ * happen to reach this limit, you can work around it by using uszprintf and
+ * textout_ex, which don't have any. Example:
+ *   textprintf_ex(screen, font, 10, 10, makecol(255, 100, 200),
+ *                 -1, "Score: %d" % player_score)
+ */
+VALUE a4r_API_textprintf_ex(VALUE self, VALUE bmp, VALUE f, VALUE x, VALUE y, VALUE color, VALUE bg, VALUE fmt)
+{
+  // TODO: Make this actually work like printf with arbitrary number of parameters
+  BITMAP *b;
+  Data_Get_Struct(bmp, BITMAP, b);
+  FONT *fnt;
+  Data_Get_Struct(f, FONT, fnt);
+  textprintf_ex(b, fnt, FIX2INT(x), FIX2INT(y), FIX2INT(color), FIX2INT(bg), StringValuePtr(fmt));
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   textprintf_centre_ex(bmp, f, x, y, color, bg, fmt) -> nil
+ *
+ * Like textprintf_ex, but interprets the x coordinate as the centre rather than
+ * the left edge of the string. This function shares the text length limitation
+ * of textprintf_ex. Example:
+ *   textprintf_centre_ex(screen, font, SCREEN_W / 2, 120,
+ *                        makecol(0, 100, 243), -1,
+ *                        "Your best score so far was %d!" %
+ *                        total_max_points)
+ */
+VALUE a4r_API_textprintf_centre_ex(VALUE self, VALUE bmp, VALUE f, VALUE x, VALUE y, VALUE color, VALUE bg, VALUE fmt)
+{
+  // TODO: Make this actually work like printf with arbitrary number of parameters
+  BITMAP *b;
+  Data_Get_Struct(bmp, BITMAP, b);
+  FONT *fnt;
+  Data_Get_Struct(f, FONT, fnt);
+  textprintf_centre_ex(b, fnt, FIX2INT(x), FIX2INT(y), FIX2INT(color), FIX2INT(bg), StringValuePtr(fmt));
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   textprintf_right_ex(bmp, f, x, y, color, bg, fmt) -> nil
+ *
+ * Like textprintf_ex, but interprets the x coordinate as the right rather than
+ * the left edge of the string. This function shares the text length limitation
+ * of textprintf_ex. Example:
+ *   textprintf_right_ex(screen, font, SCREEN_W - 10, 10,
+ *                       makecol(200, 200, 20), -1,
+ *                       "%d bullets left" % player_ammo)
+ */
+VALUE a4r_API_textprintf_right_ex(VALUE self, VALUE bmp, VALUE f, VALUE x, VALUE y, VALUE color, VALUE bg, VALUE fmt)
+{
+  // TODO: Make this actually work like printf with arbitrary number of parameters
+  BITMAP *b;
+  Data_Get_Struct(bmp, BITMAP, b);
+  FONT *fnt;
+  Data_Get_Struct(f, FONT, fnt);
+  textprintf_right_ex(b, fnt, FIX2INT(x), FIX2INT(y), FIX2INT(color), FIX2INT(bg), StringValuePtr(fmt));
+  return Qnil;
+}