private void lstAttack_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            if (lstAttack.SelectedIndex >= 0 && lstAttack.Items[lstAttack.SelectedIndex] is ProjectEternityAttackEditor)
            {
                ProjectEternityAttackEditor ActiveEditor = (ProjectEternityAttackEditor)lstAttack.Items[lstAttack.SelectedIndex];
                ActiveEditor.ShowDialog();

                _ListAttack[lstAttack.SelectedIndex].ItemName = ActiveEditor.txtName.Text;
                //Refresh text
                lstAttack.Items[lstAttack.SelectedIndex] = lstAttack.SelectedItem;
            }
        }
        public override void SaveItem(string ItemPath, string ItemName, bool ForceOverwrite = false)
        {
            //Create the Part file.
            FileStream   FS = new FileStream(ItemPath, FileMode.Create, FileAccess.Write);
            BinaryWriter BW = new BinaryWriter(FS, Encoding.UTF8);

            BW.Write(txtName.Text);
            BW.Write(frmDetails.txtMapSprite.Text);
            BW.Write(frmDetails.txtUnitSprite.Text);
            BW.Write(frmDetails.txtTags.Text);
            BW.Write(txtDescription.Text);
            BW.Write(Convert.ToInt32(txtPrice.Text));

            BW.Write((int)txtEXP.Value);
            BW.Write(Convert.ToInt32(txtBaseHP.Text));
            BW.Write(Convert.ToInt32(txtBaseEN.Text));
            BW.Write(Convert.ToInt32(txtBaseArmor.Text));
            BW.Write(Convert.ToInt32(txtBaseMobility.Text));
            BW.Write(Convert.ToSingle(txtBaseMovement.Text));
            BW.Write(frmAttacks.AttackUpgradesValueIndex);
            BW.Write(frmAttacks.AttackUpgradesCostIndex);

            Dictionary <string, int> DicTerrainValue = new Dictionary <string, int>();

            DicTerrainValue.Add(UnitStats.TerrainAir, 0);
            DicTerrainValue.Add(UnitStats.TerrainLand, 0);
            DicTerrainValue.Add(UnitStats.TerrainSea, 0);
            DicTerrainValue.Add(UnitStats.TerrainSpace, 0);
            if (cbTerrainAir.SelectedIndex >= 0)
            {
                DicTerrainValue[UnitStats.TerrainAir] = cbTerrainAir.SelectedIndex;
            }
            if (cbTerrainLand.SelectedIndex >= 0)
            {
                DicTerrainValue[UnitStats.TerrainLand] = cbTerrainLand.SelectedIndex;
            }
            if (cbTerrainSea.SelectedIndex >= 0)
            {
                DicTerrainValue[UnitStats.TerrainSea] = cbTerrainSea.SelectedIndex;
            }
            if (cbTerrainSpace.SelectedIndex >= 0)
            {
                DicTerrainValue[UnitStats.TerrainSpace] = cbTerrainSpace.SelectedIndex;
            }

            BW.Write(DicTerrainValue.Count);
            foreach (KeyValuePair <string, int> TerrainValue in DicTerrainValue)
            {
                BW.Write(TerrainValue.Key);
                BW.Write(TerrainValue.Value);
            }

            List <string> UnitMovements = new List <string>();

            if (cboMovementAir.Checked)
            {
                UnitMovements.Add(UnitStats.TerrainAir);
            }
            if (cboMovementLand.Checked)
            {
                UnitMovements.Add(UnitStats.TerrainLand);
            }
            if (cboMovementSea.Checked)
            {
                UnitMovements.Add(UnitStats.TerrainSea);
            }
            if (cboMovementSpace.Checked)
            {
                UnitMovements.Add(UnitStats.TerrainSpace);
            }
            if (cboMovementUnderground.Checked)
            {
                UnitMovements.Add(UnitStats.TerrainUnderground);
            }
            if (cboMovementUnderwater.Checked)
            {
                UnitMovements.Add(UnitStats.TerrainUnderwater);
            }

            BW.Write(UnitMovements.Count);
            for (int i = 0; i < UnitMovements.Count; i++)
            {
                BW.Write(UnitMovements[i]);
            }

            if (rbSizeLLL.Checked)
            {
                BW.Write("LLL");
            }
            else if (rbSizeLL.Checked)
            {
                BW.Write("LL");
            }
            else if (rbSizeL.Checked)
            {
                BW.Write("L");
            }
            else if (rbSizeM.Checked)
            {
                BW.Write("M");
            }
            else if (rbSizeS.Checked)
            {
                BW.Write("S");
            }
            else if (rbSizeSS.Checked)
            {
                BW.Write("SS");
            }

            if (frmUnitSizeEditor.rbNone.Checked)
            {
                BW.Write(1);
                BW.Write(1);
                BW.Write(true);
            }
            else if (frmUnitSizeEditor.rbSizeOnly.Checked)
            {
                BW.Write((int)frmUnitSizeEditor.txtWidth.Value);
                BW.Write((int)frmUnitSizeEditor.txtWidth.Value);
                for (int X = 0; X < frmUnitSizeEditor.txtWidth.Value; X++)
                {
                    for (int Y = 0; Y < frmUnitSizeEditor.txtHeight.Value; Y++)
                    {
                        BW.Write(true);
                    }
                }
            }
            else if (frmUnitSizeEditor.rbCustomSizeBox.Checked)
            {
                BW.Write((int)frmUnitSizeEditor.txtWidth.Value);
                BW.Write((int)frmUnitSizeEditor.txtWidth.Value);
                for (int X = 0; X < frmUnitSizeEditor.txtWidth.Value; X++)
                {
                    for (int Y = 0; Y < frmUnitSizeEditor.txtHeight.Value; Y++)
                    {
                        BW.Write(frmUnitSizeEditor.ListUnitSize[X][Y]);
                    }
                }
            }

            //Write Pilots whitelist.
            BW.Write(lstPilots.Items.Count);
            for (int P = 0; P < lstPilots.Items.Count; ++P)
            {
                BW.Write((string)lstPilots.Items[P]);
            }

            //Attacks.
            BW.Write(frmAttacks.ListAttack.Count);
            for (int A = 0; A < frmAttacks.ListAttack.Count; ++A)
            {
                BW.Write(frmAttacks.ListAttack[A].IsExternal);
                BW.Write(frmAttacks.ListAttack[A].RelativePath);

                if (!frmAttacks.ListAttack[A].IsExternal)
                {
                    ProjectEternityAttackEditor ActiveAttack = (ProjectEternityAttackEditor)frmAttacks.lstAttack.Items[A];
                    ActiveAttack.SaveItem(BW);
                }

                BW.Write(frmAttacks.ListAttack[A].Animations.Count);
                for (int An = 0; An < frmAttacks.ListAttack[A].Animations.Count; ++An)
                {
                    frmAttacks.ListAttack[A].Animations[An].Save(BW);
                }
            }

            //Animations.
            BW.Write(lstAnimations.Items.Count);
            for (int A = 0; A < lstAnimations.Items.Count; ++A)
            {
                BW.Write((string)lstAnimations.Items[A].Tag);
            }

            //Abilities.
            BW.Write(lstAbilities.Items.Count);
            for (int A = 0; A < lstAbilities.Items.Count; ++A)
            {
                BW.Write((string)lstAbilities.Items[A]);
            }

            //Part slots.
            BW.Write((int)txtPartsSlots.Value);

            FS.Close();
            BW.Close();
        }