Flyweight_Class.cs

Go to the documentation of this file.

 
 
using System.Collections.Generic;
 
namespace DesignPatternExamples_csharp
{
    public struct Flyweight_Context
    {
        public int OffsetXToImage;
        public int ImageWidth;
        public int ImageHeight;
        public double Position_X;
        public double Position_Y;
        public double Velocity_X;
        public double Velocity_Y;
 
        public Flyweight_Context(int offset_x, int image_width, int image_height, double position_x, double position_y, double velocity_x, double velocity_y)
        {
            OffsetXToImage = offset_x;
            ImageWidth = image_width;
            ImageHeight = image_height;
            Position_X = position_x;
            Position_Y = position_y;
            Velocity_X = velocity_x;
            Velocity_Y = velocity_y;
        }
    }
 
 
 
    //========================================================================
    //========================================================================
    //========================================================================
 
 
 
    public class Flyweight_Class
    {
        private BigResource _resource;
 
        private Flyweight_Context _context;
 
 
        internal Flyweight_Class(BigResource resource, Flyweight_Context context)
        {
            _resource = resource;
            _context = context;
        }
 
 
        public Flyweight_Context Context
        {
            get
            {
                return _context;
            }
            set
            {
                _context = value;
            }
        }
 
 
        public int ImageWidth
        {
            get
            {
                if (_resource != null)
                {
                    return _context.ImageWidth;
                }
                return 0;
            }
        }
 
 
        public int ImageHeight
        {
            get
            {
                if (_resource != null)
                {
                    return _context.ImageHeight;
                }
                return 0;
            }
        }
 
        public void Render(List<char[]> display, int offset_x, int image_width, int image_height, int position_x, int position_y)
        {
            // Let the big resource handle the rendering at the given position.
            _resource.Render(display, offset_x, image_width, image_height, position_x, position_y);
        }
    }
 
 
 
    //========================================================================
    //========================================================================
    //========================================================================
 
 
 
    class BigResource
    {
        List<string> _resource;
        int _resourceId;
 
        internal BigResource(List<string> resource, int resourceId)
        {
            _resource = resource;
            _resourceId = resourceId;
        }
 
        internal void Render(List<char[]> display, int offset_x, int image_width, int image_height, int position_x, int position_y)
        {
            int display_width = display[0].Length;
            int display_height = display.Count;
            int starting_position_x = position_x;
            int starting_position_y = position_y;
 
            // Size of image to render (can be smaller than actual image if image
            // lies partially off right or bottom of display).
            int image_render_width = image_width;
            int image_render_height = image_height;
 
            // Position into image to start rendering from (non-zero if
            // image is off the left or top edge of display).
            int starting_row_in_image = 0;
            int starting_col_in_image = offset_x;
 
            // Clip the image to the display.
            if (starting_position_x < 0)
            {
                starting_col_in_image = -starting_position_x;
                image_render_width += starting_position_x;
                starting_position_x = 0;
            }
            else if (starting_position_x + image_render_width > display_width)
            {
                image_render_width = display_width - starting_position_x;
            }
            if (starting_position_y < 0)
            {
                starting_row_in_image = - starting_position_y;
                image_render_height += starting_position_y;
                starting_position_y = 0;
            }
            else if (starting_position_y + image_render_height > display_height)
            {
                image_render_height = display_height - starting_position_y;
            }
 
            // If the image is even partially visible, render it
            if (image_render_width > 0 && image_render_height > 0)
            {
                int current_display_row = starting_position_y;
                int current_image_row = starting_row_in_image;
                for (int row = 0; row < image_render_height; ++row)
                {
                    for (int col = 0; col < image_render_width; ++col)
                    {
                        display[current_display_row][starting_position_x + col] = _resource[current_image_row][starting_col_in_image + col];
                    }
                    current_display_row += 1;
                    current_image_row += 1;
                }
            }
        }
        
        public int ResourceId
        {
            get
            {
                return _resourceId;
            }
        }
 
        public int ImageWidth
        {
            get
            {
                if (_resource != null && _resource.Count > 0)
                {
                    return _resource[0].Length;
                }
                return 0;
            }
        }
 
        public int ImageHeight
        {
            get
            {
                if (_resource != null)
                {
                    return _resource.Count;
                }
                return 0;
            }
        }
 
        public Flyweight_Class CreateFlyweight(Flyweight_Context context)
        {
            return new Flyweight_Class(this, context);
        }
    }
 
 
 
    //========================================================================
    //========================================================================
    //========================================================================
 
 
 
    public static class BigResourceManager
    {
        static List<BigResource> _resources = new List<BigResource>();
 
        static int _nextResourceId = 1;
 
        static int GetNextResourceId()
        {
            int nextId = _nextResourceId;
            ++_nextResourceId;
            return nextId;
        }
 
        public static int AddResource(List<string> rawResource)
        {
            int newResourceId = GetNextResourceId();
            BigResource addedResource = new BigResource(rawResource, newResourceId);
            _resources.Add(addedResource);
 
            return newResourceId;
        }
 
        internal static BigResource? FindResource(int resourceId)
        {
            BigResource? foundResource = null;
            foreach (BigResource resource in _resources)
            {
                if (resource.ResourceId == resourceId)
                {
                    foundResource = resource;
                    break;
                }
            }
 
            return foundResource;
        }
 
        public static Flyweight_Class? CreateFlyweight(int bigResourceId, Flyweight_Context context)
        {
            Flyweight_Class? flyweightClass = null;
            BigResource? bigResource = FindResource(bigResourceId);
            if (bigResource != null)
            {
                flyweightClass = bigResource.CreateFlyweight(context);
            }
            return flyweightClass;
        }
    }
}