Chapter 2.2 Essentials of Game Programming with Allegro

al_init();

Allegro has to set up some bare essentials before you use any of its functions in the specific Allegro library, and this is done with al_init(), except in the following cases:

• • When using al_install_system() in place of al_init() to initialize the Allegro system. This function allows more control, such as specifying a custom atexit function.
• • When working with shared libraries. In this case, it’s generally advised not to call al_init() within the library itself. Instead, the application using the library should handle the initialization.
• • When using a preinitialized system. If another part of your application or another library has already initialized Allegro, calling al_init() again is unnecessary and could cause issues.
• • When using native dialogue functions provided by Allegro 5, such as:

  al_show_native_message_box

al_install_keyboard();

al_install_keyboard() enables keyboard input. Believe it or not, accepting keyboard input to your program isn’t mandatory!

ALLEGRO_DISPLAY* disp = al_create_display(320, 200);

al_create_display() tells Allegro to create an 800 × 600 pixel window. You may change the numbers, then recompile to view the change in size.

Setup for Handling Keyboard Input

Firstly, include necessary headers and initialize the keyboard subsystem. For keyboard, only allegro5/allegro.h is needed. (The same is not true of mouse and joystick, as you will see later.) Here is the example code:

Event-Based Input

In Allegro 5, event-based input refers to handling input through an event-driven system. This means that instead of continuously checking the state of input devices, the program responds to events as they occur. Here’s how it works:

• Event Queue: An event queue is used to store events generated by various input devices (keyboard, mouse, joystick, etc.).

  You create an event queue using al_create_event_queue() and register event sources (like the keyboard or display) with al_register_event_source().

• Event Types: Allegro defines various event types, such as ALLEGRO_EVENT_KEY_DOWN for key presses, ALLEGRO_EVENT_MOUSE_BUTTON_DOWN for mouse clicks, and ALLEGRO_EVENT_DISPLAY_CLOSE for window-close events.
• Event Loop: The event loop continuously checks for events in the event queue using functions like al_get_next_event() or al_wait_for_event(). When an event is detected, the program processes it accordingly.

The following is a simple example demonstrating event-based input handling in Allegro 5. Note here we are not error checking the loading of our libraries, as you saw in some of the chapter 1 code examples. Here, keeping with the minimal concept of a demo program (it is a simple example after all . . .), we’ll exit the program on an error. You’ll see this in some of the other code examples in this text, as we’re not creating production code, if you will, but only quick examples for the student. As a matter of fact, in the example after this one, we won’t even have exit code to check for initialization; we’ll leave that as an exercise for the student to determine where the appropriate code would go. In production or release code, however, note that it’s always good practice to include error checking in your code and exit gracefully with a warning message or error display of some kind. Here is the example code:

Event-based input handling is efficient and allows your program to respond to user actions in real time.

State-Based Input (Held Keys)

In Allegro 5, state-based input refers to a method of handling input where the current state of input devices (like the keyboard or mouse) is captured and stored at a specific point in time. This allows you to check the status of keys or buttons at any moment rather than relying on event-driven input alone.

The following code checks if a key is currently held down (e.g., for movement)—here, the left and right arrow keys—and then will move a red square left or right accordingly:

Complete Coding Example

With the knowledge we have just learned about handling keyboard input, we now can move to our next code example, which creates a bouncing ball simulation, with position displayed on the upper-right corner of the window. The ball stays within a container box and the program exits when Q is pressed. This will draw a colourful square on the screen and hold it until the key is pressed:

We need the fonts and primitives add-ons now. As long as your IDE has been set up by following the instructions given in the previous section, you can now directly build with VS Code, or compile the program with Allegro dependencies in a terminal:

Compile and run the program. You should see a screen with a bouncing object, a boundary box outline, and some text presenting the x and y position variables.

Types of Gaming Mice

• Standard Gaming Mice: These are versatile and suitable for a wide range of games, from first-person shooter (FPS) to real-time strategy (RTS) games.
• MMO Mice: Designed for massively multiplayer online games, these mice often have multiple programmable buttons to handle complex commands.
• FPS Mice: These are optimized for first-person shooters, featuring high-DPI (dots per inch) settings for precise aiming and quick movements.
• Ambidextrous Mice: Suitable for both left- and right-handed users, these mice offer symmetrical designs.

