示例#1
0
        /** <summary> Returns a palette image loaded from the specified bitmap image. </summary> */
        public static PaletteImage FromImage(Bitmap image, Palette palette)
        {
            PaletteImage paletteImage = new PaletteImage(image.Size);

            for (int x = 0; x < image.Width; x++)
            {
                for (int y = 0; y < image.Height; y++)
                {
                    Color imageColor    = image.GetPixel(x, y);
                    int   minDelta      = GetColorDelta(imageColor, palette.Colors[0]);
                    int   minDeltaIndex = 0;
                    for (int i = 10; i < palette.NumColors; i++)
                    {
                        int delta = GetColorDelta(imageColor, palette.Colors[i]);
                        if (delta < minDelta)
                        {
                            minDelta      = delta;
                            minDeltaIndex = i;
                        }
                    }
                    paletteImage.pixels[x, y] = (byte)minDeltaIndex;
                }
            }

            return(paletteImage);
        }
示例#2
0
 /** <summary> Inserts the specified palette image at the specified index. </summary> */
 public void Insert(int index, PaletteImage paletteImage)
 {
     if (paletteImage != null)
     {
         this.paletteImages.Insert(index, paletteImage);
         this.palettes.Insert(index, null);
         this.imageDirectory.entries.Insert(index, paletteImage.entry);
         this.numImages++;
     }
 }
示例#3
0
 /** <summary> Adds the specified palette image. </summary> */
 public void Add(PaletteImage paletteImage)
 {
     this.paletteImages.Add(paletteImage);
     this.palettes.Add(null);
     this.imageDirectory.entries.Add(paletteImage.entry);
     if (paletteImage != null)
     {
         this.numImages++;
     }
 }
示例#4
0
 /** <summary> Removes the specified palette image. </summary> */
 public void Remove(PaletteImage paletteImage)
 {
     if (paletteImage != null)
     {
         int index = this.paletteImages.IndexOf(paletteImage);
         this.paletteImages.RemoveAt(index);
         this.palettes.RemoveAt(index);
         this.imageDirectory.entries.RemoveAt(index);
         this.numImages--;
     }
 }
示例#5
0
        //=========== DRAWING ============
        #region Drawing

        /** <summary> Draws the terrain to the specified palette image. </summary> */
        public void Draw(PaletteImage p, Point point, int darkness)
        {
            point.X -= 32 + ((Origin.X - Origin.Y) * 32);
            point.Y -= 15 + ((Origin.X + Origin.Y) * 16);
            for (int x1 = 0; x1 < Size.Width; x1++)
            {
                for (int y1 = 0; y1 < Size.Height; y1++)
                {
                    if (Slope != -1 &&
                        ((Slope == 0 && x1 < Origin.X - 0) || (Slope == 2 && x1 > Origin.X + 2) ||
                         (Slope == 1 && y1 < Origin.Y - 1) || (Slope == 3 && y1 > Origin.Y + 1)))
                    {
                        LandTiles[0].DrawWithOffset(p, point.X + ((x1 - y1) * 32), point.Y + ((x1 + y1 - 1) * 16),
                                                    darkness, false, RemapColors.None, RemapColors.None, RemapColors.None
                                                    );
                    }
                    else if (Slope == -1 ||
                             (Slope % 2 == 0 && (x1 < Origin.X - 0 || x1 > Origin.X + 2)) ||
                             (Slope % 2 == 1 && (y1 < Origin.Y - 1 || y1 > Origin.Y + 1)))
                    {
                        /*(Slope % 2 == 0 && (x1 < Origin.X - 0 || x1 > Origin.X + 2)) ||
                        *  (Slope % 2 == 1 && (y1 < Origin.Y - 1 || y1 > Origin.Y + 1))) {*/
                        LandTiles[0].DrawWithOffset(p, point.X + ((x1 - y1) * 32), point.Y + ((x1 + y1) * 16),
                                                    darkness, false, RemapColors.None, RemapColors.None, RemapColors.None
                                                    );
                    }
                    else if (Slope == 0 && x1 == Origin.X + 2)
                    {
                        LandTiles[1].DrawWithOffset(p, point.X + ((x1 - y1) * 32), point.Y + ((x1 + y1) * 16),
                                                    darkness, false, RemapColors.None, RemapColors.None, RemapColors.None
                                                    );
                    }
                    else if (Slope == 1 && y1 == Origin.Y + 1)
                    {
                        LandTiles[2].DrawWithOffset(p, point.X + ((x1 - y1) * 32), point.Y + ((x1 + y1) * 16),
                                                    darkness, false, RemapColors.None, RemapColors.None, RemapColors.None
                                                    );
                    }
                    else if (Slope == 2 && x1 == Origin.X - 0)
                    {
                        LandTiles[3].DrawWithOffset(p, point.X + ((x1 - y1) * 32), point.Y + ((x1 + y1) * 16),
                                                    darkness, false, RemapColors.None, RemapColors.None, RemapColors.None
                                                    );
                    }
                    else if (Slope == 3 && y1 == Origin.Y - 1)
                    {
                        LandTiles[4].DrawWithOffset(p, point.X + ((x1 - y1) * 32), point.Y + ((x1 + y1) * 16),
                                                    darkness, false, RemapColors.None, RemapColors.None, RemapColors.None
                                                    );
                    }
                }
            }
        }
