URW_CharDesignerSource1.0.0

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace URWCharacterDesigner
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        //public List<string> cLayers = new List<string>(new []{ "Head", "Face", "Hands", "Arms", "Chest", "Waist", "Legs", "Feet", "Hair", "Beard"});
        //public List<string> cMaterials = new List<string>(new[] { "Birch", "Bark", "Linen", "Nettle", "Woolen", "Leather", "Fur", "Lamellar", "Mail", "Iron" });
        //public List<string> cType = new List<string>(new[] { "Apron", "Belt", "Cap", "Cloak", "Coudes", "Cowl", "Cowl, long", "Cuirass", "Dress", "Footrags", "Footwear", "Forearm guards", "Gauntlets", "Habergeon", "Hauberk", "Hauberk, long", "Helm", "Helm /w spectacle", "Hood", "Kneecops", "Leggings", "Mittens", "Mittens (+ forearm)", "Necklace", "Overcoat", "Rerebraces", "Shirt", "Shirt, long sleeves", "Shin guards", "Shoes", "Shoes, laced", "Socks", "Trousers", "Tunic", "Undergarment", "Undershirt", "Veil", "Beard" });
        //public List<string> cVarient = new List<string>(new[] { "Sheep (wool)", "Bear", "Badger", "Glutton", "Beaver", "Reindeer", "(Artic) Fox", "Elk", "Wolf", "Lynx", "Polecat", "Weasel", "Pine-marten", "Hare", "Ermine", "Squirrel", "Black grouse", "Capercaillie", "Pig", "Snake", "Boar", "Cow", "Dog", "Sow", "Swan" });
        public List<Sprite> LoadedSprites = new List<Sprite>();
        public Sprite SelectedSprite = null;
        public int[] IndexMath = new int[] { 0, 8, 11, 19 };

        public int ImageIndex
        {
            get
            {
                if (cbState.SelectedIndex == 1)
                {
                    return IndexMath[1];
                }
                else if (chb8Directional.Checked)
                {
                    return IndexMath[cbState.SelectedIndex] + cbDirection.SelectedIndex;
                }
                else
                {
                    if (cbDirection.SelectedIndex < 2 || cbDirection.SelectedIndex > 5)
                    {
                        return IndexMath[cbState.SelectedIndex] + 5;
                    }
                    else
                    {
                        return IndexMath[cbState.SelectedIndex] + 7;
                    }
                }
            }
        }

        public List<Sprite> SpriteLayers = new List<Sprite>();

        private void Form1_Load(object sender, EventArgs e)
        {
            ReadConfig();
        }


        public bool HasSpriteL(string Name)
        {
            foreach (Sprite s in SpriteLayers)
            {
                if (s.Name == Name)
                {
                    return true;
                }
            }
            return false;
        }

        public Sprite GetSpriteL(string Name)
        {
            foreach (Sprite s in SpriteLayers)
            {
                if (s.Name == Name)
                {
                    return s;
                }
            }
            return null;
        }

        public Sprite GetSprite(string Name)
        {
            foreach (Sprite s in LoadedSprites)
            {
                if (s.Name == Name)
                {
                    return s;
                }
            }
            return null;
        }

        public Sprite GetSprite(string Layer, string Material, string Type, string Variant)
        {
            foreach (Sprite s in LoadedSprites)
            {
                if (s.Layer == Layer && s.Material == Material && s.Type == Type && s.Variant == Variant)
                {
                    // LoadSpritePreview
                    pbItemPreview.Image = GetSpriteImages(s.FilePath)[ImageIndex];
                    return s;
                }
            }
            return null;
        }

        public void ValidateSpriteFiles()
        {
            foreach (Sprite s in LoadedSprites)
            {
                //MessageBox.Show(ImagePaths[0]);
                if (!File.Exists(s.FilePath))
                {
                    LoadedSprites.Remove(s);
                    if (MessageBox.Show(string.Format("Sprite image file does not exist in sprites folder: {0}", s.FilePath), "File not found", MessageBoxButtons.OKCancel) == DialogResult.Cancel)
                    {
                        Environment.Exit(0);
                    }
                }
            }
        }

        public List<Bitmap> GetSpriteImages(string Path) // PC model
        {
            List<Bitmap> Return = new List<Bitmap>();
            using (Bitmap bmpSprite = new Bitmap(Path))
            {
                bmpSprite.MakeTransparent(bmpSprite.GetPixel(0, 0));
                for (int i = 0; i < 27; i++)
                {
                    Return.Add(bmpSprite.Clone(new Rectangle(1 + (i * 65), 1, 64, 64), System.Drawing.Imaging.PixelFormat.DontCare));
                }
            }
            return Return;
        }

        public Bitmap GetCompiledLayers()
        {
            int[] DirectionRight = { 0, 1, 6, 7, 11, 12, 17, 18, 19, 20, 25, 26 }; // 7
            int[] DirectionLeft = { 2, 3, 4, 5, 13, 14, 15, 16, 21, 22, 23, 24 }; // 5
            Bitmap Return = new Bitmap(1800, 66);
            {
                using (Graphics g = Graphics.FromImage(Return))
                {
                    g.FillRectangle(Brushes.DarkMagenta, 0, 0, 1800, 66);
                    for (int i = lbLayers.Items.Count - 1; i > -1; i--)
                    {
                        if (HasSpriteL(lbLayers.Items[i].ToString()))
                        {
                            using (Bitmap bmpLoaded = new Bitmap(GetSpriteL(lbLayers.Items[i].ToString()).FilePath))
                            {
                                bmpLoaded.MakeTransparent(bmpLoaded.GetPixel(0, 0));

                                if (chbAddAll.Checked) // Generate all from 1 image 2dir
                                {
                                    if (!chb8Directional.Checked)
                                    {
                                        Bitmap BmpHolder = bmpLoaded.Clone(new Rectangle(1, 1, 64, 64), System.Drawing.Imaging.PixelFormat.DontCare);

                                        for (int x = 0; x < 28; x++)
                                        {
                                            g.DrawImage(BmpHolder, new Rectangle((x * 65) + 1, 1, 64, 64));
                                            g.FillRectangle(Brushes.White, new Rectangle((65 * 27) + 1, 0, 66, 66));
                                        }
                                    }
                                }

                                if (chb8Directional.Checked)
                                {
                                    g.DrawImage(bmpLoaded, new Rectangle(0, 0, 1800, 66));
                                    g.FillRectangle(Brushes.White, new Rectangle((65 * 27) + 1, 0, 66, 66));
                                }
                                else // generates 2dir from 8dir
                                {
                                    int LR = 0;
                                    int State = 0;
                                    for (int x = 0; x < 28; x++)
                                    {
                                        if (DirectionRight.Contains(x))
                                        {
                                            LR = 7;
                                        }
                                        else if (DirectionLeft.Contains(x))
                                        {
                                            LR = 5;
                                        }

                                        if (x == 11)
                                        {
                                            State = 11;
                                        }
                                        else if (x == 19)
                                        {
                                            State = 19;
                                        }
                                        else if (x > 7 && x < 11)
                                        {
                                            LR = x; State = 0;
                                        }

                                        g.DrawImage(bmpLoaded.Clone(new Rectangle(((LR + State) * 65), 0, 65, 66), System.Drawing.Imaging.PixelFormat.DontCare), new Rectangle((x * 65), 0, 65, 66));
                                        g.FillRectangle(Brushes.White, new Rectangle((65 * 27) + 1, 0, 66, 66));
                                    }
                                }

                                if (chbAddFallen.Checked) // rotate & center
                                {
                                    Bitmap BmpHolder = bmpLoaded.Clone(new Rectangle((5 * 65) + 1, 1, 64, 64), System.Drawing.Imaging.PixelFormat.DontCare);
                                    BmpHolder.RotateFlip(RotateFlipType.Rotate90FlipNone);
                                    g.DrawImage(BmpHolder, new Rectangle((8 * 65) -9, -2, 64, 64));
                                    BmpHolder = bmpLoaded.Clone(new Rectangle((7 * 65) + 1, 1, 64, 64), System.Drawing.Imaging.PixelFormat.DontCare);
                                    BmpHolder.RotateFlip(RotateFlipType.Rotate270FlipNone);
                                    g.DrawImage(BmpHolder, new Rectangle((9 * 65) +11, -2, 64, 64));
                                }

                                if (chbAddWading.Checked) // lower & crop
                                {
                                    if (chb8Directional.Checked)
                                    {
                                        for (int x = 11; x < 27; x++)
                                        {
                                            if (x >= 19) // shallow
                                            {
                                                Bitmap BmpHolder = bmpLoaded.Clone(new Rectangle(((x-19) * 65) + 1, 1, 64, 22), System.Drawing.Imaging.PixelFormat.DontCare);
                                                g.DrawImage(BmpHolder, new Rectangle((x * 65) + 1, 12, 64, 22));
                                            }
                                            else // deep
                                            {
                                                Bitmap BmpHolder = bmpLoaded.Clone(new Rectangle(((x-11) * 65) + 1, 1, 64, 14), System.Drawing.Imaging.PixelFormat.DontCare);
                                                g.DrawImage(BmpHolder, new Rectangle((x * 65) + 1, 19, 64, 14));
                                            }
                                        }
                                        g.FillRectangle(Brushes.White, new Rectangle((65 * 27) + 1, 0, 66, 66));
                                    }
                                    else // 2dir
                                    {
                                        for (int x = 12; x < 28; x++)
                                        {

                                            if (x >= 20) // shallow
                                            {
                                                if (DirectionLeft.Contains(x))
                                                {
                                                    Bitmap BmpHolder = bmpLoaded.Clone(new Rectangle((5 * 65) + 1, 1, 64, 22), System.Drawing.Imaging.PixelFormat.DontCare);
                                                    g.DrawImage(BmpHolder, new Rectangle((x * 65) + 1, 12, 64, 22));
                                                }
                                                else if (DirectionRight.Contains(x))
                                                {
                                                    Bitmap BmpHolder = bmpLoaded.Clone(new Rectangle((7 * 65) + 1, 1, 64, 22), System.Drawing.Imaging.PixelFormat.DontCare);
                                                    g.DrawImage(BmpHolder, new Rectangle((x * 65) + 1, 12, 64, 22));
                                                }
                                            }
                                            else
                                            {
                                                if (DirectionLeft.Contains(x))
                                                {
                                                    Bitmap BmpHolder = bmpLoaded.Clone(new Rectangle((5 * 65) + 1, 1, 64, 14), System.Drawing.Imaging.PixelFormat.DontCare);
                                                    g.DrawImage(BmpHolder, new Rectangle((x * 65) + 1, 19, 64, 14));
                                                }
                                                else if (DirectionRight.Contains(x))
                                                {
                                                    Bitmap BmpHolder = bmpLoaded.Clone(new Rectangle((7 * 65) + 1, 1, 64, 14), System.Drawing.Imaging.PixelFormat.DontCare);
                                                    g.DrawImage(BmpHolder, new Rectangle((x * 65) + 1, 19, 64, 14));
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return Return;
        }

        public void ReadConfig()
        {
            String[] Lines = File.ReadAllLines("Config.txt");  // sprite.png=(Name,Layer,Type,Material,Variant)
            LoadedSprites.Clear();
            foreach (string s in Lines)
            {
                if (s.Contains("="))
                {
                    string Path = s.Split('=')[0];
                    String[] Data = s.Split('=')[1].Substring(1).TrimEnd(")".ToCharArray()).Split(',');
                    if (Data.Length >= 4)
                    {
                        Sprite CurrentSprite = new Sprite() { FilePath = Environment.CurrentDirectory + "\\Sprites\\" + Path, Name = Data[0], Layer = Data[1], Type = Data[2], Material = Data[3] };
                        if (Data.Length > 4) { CurrentSprite.Variant = Data[4]; }
                        LoadedSprites.Add(CurrentSprite);
                    }
                }
            }
            ValidateSpriteFiles();
        }

        private void btn_Click(object sender, EventArgs e)
        {
            switch (((Button)sender).Name)
            {
                case "btnLayerUp":
                    if (lbLayers.SelectedIndex > 0 && lbLayers.Items.Count > 1)
                    {
                        int OldIndex = lbLayers.SelectedIndex;
                        lbLayers.Items.Insert(lbLayers.SelectedIndex - 1, lbLayers.SelectedItem);
                        lbLayers.Items.RemoveAt(OldIndex + 1);
                        lbLayers.SelectedIndex = OldIndex - 1;
                    }
                    break;
                case "btnLayerDown":
                    if ((lbLayers.SelectedIndex != -1) && (lbLayers.SelectedIndex < lbLayers.Items.Count - 1) && lbLayers.Items.Count > 1)
                    {
                        int OldIndex = lbLayers.SelectedIndex;
                        lbLayers.Items.Insert(lbLayers.SelectedIndex + 2, lbLayers.SelectedItem);
                        lbLayers.Items.RemoveAt(OldIndex);
                        lbLayers.SelectedIndex = OldIndex + 1;
                    }
                    break;
                case "btnLayerDelete":
                    int oIndex = lbLayers.SelectedIndex;
                    if (oIndex > -1)
                    {
                        SpriteLayers.Remove(GetSpriteL(lbLayers.Text));
                        if (oIndex - 1 > 0) { lbLayers.SelectedIndex = oIndex - 1; } else { lbLayers.SelectedIndex = 0; }
                        lbLayers.Items.RemoveAt(oIndex);
                        UpdateFullSheet();
                        UpdateFullPreview();
                    }
                    break;
                case "btnLayerDeleteAll":
                    SpriteLayers.Clear();
                    lbLayers.Items.Clear();
                    UpdateFullSheet();
                    UpdateFullPreview();
                    break;
                case "btnLayerLoad":
                    break;
                case "btnLayerSave":
                    break;
                case "btnLayerSaveAs":
                    break;
                case "btnAddItem":
                    if (!SpriteLayers.Contains(SelectedSprite) && SelectedSprite != null)
                    {
                        SpriteLayers.Add(SelectedSprite);
                        lbLayers.Items.Insert(0, SelectedSprite.Name);
                        UpdateFullSheet();
                        UpdateFullPreview();
                        lbLayers.SelectedIndex = 0;
                    }
                    break;
                case "btnSaveChar":
                    break;
                case "btnSaveCharAs":
                    break;
                case "btnBrowseItem":
                    OpenFileDialog ofdBrowse = new OpenFileDialog() { InitialDirectory = Environment.CurrentDirectory + "\\Sprites" };
                    if (ofdBrowse.ShowDialog() == DialogResult.OK)
                    {
                        foreach (Sprite s in LoadedSprites)
                        {
                            if (s.FilePath.Contains(ofdBrowse.FileName))
                            {
                                SelectedSprite = s;
                                cbLayer.Text = s.Layer;
                                cbType.Text = s.Type;
                                cbMaterial.Text = s.Material;
                                cbVariant.Text = s.Variant;
                            }
                        }
                    }
                    break;
                default:
                    break;
            }
        }

        private void cbLayer_SelectedIndexChanged(object sender, EventArgs e) // Select Layer
        {
            cbType.Items.Clear();
            cbType.Text = "";
            cbMaterial.Text = "";
            cbVariant.Text = "";
            cbType.Enabled = false;
            cbMaterial.Enabled = false;
            cbVariant.Enabled = false;

            foreach (Sprite s in LoadedSprites)
            {
                if (s.Layer == cbLayer.Items[cbLayer.SelectedIndex].ToString()) // Detect sprites of layer
                {
                    if (!cbType.Items.Contains(s.Type))
                    {
                        cbType.Items.Add(s.Type); // Add sprites of layer to type filter
                    }
                }
            }
            if (cbType.Items.Count > 0) { cbType.Enabled = true; } else { cbType.Enabled = false; cbMaterial.Enabled = false; cbVariant.Enabled = false; }
            if (cbMaterial.Text == "") { pbItemPreview.Image = null; }
        }

        private void cbType_SelectedIndexChanged(object sender, EventArgs e) // Select Type
        {
            cbMaterial.Items.Clear();
            cbMaterial.Text = "";
            cbMaterial.Enabled = false;
            cbVariant.Text = "";
            cbVariant.Enabled = false;
            if (cbType.Items.Count > 0)
            {
                foreach (Sprite s in LoadedSprites)
                {
                    if (s.Type == cbType.Items[cbType.SelectedIndex].ToString() && s.Layer == cbLayer.Items[cbLayer.SelectedIndex].ToString()) // Detect sprite of type
                    {
                        if (!cbMaterial.Items.Contains(s.Material))
                        {
                            cbMaterial.Items.Add(s.Material); // Add sprites of type to material filter
                        }
                    }
                }
            }
            if (cbMaterial.Items.Count > 0) { cbMaterial.Enabled = true; } else { cbMaterial.Enabled = false; cbVariant.Enabled = false; }
            if (cbMaterial.Text == "") { pbItemPreview.Image = null; }
        }

        private void cbMaterial_SelectedIndexChanged(object sender, EventArgs e) // Select Material
        {
            cbVariant.Items.Clear();
            cbVariant.Text = "";
            cbVariant.Enabled = false;
            if (cbMaterial.Items.Count > 0)
            {
                foreach (Sprite s in LoadedSprites)
                {
                    if (s.Material == cbMaterial.Items[cbMaterial.SelectedIndex].ToString() && s.Type == cbType.Items[cbType.SelectedIndex].ToString() && s.Layer == cbLayer.Items[cbLayer.SelectedIndex].ToString()) // Detect sprite of Material
                    {
                        if (!cbVariant.Items.Contains(s.Variant) && s.Variant != string.Empty)
                        {
                            cbVariant.Items.Add(s.Variant); // Add sprites of material to varient list
                        }
                    }
                }
            }
            if (cbVariant.Items.Count > 0) { cbVariant.Enabled = true; }
            else
            {
                cbVariant.Enabled = false;
                SelectedSprite = GetSprite(cbLayer.Text, cbMaterial.Text, cbType.Text, string.Empty);
            }
            if (cbMaterial.Text == "") { pbItemPreview.Image = null; }
        }

        private void cbVariant_SelectedIndexChanged(object sender, EventArgs e)
        {
            SelectedSprite = GetSprite(cbLayer.Text, cbMaterial.Text, cbType.Text, cbVariant.Text);
            //UpdatePreview
        }

        public void UpdateFullSheet()
        {
            if (lbLayers.Items.Count > 0)
            {
                using (Bitmap SpriteSheet = GetCompiledLayers())
                {
                    SpriteSheet.Save("TempSpriteSheet.png");
                }
            }
        }

        public void UpdateFullPreview()
        {
            if (lbLayers.Items.Count > 0)
            {
                pbCharPreview.BackgroundImage = ResizeBitmap(GetSpriteImages("TempSpriteSheet.png")[ImageIndex], 128,128);
            }
            else
            {
                pbCharPreview.BackgroundImage = new Bitmap(128,128);
            }
        }

        public Bitmap ResizeBitmap(Bitmap sourceBMP, int width, int height)
        {
            Bitmap result = new Bitmap(width, height);
            using (Graphics g = Graphics.FromImage(result))
            {
                g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;
                g.DrawImage(sourceBMP, 0, 0, width, height);
            }
            return result;
        }

        private void lbLayers_SelectedIndexChanged(object sender, EventArgs e) // Rerender on order change
        {
            UpdateFullSheet();
            UpdateFullPreview();
        }

        private void cbDirection_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(cbMaterial.Text))
            {
                pbItemPreview.Image = GetSpriteImages(SelectedSprite.FilePath)[ImageIndex];
            }
            UpdateFullSheet();
            UpdateFullPreview();
        }

        private void cbState_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(cbMaterial.Text))
            {
                pbItemPreview.Image = GetSpriteImages(SelectedSprite.FilePath)[ImageIndex];
            }
            UpdateFullSheet();
            UpdateFullPreview();
        }

        private void chb8Directional_CheckedChanged(object sender, EventArgs e)
        {
            UpdateFullSheet();
            UpdateFullPreview();
            if (!string.IsNullOrEmpty(cbMaterial.Text))
            {
                pbItemPreview.Image = GetSpriteImages(SelectedSprite.FilePath)[ImageIndex];
            }
        }

        private void chbAddWading_CheckedChanged(object sender, EventArgs e)
        {
            UpdateFullSheet();
            UpdateFullPreview();
            if (!string.IsNullOrEmpty(cbMaterial.Text))
            {
                pbItemPreview.Image = GetSpriteImages(SelectedSprite.FilePath)[ImageIndex];
            }
        }

        private void chbAddAll_CheckedChanged(object sender, EventArgs e)
        {
            UpdateFullSheet();
            UpdateFullPreview();
            if (!string.IsNullOrEmpty(cbMaterial.Text))
            {
                pbItemPreview.Image = GetSpriteImages(SelectedSprite.FilePath)[ImageIndex];
            }
        }

        private void chbAddFallen_CheckedChanged(object sender, EventArgs e)
        {
            UpdateFullSheet();
            UpdateFullPreview();
            if (!string.IsNullOrEmpty(cbMaterial.Text))
            {
                pbItemPreview.Image = GetSpriteImages(SelectedSprite.FilePath)[ImageIndex];
            }
        }
    }

    public class Sprite
    {
        public string FilePath, Layer, Name, Type, Material, Variant = "";
    }
}