Key Features

• DPI (Dots Per Inch): Higher DPI settings allow for more sensitive and precise movements, which is crucial in fast-paced games.
• Polling Rate: This measures how often the mouse reports its position to the computer. A higher polling rate (e.g., 000 Hz) means more responsive performance.
• Programmable Buttons: Extra buttons can be customized for specific in-game actions, enhancing gameplay efficiency.
• Ergonomics: Comfortable design is essential for long gaming sessions to prevent strain and injury.

Popular Uses in Games

• First-Person Shooter (FPS): Precision and quick response times are critical, making high-DPI and low-latency mice ideal.
• Real-Time Strategy (RTS): Accurate clicking and multiple programmable buttons help manage complex commands and unit control.
• Massively Multiplayer Online (MMO): Extra buttons and macros are useful for managing numerous abilities and commands.

Top Gaming Mice in 2024

• Logitech G Pro X Superlight: Known for its lightweight design and high performance, it’s a favorite among professional gamers.
• Razer DeathAdder V3 Pro: Offers excellent ergonomics and precision, making it ideal for long gaming sessions.
• SteelSeries Rival 600: Features dual sensors for enhanced accuracy and customizable weights for a personalized feel.

Mouse-Only Games

There are also many games designed to be played primarily with a mouse. These include point-and-click adventures, puzzle games, and idle clickers. Websites like CrazyGames and Poki offer a variety of mouse-only games that you can enjoy.

Generally speaking, there are two ways you can choose to interpret mouse movement:

1. 1. Moving the mouse pointer and clicking around as you normally would.
2. 2. Using the speed of the mouse to control something in the game. This allows you to use the mouse a bit like a joystick; most PC-based first-person shooters do this to allow the player to speedily aim.

Steps to Use Mouse in Allegro Games

To use the mouse in Allegro games, we will need to follow a few steps to initialize and handle mouse input. Here’s a basic guide to get you started:

1. 1. Initialize the Mouse

   First, you need to install the mouse handler using al_install_mouse(). This function sets up the mouse for use in your game:

      if (!al_install_mouse()) {

          fprintf(stderr, "Failed to initialize the mouse!\n");

          return—;

      }

2. 2. Check Mouse State

   You can retrieve the current state of the mouse using al_get_mouse_state(). This function fills an ALLEGRO_MOUSE_STATE structure with the current mouse position and button states:

      ALLEGRO_MOUSE_STATE state;

      al_get_mouse_state(&state);

3. 3. Handle Mouse Input

   You can check the position and button states from the ALLEGRO_MOUSE_STATE structure. For example, to get the mouse coordinates and check if the left button is pressed, use this:

      int mouse_x = state.x;

      int mouse_y = state.y;

      if (al_mouse_button_down(&state, )) {

          // Left mouse button is pressed

      }

4. 4. Display Mouse Cursor

   To show the mouse cursor on the screen, use al_show_mouse_cursor(display), where display is your Allegro display:

      al_show_mouse_cursor(display);

Types of Joysticks

• Digital Joysticks: These are the simplest form, where the joystick can be moved in four or eight directions. They are often used in arcade games.
• Analog Joysticks: These provide a range of motion and are more precise, making them ideal for flight simulators and racing games.
• HOTAS (Hands-On Throttle-And-Stick): These are advanced setups that include a joystick and a separate throttle control, often used in flight simulators for a more immersive experience.

Key Features of Joysticks

• Buttons: Joysticks typically have multiple buttons that can be programmed for different functions in a game.
• Hat Switch: A small joystick on top of the main stick used for looking around in a game.
• Throttle Control: Found in HOTAS setups, it allows for precise control of speed in flight simulators.

Popular Uses in Games

• Flight Simulators: Joysticks provide the most realistic control for flying aircraft in games like Microsoft Flight Simulator.
• Space Simulators: Games like Elite Dangerous and Star Citizen benefit from the precise control offered by joysticks.
• Arcade Games: Classic arcade games often use digital joysticks for their simple and responsive controls.

Best Joysticks for Video Games in 2024

• Thrustmaster HOTAS Warthog: Known for its build quality and precision, it’s a favorite among flight sim enthusiasts.
• Logitech G X56 HOTAS RGB: Offers a good balance between features and price, suitable for both beginners and experienced users.
• Thrustmaster T.Flight HOTAS X: A budget-friendly option that still provides a solid experience.