示例#6
0
 /** <summary> Draws the palette image into the specified palette image. </summary> */
 public void Draw(PaletteImage p, Point point, int darkness, bool glass, RemapColors remap1 = RemapColors.None, RemapColors remap2 = RemapColors.None, RemapColors remap3 = RemapColors.None)
 {
     for (int x1 = 0; x1 < Width; x1++)
     {
         for (int y1 = 0; y1 < Height; y1++)
         {
             if (x1 + point.X >= 0 && y1 + point.Y >= 0 && x1 + point.X < p.Width && y1 + point.Y < p.Height)
             {
                 p.pixels[x1 + point.X, y1 + point.Y] = GetColorIndexRemapped(pixels[x1, y1], p.pixels[x1 + point.X, y1 + point.Y], darkness, glass, remap1, remap2, remap3);
             }
         }
     }
 }
示例#7
0
        /** <summary> Draws the palette image into the specified palette image using the image entry's offset. </summary> */
        public void DrawWithOffset(PaletteImage p, int x, int y, int darkness, bool glass, RemapColors remap1 = RemapColors.None, RemapColors remap2 = RemapColors.None, RemapColors remap3 = RemapColors.None)
        {
            x += this.entry.XOffset;
            y += this.entry.YOffset;

            for (int x1 = 0; x1 < Width; x1++)
            {
                for (int y1 = 0; y1 < Height; y1++)
                {
                    if (x1 + x >= 0 && y1 + y >= 0 && x1 + x < p.Width && y1 + y < p.Height)
                    {
                        p.pixels[x1 + x, y1 + y] = GetColorIndexRemapped(pixels[x1, y1], p.pixels[x1 + x, y1 + y], darkness, glass, remap1, remap2, remap3);
                    }
                }
            }
        }
示例#8
0
 /** <summary> Sets the specified palette image at the specified index. </summary> */
 public void Set(int index, PaletteImage paletteImage)
 {
     if (paletteImage != null)
     {
         if (this.paletteImages[index] == null)
         {
             this.numImages++;
             if (this.palettes[index] != null)
             {
                 this.palettes[index] = null;
                 this.numPalettes--;
             }
         }
         this.paletteImages[index]          = paletteImage;
         this.imageDirectory.entries[index] = paletteImage.entry;
     }
 }
示例#9
0
 /** <summary> Draws the palette into the specified palette image. </summary> */
 public void Draw(PaletteImage p, Point point, Size colorSize)
 {
     for (int i = 0; i < colors.Length; i++)
     {
         int x2 = ((i + entry.XOffset) % 16) * colorSize.Width;
         int y2 = ((i + entry.XOffset) / 16) * colorSize.Height;
         for (int x1 = 0; x1 < colorSize.Width; x1++)
         {
             for (int y1 = 0; y1 < colorSize.Height; y1++)
             {
                 if (point.X + x1 + x2 >= 0 && point.Y + y1 + y2 >= 0 && point.X + x1 + x2 < p.Width && point.Y + y1 + y2 < p.Height)
                 {
                     p.pixels[point.X + x1 + x2, point.Y + y1 + y2] = (byte)(i + entry.XOffset);
                 }
             }
         }
     }
 }
示例#10
0
 /** <summary> Draws the palette into the specified palette image. </summary> */
 public void Draw(PaletteImage p, int x, int y, int colorWidth, int colorHeight)
 {
     for (int i = 0; i < colors.Length; i++)
     {
         int x2 = ((i + entry.XOffset) % 16) * colorWidth;
         int y2 = ((i + entry.XOffset) / 16) * colorHeight;
         for (int x1 = 0; x1 < colorWidth; x1++)
         {
             for (int y1 = 0; y1 < colorHeight; y1++)
             {
                 if (x + x1 + x2 >= 0 && y + y1 + y2 >= 0 && x + x1 + x2 < p.Width && y + y1 + y2 < p.Height)
                 {
                     p.pixels[x + x1 + x2, y + y1 + y2] = (byte)(i + entry.XOffset);
                 }
             }
         }
     }
 }
