Flyweight_Exercise.c

Go to the documentation of this file.

 
 
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "helpers/checkforkey.h"
#include "helpers/cursor.h"
#include "helpers/readkey.h"
#include "helpers/sleep.h"
 
#include "Flyweight_BigResourceManager.h"
#include "Flyweight_Display.h"
#include "Flyweight_Image.h"
#include "Flyweight_Exercise.h"
 
//=============================================================================
//=============================================================================
 
static int _Flyweight_GenerateBigResource(int numImages, int width, int height)
{
    int resourceId = -1;
 
    if (numImages < 1)
    {
        numImages = 1;
    }
    else if (numImages > 9)
    {
        numImages = 9;
    }
    if (width < 3)
    {
        width = 3;
    }
    if (height < 3)
    {
        height = 3;
    }
 
    size_t imageSize = (width * height) * numImages;
    BigResource* resource = calloc(1, sizeof(BigResource));
    if (resource != NULL)
    {
        char* image = calloc(1, imageSize + 1);
        if (image != NULL)
        {
            const char imageBackgroundCharacter[] = "0123456789";
 
            resource->data = image;
            resource->numImages = numImages;
 
            for (int row = 0; row < height; ++row)
            {
                int imageColumnOffset = row * (width * numImages);
                for (int imageIndex = 0; imageIndex < numImages; imageIndex++)
                {
                    char backgroundChar = imageBackgroundCharacter[imageIndex];
                    for (int colIndex = 0; colIndex < width; colIndex++)
                    {
                        if (row == 0 || (row + 1) == height)
                        {
                            // top and bottom row are the same.
                            if (colIndex == 0 || (colIndex + 1) == width)
                            {
                                image[imageColumnOffset + colIndex] = '+';
                            }
                            else
                            {
                                image[imageColumnOffset + colIndex] = '-';
                            }
                        }
                        else
                        {
                            // top and bottom row are the same.
                            if (colIndex == 0 || (colIndex + 1) == width)
                            {
                                image[imageColumnOffset + colIndex] = '|';
                            }
                            else
                            {
                                // All other rows are each the same -- except that
                                // each image is "numbered" where the background of the
                                // image reflects the number of the image (0, 1, 2, etc.).
                                image[imageColumnOffset + colIndex] = backgroundChar;
                            }
                        }
                    }
                    imageColumnOffset += width;
                }
            }
 
            resourceId = BigResourceManager_AddResource(resource);
            if (resourceId == -1)
            {
                free(image);
                image = NULL;
            }
        }
        else
        {
            printf("  Error!  Failed to allocate memory for the big image: size = %zu\n", imageSize);
        }
    }
    else
    {
        printf("  Error!  Failed to allocate memory for the big resource structure: size = %zu\n", sizeof(BigResource));
    }
    return resourceId;
}
 
 
static void _Flyweight_MoveFlyweights(Flyweight_ImageList* imageList,
    int display_width, int display_height)
{
    if (imageList != NULL)
    {
        for (size_t imageIndex = 0; imageIndex < imageList->images_count; imageIndex++)
        {
            Flyweight_Image* image = &imageList->images[imageIndex];
            Flyweight_Context* context = &image->Context;
            int image_width = context->ImageWidth;
            int image_height = context->ImageHeight;
            double newx = context->Position_X + context->Velocity_X;
            double newy = context->Position_Y + context->Velocity_Y;
 
            if (newx < 0 || (newx + image_width) > display_width)
            {
                // Bounce off left or right edge.
                context->Velocity_X = -context->Velocity_X;
                if (newx < 0)
                {
                    newx = 0;
                }
                else
                {
                    newx = display_width - image_width;
                }
            }
 
            if (newy < 0 || (newy + image_height) > display_height)
            {
                // Bounce off top or bottom edge.
                context->Velocity_Y = -context->Velocity_Y;
                if (newy < 0)
                {
                    newy = 0;
                }
                else
                {
                    newy = display_height - image_height;
                }
            }
 
            context->Position_X = newx;
            context->Position_Y = newy;
        }
    }
}
 
 
static void _Flyweight_RenderFlyweights(Flyweight_ImageList* imageList, Display* displayArea)
{
    if (imageList != NULL && displayArea != NULL)
    {
        // Render the image into the "display", one image for each instance
        // of the Flyweight class.
        for (size_t imageIndex = 0; imageIndex < imageList->images_count; imageIndex++)
        {
            Flyweight_Image* image = &imageList->images[imageIndex];
            Flyweight_Context* context = &image->Context;
            BigResource_Render(displayArea, image->BigResourceId,
                context->OffsetXToImage,
                context->ImageWidth,
                context->ImageHeight,
                (int)context->Position_X,
                (int)context->Position_Y);
        }
    }
}
 
 
static double GenerateVelocity(void)
{
    double speed = ((rand() % 5) + 1) / 5.0;
    double direction = ((rand() % 100) > 50) ? 1.0 : -1.0;
    return speed * direction;
}
 
 
static void _Flyweight_GenerateFlyweightClasses(int bigResourceId, int numFlyweights,
    int image_width, int image_height, int display_width, int display_height,
    Flyweight_ImageList* imageList)
{
    // Generate the instances of the flyweight class, randomizing the position
    // of each flyweight within the display.
    for (int index = 0; index < numFlyweights; ++index)
    {
        Flyweight_Image image = { 0 };
        image.Context.OffsetXToImage = index * image_width;
        image.Context.ImageWidth = image_width;
        image.Context.ImageHeight = image_height;
        // Make sure the entire image can be rendered at each position
        image.Context.Position_X = rand() % (display_width - image_width);
        image.Context.Position_Y = rand() % (display_height - image_height);
        // Randomize the initial velocity.
        image.Context.Velocity_X = GenerateVelocity();
        image.Context.Velocity_Y = GenerateVelocity();
 
        // Create an instance of the Flyweight_Class for the given big
        // resource and with the new context.
        image.BigResourceId = bigResourceId;
        Flyweight_ImageList_Add(imageList, &image);
    }
}
 
 
static void _Flyweight_ClearDisplay(Display* display)
{
    if (display != NULL && display->area != NULL)
    {
        for (int rowIndex = 0; rowIndex < display->height; rowIndex++)
        {
            char* row = display->area[rowIndex];
            for (int colIndex = 0; colIndex < display->width; ++colIndex)
            {
                row[colIndex] = '~';
            }
        }
    }
}
 
 
static void _Flyweight_GenerateDisplay(Display* display, int width, int height)
{
    if (Display_Create(display, width, height))
    {
        _Flyweight_ClearDisplay(display);
    }
}
 