Joysticks enhance the gaming experience by providing more intuitive and precise control, especially in games that simulate real-world activities.

Steps to Use a Joystick in Your Allegro 5 Games

To use a joystick in your Allegro 5 games requires the following steps:

1. 1. Initialize the Joystick
   • • Include the Allegro joystick header—#include <allegro5/allegro.h>
   • • Install the joystick driver using al_install_joystick().
   • • Check if the joystick is installed with al_is_joystick_installed().
2. 2. Get Joystick Information
   • • Use al_get_num_joysticks() to find out how many joysticks are connected.
   • • Retrieve a joystick object with al_get_joystick().
3. 3. Read Joystick State
   • • Create an ALLEGRO_JOYSTICK_STATE object.
   • • Use al_get_joystick_state() to update the state of the joystick.
4. 4. Handle Joystick Events
   • • Register the joystick event source with al_get_joystick_event_source().
   • • Use an event queue to handle joystick events like button presses and axis movements.

Here’s a simple example to get you started:

The CollisionTest Program

The CollisionTest program demonstrates basic collision detection principles by simulating interactions between two game objects. The setup involves:

• Sprites: These are visual representations of objects; we will use simple squares.
• Movement and Interaction: The program detects collisions as sprites move, triggering predefined responses such as bouncing or stopping.

As with previous code examples, we have the usual basic constructs of code: we have our setup and initialization phase: We load sprites, set initial positions, and define movement parameters.

We then have our game loop functions, which here will do the following:

• • Check for collisions in every frame.
• • Perform a collision response—that is, execute an appropriate reaction, such as reversing direction or displaying an effect. For our demonstration program, we will simply change the direction of the sprite objects after they collide (here a complete overlap) and print a message on the screen.

The primary element of code we need to examine here is of course the collision detection function. We begin with the Sprite struct, which stores the following information elements of the Sprite object (see table 2):

Using these variables, we can create a function to examine the location of two sprites to see if their edges are touching or overlapping. Imagine in our game we have a sprite at position (100, 150) on our screen with size (50 × 50) and velocity (2, 3). The memory representation of that Sprite struct information is then as shown in table 3.

In each iteration of our game loop, movement-wise, this sprite—we’ll call it Sprite A—will move 2 pixels right and 3 pixels down per animation frame.

Explaining the check_collision Function

We talked previously about what a bounding box collision was, and since our simple example is using basic shapes (squares), we will implement one here. Our check collision function looks like this:

This function checks if two sprites overlap (collide) on the screen. It uses axis—aligned bounding box (AABB) collision detection, which is a fast method for detecting rectangle-based collisions and returns a simple true or false condition. Note the use of the logical AND operator (&&) in the return logic. If all four conditions are true, then the sprites overlap, and the collision detection function returns a “true” condition.

Understanding the Conditions

The function checks if the bounding boxes of two sprites overlap by looking at the edges of the two objects:

1. 1. a->x < b->x + b->width

   Ensures Sprite A’s left edge is to the left of Sprite B’s right edge.

2. 2. a->x + a->width > b->x

   Ensures Sprite A’s right edge is to the right of Sprite B’s left edge.

3. 3. a->y < b->y + b->height

   Ensures Sprite A’s top edge is above Sprite B’s bottom edge.

4. 4. a->y + a->height > b->y

   Ensures Sprite A’s bottom edge is below Sprite B’s top edge.

Axis-Aligned Bounding Box (AABB)

For two axis-aligned bounding boxes, the collision detection can be determined by checking if their edges overlap. The equations are:

Circle Collision

For circular objects, the collision detection is based on the distance between their centers. The equation is:

Where ( A ) and ( B ) are the circles with properties ( x ), ( y ), and ( radius ).

Separating Axis Theorem (SAT)

The Separating Axis Theorem is used for detecting collisions between convex polygons. It involves projecting the vertices of the polygons onto various axes and checking for overlaps. The key idea is that if there is a separating axis where the projections do not overlap, then the polygons do not collide.

1. 1. Projection of a Point onto an Axis

   Given a point P and an axis A, the projection P’ is

   