示例#11
0
 /** <summary> Draws the terrain to the specified palette image. </summary> */
 public void Draw(PaletteImage p, int x, int y, int darkness)
 {
     x -= 32 + ((Origin.X - Origin.Y) * 32);
     y -= 15 + ((Origin.X + Origin.Y) * 16);
     for (int x1 = 0; x1 < Size.Width; x1++)
     {
         for (int y1 = 0; y1 < Size.Height; y1++)
         {
             if (Slope == -1 ||
                 (Slope % 2 == 0 && x1 < Origin.X - 1 && x1 > Origin.X + 1) ||
                 (Slope % 2 == 1 && y1 < Origin.Y - 1 && y1 > Origin.Y + 1))
             {
                 LandTiles[0].DrawWithOffset(p, x + ((x1 - y1) * 32), y + ((x1 + y1) * 16),
                                             darkness, false, RemapColors.None, RemapColors.None, RemapColors.None
                                             );
             }
             else if (Slope == 0 && x1 == Origin.X + 1)
             {
                 LandTiles[1].DrawWithOffset(p, x + ((x1 - y1) * 32), y + ((x1 + y1) * 16),
                                             darkness, false, RemapColors.None, RemapColors.None, RemapColors.None
                                             );
             }
             else if (Slope == 1 && y1 == Origin.Y + 1)
             {
                 LandTiles[2].DrawWithOffset(p, x + ((x1 - y1) * 32), y + ((x1 + y1) * 16),
                                             darkness, false, RemapColors.None, RemapColors.None, RemapColors.None
                                             );
             }
             else if (Slope == 2 && x1 == Origin.X - 1)
             {
                 LandTiles[3].DrawWithOffset(p, x + ((x1 - y1) * 32), y + ((x1 + y1) * 16),
                                             darkness, false, RemapColors.None, RemapColors.None, RemapColors.None
                                             );
             }
             else if (Slope == 3 && y1 == Origin.Y - 1)
             {
                 LandTiles[4].DrawWithOffset(p, x + ((x1 - y1) * 32), y + ((x1 + y1) * 16),
                                             darkness, false, RemapColors.None, RemapColors.None, RemapColors.None
                                             );
             }
         }
     }
 }
示例#12
0
 /** <summary> Draws the object as it is in the dialog. </summary> */
 public virtual bool DrawDialog(PaletteImage p, Point position, Size dialogSize, DrawSettings drawSettings)
 {
     return(false);
 }
示例#13
0
        //=========== DRAWING ============
        #region Drawing

        /** <summary> Draws the object as it is in game. </summary> */
        public virtual bool Draw(PaletteImage p, Point position, DrawSettings drawSettings)
        {
            return(false);
        }