static void _Flyweight_ShowDisplay(Display* display)
{
    if (display != NULL && display->area != NULL)
    {
        for (int rowIndex = 0; rowIndex < display->height; rowIndex++)
        {
            printf("  %s\n", display->area[rowIndex]);
        }
        printf("\n");
    }
}
 
//=============================================================================
//=============================================================================
 
// ! [Using Flyweight in C]
void Flyweight_Exercise(void)
{
    printf("\nFlyweight_Exercise\n");
 
    // Define the display and image size.
    const int DISPLAY_WIDTH = 80;
    const int DISPLAY_HEIGHT = 20;
    const int IMAGE_WIDTH = 30;
    const int IMAGE_HEIGHT = 5;
    const int NUMFLYWEIGHTS = 5;
    const int NUM_ITERATIONS = 1000;
 
    int bigResourceId = _Flyweight_GenerateBigResource(NUMFLYWEIGHTS, IMAGE_WIDTH, IMAGE_HEIGHT);
    printf("bigResourceId = %d\n", bigResourceId);
 
    Flyweight_ImageList imageList = { 0 };
    _Flyweight_GenerateFlyweightClasses(bigResourceId, NUMFLYWEIGHTS,
        IMAGE_WIDTH, IMAGE_HEIGHT, DISPLAY_WIDTH, DISPLAY_HEIGHT, &imageList);
 
    // Create the "display".
    // We use a list of character arrays so we can write to each
    // character position individually.  In C#, strings are immutable
    // and changing a character in a string is not allowed.
    Display displayArea = { 0 };
    _Flyweight_GenerateDisplay(&displayArea, DISPLAY_WIDTH, DISPLAY_HEIGHT);
 
    // Finally, display the rendered output.
    printf("  The image rendered %d times:\n", NUMFLYWEIGHTS);
    printf("\n"); // Blank line for iteration count
    _Flyweight_RenderFlyweights(&imageList, &displayArea);
    _Flyweight_ShowDisplay(&displayArea);
 
    disableinputecho();
    // Now let's have some fun and bounce those images around for a while!
    // (Or until a keypress.)
    int cursorLeft = -1;
    int cursorTop = -1;
    getcursorposition(&cursorTop, &cursorLeft);
    if (cursorLeft != -1 && cursorTop != -1)
    {
        cursorTop -= DISPLAY_HEIGHT + 1;
    }
 
    for (int index = 0; index < NUM_ITERATIONS; ++index)
    {
        if (cursorLeft != -1)
        {
            setcursorposition(cursorTop - 1, cursorLeft);
        }
        printf("  %5d/%d iterations [press a key to exit early]\n", index + 1, NUM_ITERATIONS);
        if (cursorLeft != -1)
        {
            setcursorposition(cursorTop, cursorLeft);
        }
 
        _Flyweight_ClearDisplay(&displayArea);
        _Flyweight_MoveFlyweights(&imageList, DISPLAY_WIDTH, DISPLAY_HEIGHT);
        _Flyweight_RenderFlyweights(&imageList, &displayArea);
        _Flyweight_ShowDisplay(&displayArea);
        sleep(16); // 60 frames a second
        if (checkforkey())
        {
            readkey();
            break;
        }
    }
    enableinputecho();
 
    // Cleanup
    Display_Destroy(&displayArea);
    Flyweight_ImageList_Clear(&imageList);
    BigResourceManager_Clear();
 
    printf("  Done.\n");
}
// ! [Using Flyweight in C]