2. 2. Overlap Check

   For two polygons, project all vertices onto the axis and find the minimum and maximum values for each polygon. If the intervals overlap on all axes, the polygons collide.

Line Segment vs. Triangle

To check if a line segment intersects a triangle, you can use the following steps:

1. 1. Compute Signed Distances

   Compute the signed distances of the segment endpoints to the plane of the triangle:

   d = P − V₀ ∙ N

   d₂ = P₂ − V₀ ∙ N

   Where P and P2 are the segment endpoints, V0 is a vertex of the triangle, and N is the normal of the triangle.

2. 2. Intersection Point

   If the signs of d and d2 are different, compute the intersection point P:

   

3. 3. Point Inside Triangle

   Check if the intersection point P is inside the triangle using barycentric coordinates or edge tests.

These equations form the basis of many collision detection algorithms used in games. For more detailed information, you can ask an AI assistant about lectures on collision detection algorithms in video games.

Importance of Sound Effects

1. 1. Emotional Impact

   Music sets the emotional tone of the game, influencing the player’s mood and reactions. For example, a tense soundtrack can heighten the sense of danger, while a calm melody can create a peaceful atmosphere.

2. 2. Immersion

   Sound effects and ambient sounds help create a believable game world. The sound of footsteps, rustling leaves, or distant explosions can make the game environment feel more real.

3. 3. Feedback

   Audio cues provide feedback to the player, indicating actions or events. For instance, a sound effect might signal that a player has successfully completed a task or that an enemy is nearby.

4. 4. Narrative Enhancement

   Music and sound effects can enhance the storytelling aspect of games. They can underscore dramatic moments, highlight important events, and support the narrative flow.

Components of Game Audio

1. 1. Music

   Composed specifically for the game, music can vary depending on the game’s genre and setting. Dynamic music systems can change the music based on the player’s actions or the game’s state.

2. 2. Sound Effects (SFX)

   These include all the sounds made by characters, environments, and actions within the game. High-quality sound effects can significantly enhance the realism and immersion of the game.

3. 3. Voice Acting

   Voice acting brings characters to life, adding depth to the narrative and making interactions more engaging. Good voice acting can greatly enhance the player’s connection to the story and characters.

4. 4. Ambient Sounds

   Background sounds that create the atmosphere of the game world. These can include environmental sounds like wind, water, and wildlife, which help to set the scene and make the world feel alive.

Setting Up

1. 1. Initialize Allegro and Audio Add-Ons

   if (!al_init()) {

       fprintf(stderr, "Allegro failed to init\n");

       return—1;

   }

   al_install_keyboard();

   al_install_audio();

   al_init_acodec_addon();

   al_reserve_samples(8);

2. 2. Load Audio Files

   Load your audio files into ALLEGRO_SAMPLE objects. Allegro supports various formats like WAV, OGG, and FLAC:

   ALLEGRO_SAMPLE *sfx = al_load_sample("sound.wav");

    if (!sfx) {

        fprintf(stderr, "Couldn't load sound.wav\n");

        return—1;

    }

3. 3. Play Sound Effects

   To play a sound effect, use al_play_sample. Note that sound effects are often used in a “one-shot” type of occurrence with an event—that is, they don’t repeat, and as such, we use a single play mode: ALLEGRO_PLAYMODE_ONCE.

       // Play sound effect

    al_play_sample(sfx, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, nullptr);

4. 4. Load and Play Music

   For background music, unlike the one-shot sound effect, we will use the looping function, as background music tends to play continuously. We specify this mode with ALLEGRO_PLAYMODE_LOOP.

   ALLEGRO_AUDIO_STREAM *music = al_load_audio_stream("music.ogg", 4, 2048);

   if (!music) {

       fprintf(stderr, "Couldn't load music.ogg\n");

       return—1;

   }

   al_set_audio_stream_playmode(music, ALLEGRO_PLAYMODE_LOOP);

   al_attach_audio_stream_to_mixer(music, al_get_default_mixer());

   Note also the use of two new functions here related to playback in Allegro: the audio stream mode and the audio stream mixer. Here, our music file is a larger continuous audio event (unlike a short sound sample), and so it is a “stream” of audio. We denote “music” as our “stream” and so set the play mode for that to LOOP. We then take that music stream and feed it to the default Allegro sound mixer. The Allegro mixer function lets us modify the playback characteristics if we wish; here, we don’t make any changes to the audio and use the defaults. In a future chapter, we’ll look at some of the uses of the mixer and its effect, but for now, just consider it a requirement for the output of the sound—the software speaker, as it were.