示例#14
0
        /** <summary> Writes the graphics data. </summary> */
        public void Write(BinaryWriter writer)
        {
            long startPosition = writer.BaseStream.Position;

            for (int i = 0; i < imageDirectory.NumEntries; i++)
            {
                ImageEntry entry = imageDirectory.entries[i];
                entry.StartAddress = (uint)(writer.BaseStream.Position - startPosition);

                if (entry.Flags.HasFlag(ImageFlags.DirectBitmap))
                {
                    if (!entry.Flags.HasFlag(ImageFlags.CompactedBitmap))
                    {
                        if (entry.Flags.HasFlag(ImageFlags.LandTile))
                        {
                            // Don't know what this flag does, but images can still be written normally.
                        }
                        PaletteImage paletteImage = this.paletteImages[i];

                        // Write each row
                        for (int y = 0; y < entry.Height; y++)
                        {
                            // Write each pixel in the row
                            for (int x = 0; x < entry.Width; x++)
                            {
                                writer.Write(paletteImage.Pixels[x, y]);
                            }
                        }
                    }
                    else
                    {
                        if (entry.Flags.HasFlag(ImageFlags.LandTile))
                        {
                            // Don't know what this flag does, but images can still be written normally.
                        }
                        PaletteImage paletteImage = this.paletteImages[i];

                        List <ScanLine> scanLines  = new List <ScanLine>();
                        ushort[]        rowOffsets = new ushort[entry.Height];
                        ushort          rowOffset  = (ushort)(entry.Height * 2);

                        // Write the scan lines in every row and figure out the scan line row offsets
                        for (int y = 0; y < (int)entry.Height; y++)
                        {
                            rowOffsets[y] = rowOffset;

                            ScanLine scanLine = new ScanLine();
                            scanLine.Row = (short)y;

                            // Continue until the next row
                            while ((scanLine.Count & 0x80) == 0x00)
                            {
                                // Reset the scan line count
                                scanLine.Count = 0;

                                // Find each scan line and then check if there's another one in the row
                                bool finishedScanLine = false;
                                bool lastScanLine     = true;
                                for (int x = 0; x + (int)scanLine.Offset < (int)entry.Width; x++)
                                {
                                    if (!finishedScanLine)
                                    {
                                        if (scanLine.Count == 0)
                                        {
                                            // If the scan line hasn't started yet, increment the offset
                                            if (paletteImage.Pixels[x + scanLine.Offset, y] == 0x00)
                                            {
                                                scanLine.Offset++;
                                                x--;
                                            }
                                            else
                                            {
                                                scanLine.Count = 1;
                                            }
                                        }
                                        else if (paletteImage.Pixels[x + scanLine.Offset, y] == 0x00 || x == 0x7F)
                                        {
                                            // If the next pixel is transparent or the scan line is as big as possible, finish the line
                                            finishedScanLine = true;
                                        }
                                        else
                                        {
                                            // Increment the scan line byte count
                                            scanLine.Count++;
                                        }
                                    }
                                    else if (paletteImage.Pixels[x + scanLine.Offset, y] != 0x00)
                                    {
                                        // There is another scan line after this
                                        lastScanLine = false;
                                        break;
                                    }
                                }
                                // Set the end flag if the scan line is the last in the row
                                if (lastScanLine)
                                {
                                    scanLine.Count |= 0x80;
                                }
                                // If the row has all transparent pixels, set the offset to 0
                                if (scanLine.Count == 0)
                                {
                                    scanLine.Offset = 0;
                                    scanLine.Count  = 0;
                                }

                                rowOffset += (ushort)(2 + (scanLine.Count & 0x7F));
                                scanLines.Add(scanLine);

                                // Increment the scan line count
                                if (!lastScanLine)
                                {
                                    scanLine.Offset += (byte)(scanLine.Count & 0x7F);
                                }
                            }
                        }

                        // Write the row offsets
                        for (int j = 0; j < entry.Height; j++)
                        {
                            writer.Write(rowOffsets[j]);
                        }

                        // Write the scan lines
                        for (int j = 0; j < scanLines.Count; j++)
                        {
                            writer.Write(scanLines[j].Count);
                            writer.Write(scanLines[j].Offset);
                            for (int k = 0; k < (int)(scanLines[j].Count & 0x7F); k++)
                            {
                                try {
                                    writer.Write(paletteImage.Pixels[k + scanLines[j].Offset, scanLines[j].Row]);
                                }
                                catch (Exception) {
                                }
                            }
                        }
                    }
                }
                else if (entry.Flags.HasFlag(ImageFlags.PaletteEntries))
                {
                    Palette palette = this.palettes[i];

                    // Write each color
                    for (int j = 0; j < entry.Width; j++)
                    {
                        // Yes, the colors are in the order blue, green, red
                        writer.Write(palette.Colors[j].B);
                        writer.Write(palette.Colors[j].G);
                        writer.Write(palette.Colors[j].R);
                    }
                }
            }
        }