Example Code

Here’s a complete example demonstrating how to set up and play sound and music in an Allegro game. It will start the music playback with a quick sound effect at the beginning, then continue to play. At the end of the music, after a brief pause, it will play again but with no sound effect and continue to do so until the example is ended:

Live Streaming Gameplay

Live streaming gameplay involves broadcasting your gaming sessions to an audience in real time. This has become incredibly popular on platforms like Twitch, YouTube Gaming, and Facebook Gaming. Here’s how you can get started:

1. 1. Equipment
   • Good Gaming PC: Ensure your PC can handle both gaming and streaming simultaneously.
   • Webcam and Microphone: Use for better interaction with your audience.
   • Capture Card: Use if you’re streaming from a console.
2. 2. Software
   • OBS Studio: A free and open-source software for video recording and live streaming.
   • Streamlabs OBS: A user-friendly version of OBS with additional features for streamers.
3. 3. Setting Up
   • Create an account on your chosen streaming platform.
   • Configure your streaming software with your platform’s stream key.
   • Set up scenes and sources in OBS to include your game, webcam, and overlays.
4. 4. Engage with Your Audience
   • Interact with viewers through chat.
   • Use alerts and notifications to acknowledge new followers, subscribers, and donations.

Game Streaming Services

Game streaming services allow you to play games on various devices without needing powerful hardware. The game runs on a remote server or on your gaming PC, and the video is streamed to your device. Here are some popular services:

• Steam Remote Play: Stream games from your PC to other devices like phones, tablets, and TVs using Steam Link.
• NVIDIA GeForce NOW: Play your PC games from the cloud on various devices. It supports a wide range of games from different platforms.
• Xbox Cloud Gaming (xCloud): Part of Xbox Game Pass Ultimate, allowing you to stream Xbox games to your PC, phone, or tablet.
• PlayStation Now: Stream a library of PlayStation games to your PC or PlayStation console.

Getting Started with Game Streaming Services

• Choose a Service: Select a service that supports the games you want to play and is available in your region.
• Set Up Your Account: Create an account and subscribe to the service if necessary.
• Install the App: Download and install the app on your device.
• Connect a Controller: Many services support Bluetooth controllers for a better gaming experience.
• Start Playing: Launch the app, log in, and start streaming your games.

Streaming in video games, whether live streaming your gameplay or using game streaming services, offers a flexible and engaging way to enjoy and share gaming experiences.

Media Streaming in Allegro Games

With Allegro, we have the ability to stream audio or video content within your game. Audio streaming capabilities are one of Allegro’s add-on functions for video, though one will need to utilize an external library. Here’s how you would handle both.

Importance of Timers and Timing

1. 1. Gameplay Mechanics

   Timers are often used to create time-based challenges, such as countdowns for completing a task or time limits for levels. This adds urgency and excitement to the gameplay.

2. 2. Animation and Movement

   Timing is essential for smooth animations and character movements. Consistent timing ensures that animations run at the correct speed and look natural.

3. 3. Game Loops

   The game loop relies on precise timing to update game states and render frames consistently. This ensures a smooth and responsive gaming experience.

Types of Timers

1. 1. Real-Time Timers

   These timers measure actual elapsed time and are used for tasks that need to happen at specific intervals, such as spawning enemies or updating the game state.

2. 2. Frame-Based Timers

   These timers are based on the number of frames rendered. They are useful for animations and movements that need to be consistent regardless of the frame rate.

3. 3. Event Timers

   These timers trigger specific events after a set period. They are often used for delayed actions, such as power-ups or timed events.

Types of Files in Games

1. 1. Asset Files

   These include images, sounds, music, models, and other resources used in the game. They are often stored in formats like PNG, WAV, MP3, OBJ, and so on.

2. 2. Configuration Files

   These files store settings and preferences for the game. Common formats include INI, JSON, and XML.

3. 3. Save Files

   Save files store the player’s progress and game state. They can be in various formats, often custom to the game.

4. 4. Log Files

   Log files record events and errors that occur during gameplay, useful for debugging and support.

Behavior

The program attempts to read from a configuration file (config.ini) located in the same directory as the executable. This file would typically contain user-defined settings for various subsystems. On each execution, the program logs the success or failure of initializing these components to game.log.

Since the required assets (e.g., sound files, graphics, and config.ini) are deliberately omitted, the program will launch and then exit immediately. After execution, you can inspect game.log to see which components failed to initialize.

How to Test

To observe changes in behavior:

1. 1. Run the executable as is and examine game.log.
2. 2. Add one or more of the missing files (e.g., config.ini) to the executable’s directory.
3. 3. Run the program again and compare the updated log entries.

This approach helps illustrate how initialization routines and logging mechanisms behave under failure conditions and how they can be used to diagnose missing or misconfigured resources.

Here’s the complete example demonstrating how to load an image, read a configuration file, save game state, and log events in an Allegro game:

Setting Up PhysicsFS

1. 1. Install PhysicsFS

   Download and install PhysicsFS from the official website.

2. 2. Include PhysicsFS in Your Project

   Make sure to include the PhysicsFS header and link to the PhysicsFS library in your project.

Integrating PhysicsFS with Allegro

1. 1. Initialize PhysicsFS

   Initialize PhysicsFS and set up the search path:

   if (PHYSFS_init(NULL) == 0) {

        fprintf(stderr, "Failed to initialize PhysicsFS—%s\n",

                PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));

        return—1;

    }

    if (PHYSFS_mount("data.zip", NULL, 1) == 0) {

        fprintf(stderr, "Failed to mount archive—%s\n",

                PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));

        PHYSFS_deinit();

        return—1;

    }

2. 2. Set Allegro to Use PhysicsFS

   Use Allegro’s PhysicsFS add-on to set the file interface:

      al_set_physfs_file_interface();

3. 3. Load Files Using Allegro’s File I/O API

   Now you can load files from the archive using Allegro’s standard file I/O functions:

      ALLEGRO_BITMAP *image = al_load_bitmap("image.png");

   if (!image) {

       fprintf(stderr, "Failed to load image!\n");

       al_destroy_display(display);

       PHYSFS_deinit();

       return—1;

   }

   ALLEGRO_SAMPLE *sound = al_load_sample("sound.wav");

   if (!sound) {

       fprintf(stderr, "Failed to load sound!\n");

       al_destroy_bitmap(image);

       al_destroy_display(display);

       PHYSFS_deinit();

       return—1;

   }

Example Code

In this example, we’ll use PhysicsFS with Allegro 5 to open a data file, data.zip, and extract an image to display (image.png) and a sound to play (sound.wav). The program will get the data files from data.zip, play a sound, and display the image for 15 seconds:

Setting Up

1. 1. Include the memfile Header

   Make sure to include the allegro_memfile.h header in your project:

      #include <allegro5/allegro.h>

      #include <allegro5/allegro_memfile.h>

2. 2. Link with the memfile Add-On

   Ensure your project links against the allegro_memfile library.

3. 3. Create and Use memfiles
   • Create a Memfile: Use al_open_memfile to create a memfile from a block of memory:

      char data = "This is some data in memory.";

      ALLEGRO_FILE *memfile = al_open_memfile(data, sizeof(data), "r");

      if (!memfile) {

          fprintf(stderr, "Failed to create memfile!\n");

          return-1;

      }

   • Read from the memfile: You can read from the memfile using Allegro’s file I/O functions:

      char buffer[256];

      al_fread(memfile, buffer, sizeof(data));

      printf("Read from memfile—%s\n", buffer);

   • Write to the memfile: If the memfile is opened in write mode, you can write to it:

      ALLEGRO_FILE *writable_memfile = al_open_memfile(data, sizeof(data), "w");

      if (!writable_memfile) {

          fprintf(stderr, "Failed to create writable memfile!\n");

          return-1;

      }

      const char *new_data = "New data in memory.";

      al_fwrite(writable_memfile, new_data, strlen(new_data) + );

   • Close the memfile: Always close the memfile when you’re done:

      al_fclose(memfile);

      al_fclose(writable_memfile);

Example Code

Here’s a complete example demonstrating how to create, read from, and write to a memfile in Allegro 5:

This example initializes Allegro, creates a memfile from a block of memory, reads from it, writes new data to it, and then prints the updated data.