示例#15
0
        /** <summary> Reads the graphics data. </summary> */
        public void Read(BinaryReader reader)
        {
            long startPosition = reader.BaseStream.Position;

            for (int i = 0; i < imageDirectory.NumEntries; i++)
            {
                ImageEntry entry = imageDirectory.entries[i];
                if (entry.Flags.HasFlag(ImageFlags.DirectBitmap))
                {
                    if (!entry.Flags.HasFlag(ImageFlags.CompactedBitmap))
                    {
                        if (entry.Flags.HasFlag(ImageFlags.LandTile))
                        {
                            // Don't know what this flag does, but images can still be read normally.
                        }
                        PaletteImage paletteImage = new PaletteImage(entry);
                        reader.BaseStream.Position = startPosition + entry.StartAddress;

                        // Read each row
                        for (int y = 0; y < entry.Height; y++)
                        {
                            for (int x = 0; x < entry.Width; x++)
                            {
                                byte b = reader.ReadByte();
                                paletteImage.Pixels[x, y] = b;
                            }
                        }
                        this.paletteImages.Add(paletteImage);
                        this.palettes.Add(null);
                        this.numImages++;
                    }
                    else
                    {
                        if (entry.Flags.HasFlag(ImageFlags.LandTile))
                        {
                            // Don't know what this flag does, but images can still be read normally.
                        }
                        PaletteImage paletteImage = new PaletteImage(entry);
                        uint[]       rowOffsets   = new uint[entry.Height];
                        reader.BaseStream.Position = startPosition + entry.StartAddress;

                        // Read the row offsets
                        for (int j = 0; j < entry.Height; j++)
                        {
                            rowOffsets[j] = reader.ReadUInt16();
                        }

                        // Read the scan lines in each row
                        for (int j = 0; j < entry.Height; j++)
                        {
                            reader.BaseStream.Position = startPosition + entry.StartAddress + rowOffsets[j];
                            byte b1 = 0;
                            byte b2 = 0;

                            // A MSB of 1 means the last scan line in a row
                            while ((b1 & 0x80) == 0)
                            {
                                // Read the number of bytes of data
                                b1 = reader.ReadByte();
                                // Read the offset from the left edge of the image
                                b2 = reader.ReadByte();
                                for (int k = 0; k < (int)(b1 & 0x7F); k++)
                                {
                                    byte b3 = reader.ReadByte();
                                    paletteImage.Pixels[(int)b2 + k, j] = b3;
                                }
                            }
                        }
                        this.paletteImages.Add(paletteImage);
                        this.palettes.Add(null);
                        this.numImages++;
                    }
                }
                else if (entry.Flags.HasFlag(ImageFlags.PaletteEntries))
                {
                    Palette palette = new Palette(entry);
                    reader.BaseStream.Position = startPosition + entry.StartAddress;

                    // Read each color
                    for (int j = 0; j < entry.Width; j++)
                    {
                        // Yes, the colors are in the order blue, green, red
                        byte blue  = reader.ReadByte();
                        byte green = reader.ReadByte();
                        byte red   = reader.ReadByte();

                        palette.Colors[j] = Color.FromArgb(red, green, blue);
                    }
                    this.paletteImages.Add(null);
                    this.palettes.Add(palette);
                    this.numPalettes++;
                }
            }
        }
示例#16
0
        /** <summary> Reads the palette image from the graphics data. </summary> */
        public PaletteImage ReadPaletteImage(BinaryReader reader, long startPosition, int index)
        {
            int        i     = index;
            ImageEntry entry = imageDirectory.entries[i];

            if (entry.Flags.HasFlag(ImageFlags.DirectBitmap))
            {
                if (!entry.Flags.HasFlag(ImageFlags.CompactedBitmap))
                {
                    if (entry.Flags.HasFlag(ImageFlags.LandTile))
                    {
                        // Don't know what this flag does, but images can still be read normally.
                    }
                    PaletteImage paletteImage = new PaletteImage(entry);
                    reader.BaseStream.Position = startPosition + entry.StartAddress;

                    // Read each row
                    for (int y = 0; y < entry.Height; y++)
                    {
                        for (int x = 0; x < entry.Width; x++)
                        {
                            byte b = reader.ReadByte();
                            paletteImage.Pixels[x, y] = b;
                        }
                    }
                    return(paletteImage);
                }
                else
                {
                    if (entry.Flags.HasFlag(ImageFlags.LandTile))
                    {
                        // Don't know what this flag does, but images can still be read normally.
                    }
                    PaletteImage paletteImage = new PaletteImage(entry);
                    uint[]       rowOffsets   = new uint[entry.Height];
                    reader.BaseStream.Position = startPosition + entry.StartAddress;

                    // Read the row offsets
                    for (int j = 0; j < entry.Height; j++)
                    {
                        rowOffsets[j] = reader.ReadUInt16();
                    }

                    // Read the scan lines in each row
                    for (int j = 0; j < entry.Height; j++)
                    {
                        reader.BaseStream.Position = startPosition + entry.StartAddress + rowOffsets[j];
                        byte b1 = 0;
                        byte b2 = 0;

                        // A MSB of 1 means the last scan line in a row
                        while ((b1 & 0x80) == 0)
                        {
                            // Read the number of bytes of data
                            b1 = reader.ReadByte();
                            // Read the offset from the left edge of the image
                            b2 = reader.ReadByte();
                            for (int k = 0; k < (int)(b1 & 0x7F); k++)
                            {
                                byte b3 = reader.ReadByte();
                                paletteImage.Pixels[(int)b2 + k, j] = b3;
                            }
                        }
                    }
                    return(paletteImage);
                }
            }
            else if (entry.Flags.HasFlag(ImageFlags.PaletteEntries))
            {
            }
            return(null);
        }