public void SauveSprite(string fileName, string version) { byte[] ret = MakeSprite(); StreamWriter sw = SaveAsm.OpenAsm(fileName, version); SaveAsm.GenereDatas(sw, ret, ret.Length, BitmapCpc.TailleX >> (BitmapCpc.TailleX <= 320 ? 3 : 4)); SaveAsm.CloseAsm(sw); main.SetInfo("Sauvegarde sprite assembleur ok."); }
public void SauveSpriteCmp(string fileName, string version) { byte[] ret = MakeSprite(); byte[] sprCmp = new byte[ret.Length]; int l = PackDepack.Pack(ret, ret.Length, sprCmp, 0); StreamWriter sw = SaveAsm.OpenAsm(fileName, version); SaveAsm.GenereDatas(sw, sprCmp, l, 16); SaveAsm.CloseAsm(sw); main.SetInfo("Sauvegarde sprite assembleur compacté ok."); }
private void SauveDeltaPack(int adrDeb, int adrMax, int delai, int modeLigne, bool imageMode, bool optimSpeed) { int sizeDepack = 0; int nbImages = img.main.GetMaxImages(); byte[][] bufOut = new byte[nbImages << 1][]; int[] lg = new int[nbImages << 1]; int[] bank = new int[nbImages << 1]; for (int i = 0; i < nbImages << 1; i++) { bufOut[i] = new byte[0x18000]; } if (adrMax == 0) { adrMax = 0xBE00; } // Calcule les animations int ltot = 0, maxDepack = 0; int posPack = 0; if (chkBoucle.Checked) { img.main.SelectImage(nbImages - 1, true); img.Convert(!img.bitmapCpc.isCalc, true); lg[posPack] = PackFrame(bufOut[0], ref sizeDepack, true, false, -1, modeLigne, imageMode, optimSpeed); if (lg[posPack] > 0) { ltot += lg[posPack++]; } } img.main.SetInfo("Début sauvegarde animation assembleur..."); for (int i = 0; i < (imageMode ? 1 : nbImages); i++) { if (!imageMode) { img.main.SelectImage(i, true); img.Convert(!img.bitmapCpc.isCalc, true); } Application.DoEvents(); if (chk2Zone.Checked) { lg[posPack] = PackFrame(bufOut[posPack], ref sizeDepack, i == 0 && !chkBoucle.Checked, i == 0 && !chkBoucle.Checked, 0, modeLigne, imageMode, optimSpeed); if (lg[posPack] > 0) { ltot += lg[posPack++]; } lg[posPack] = PackFrame(bufOut[posPack], ref sizeDepack, i == 0 && !chkBoucle.Checked, i == 0 && !chkBoucle.Checked, 1, modeLigne, imageMode, optimSpeed); if (lg[posPack] > 0) { ltot += lg[posPack++]; } } else { lg[posPack] = PackFrame(bufOut[posPack], ref sizeDepack, i == 0 && !chkBoucle.Checked, i == 0 && !chkBoucle.Checked, -1, modeLigne, imageMode, optimSpeed); if (lg[posPack] > 0) { ltot += lg[posPack++]; } } maxDepack = Math.Max(maxDepack, sizeDepack); } // Sauvegarde StreamWriter sw = SaveAsm.OpenAsm(fileName, version); if (param.withCode && !chkDataBrut.Checked) { SaveAsm.GenereEntete(sw, adrDeb); if (BitmapCpc.cpcPlus) { SaveAsm.GenereInitPlus(sw); } else { SaveAsm.GenereInitOld(sw); } } bool gest128K = chk128Ko.Checked; if ((ltot + adrDeb < adrMax) && (ltot + adrDeb < 0xBE00 - maxDepack)) { gest128K = false; } if (param.withCode && !chkDataBrut.Checked) { SaveAsm.GenereAffichage(sw, delai, chkBoucle.Checked, gest128K, imageMode); if (BitmapCpc.modeVirtuel >= 7) { SaveAsm.GenereDrawAscii(sw, rbFrameFull.Checked, rbFrameO.Checked, rbFrameD.Checked, gest128K, imageMode); } else if (chkDirecMem.Checked) { SaveAsm.GenereDrawDirect(sw, gest128K); } else { SaveAsm.GenereDrawDC(sw, delai, chkCol.Checked, gest128K, modeLigne == 8 ? 0x3F : modeLigne == 4 ? 0x1F : modeLigne == 2 ? 0xF : 0x7, optimSpeed); } } if ((param.withPalette || param.withCode) && !chkDataBrut.Checked) { if (BitmapCpc.cpcPlus) { SaveAsm.GenerePalettePlus(sw, img); } else { SaveAsm.GenerePaletteOld(sw, img); } } int endBank0 = 0; int lbank = 0, numBank = 0xC0; for (int i = 0; i < posPack; i++) { lbank += lg[i]; if (!chkDataBrut.Checked && gest128K && lbank > (numBank == 0xC0 ? Math.Min((0xBE00 - maxDepack - adrDeb), adrMax - adrDeb) : 0x4000) && (numBank > 0xC0 || lbank + adrDeb - lg[i] > 0x4000)) { if (numBank == 0xC0) { endBank0 = lbank + adrDeb - lg[i]; sw.WriteLine("EndBank0:"); numBank = 0xC4; } else { numBank++; if ((numBank & 15) == 8) { numBank += 4; } if ((numBank & 15) == 15) { numBank += 5; } } lbank = lg[i]; sw.WriteLine(" ORG #4000"); sw.WriteLine(" Write Direct -1,-1,#"+ numBank.ToString("X2")); } bank[i] = numBank; if (imageMode && lastAscii != '\0') { sw.WriteLine("; Type Frame ='" + lastAscii + "'"); } sw.WriteLine("Delta" + i.ToString() + ":\t\t; Taille #" + lg[i].ToString("X4")); SaveAsm.GenereDatas(sw, bufOut[i], lg[i], chkDataBrut.Checked ? 3 : 16); } if (gest128K) { SaveAsm.GenerePointeurs(sw, posPack, bank, gest128K && numBank > 0xC0); } else if (!imageMode && !chkDataBrut.Checked) { sw.WriteLine(" DB #FF ; Fin de l'animation"); ltot++; } SaveAsm.GenereFin(sw, ltot, gest128K && endBank0 < 0x8000); SaveAsm.CloseAsm(sw); for (int i = 0; i < posPack; i++) { bufOut[i] = null; } img.main.SetInfo("Longueur totale données animation : " + ltot + " octets."); if (!chkDataBrut.Checked && (numBank > 0xC7 || (!chk128Ko.Checked && ltot + adrDeb >= 0xBE00 - maxDepack))) { MessageBox.Show("Attention ! la taille totale (animation + buffer de décompactage) dépassera " + (chk128Ko.Checked ? "112K" : "48Ko") + ", risque d'écrasement de la mémoire vidéo et plantage..." , "Alerte" , MessageBoxButtons.OK , MessageBoxIcon.Warning); img.main.SetInfo("Dépassement capacité mémoire..."); } else { img.main.SetInfo("Sauvegarde animation assembleur ok."); } GC.Collect(); }
static public int SauveScr(string fileName, BitmapCpc bitmapCpc, ImageCpc img, Param param, bool compact, string version = null, int[,] colMode5 = null) { byte[] bufPack = new byte[0x8000]; bool overscan = (BitmapCpc.NbLig * BitmapCpc.NbCol > 0x3F00); if (param.withPalette && version == null) { if (param.cpcPlus) { ModePal[0] = (byte)(BitmapCpc.modeVirtuel | 0x8C); int k = 1; for (int i = 0; i < 16; i++) { ModePal[k++] = (byte)(((BitmapCpc.Palette[i] >> 4) & 0x0F) | (BitmapCpc.Palette[i] << 4)); ModePal[k++] = (byte)(BitmapCpc.Palette[i] >> 8); } } else { ModePal[0] = (byte)BitmapCpc.modeVirtuel; for (int i = 0; i < 16; i++) { ModePal[1 + i] = (byte)BitmapCpc.Palette[i]; } } } byte[] imgCpc = bitmapCpc.bmpCpc; if (!overscan) { Buffer.BlockCopy(ModePal, 0, imgCpc, 0x17D0, ModePal.Length); if (param.withCode && version == null) { if (param.cpcPlus) { Buffer.BlockCopy(CodeP0, 0, imgCpc, 0x07D0, CodeP0.Length); Buffer.BlockCopy(CodeP1, 0, imgCpc, 0x0FD0, CodeP1.Length); Buffer.BlockCopy(CodeP3, 0, imgCpc, 0x1FD0, CodeP3.Length); } else { Buffer.BlockCopy(CodeStd, 0, imgCpc, 0x07D0, CodeStd.Length); } if (BitmapCpc.modeVirtuel == 3 || BitmapCpc.modeVirtuel == 4) { Buffer.BlockCopy(codeEgx0, 0, imgCpc, 0x37D0, codeEgx0.Length); Buffer.BlockCopy(codeEgx1, 0, imgCpc, 0x2FD0, codeEgx1.Length); imgCpc[0x07F2] = 0xD0; imgCpc[0x07F3] = 0xF7; // CALL 0xF7D0 imgCpc[0x37FA] = 0xEF; // Call 0xEFD0 } } } else { if (BitmapCpc.NbLig * BitmapCpc.NbCol > 0x4000) { Buffer.BlockCopy(ModePal, 0, imgCpc, 0x600, ModePal.Length); if (param.withCode && version == null) { if (param.cpcPlus) { Buffer.BlockCopy(CodeOvP, 0, imgCpc, 0x621, CodeOvP.Length); } else { Buffer.BlockCopy(CodeOv, 0, imgCpc, 0x611, CodeOv.Length); } if (BitmapCpc.modeVirtuel == 3 || BitmapCpc.modeVirtuel == 4) { Buffer.BlockCopy(codeEgx0, 0, imgCpc, 0x1600, codeEgx0.Length); Buffer.BlockCopy(codeEgx1, 0, imgCpc, 0x1640, codeEgx1.Length); if (param.cpcPlus) { imgCpc[0x669] = 0xCD; imgCpc[0x66A] = 0x00; imgCpc[0x66B] = 0x18; // CALL #1800 } else { imgCpc[0x631] = 0x00; imgCpc[0x632] = 0x18; // CALL #1800 } imgCpc[0x1629] = 0x40; imgCpc[0x162A] = 0x18; // CALL #1840 } } } } short startAdr = (short)(overscan ? 0x200 : 0xC000); short exec = (short)(overscan ? param.cpcPlus ? 0x821 : 0x811 : 0xC7D0); CpcAmsdos entete; int lg = BitmapCpc.BitmapSize; if (compact) { lg = PackDepack.Pack(bitmapCpc.bmpCpc, lg, bufPack, 0) + 1; // Prendre 1 octet de marge ? if (param.withCode && version == null) { Buffer.BlockCopy(codeDepack, 0, bufPack, lg, codeDepack.Length); bufPack[lg + 4] = (byte)(startAdr & 0xFF); bufPack[lg + 5] = (byte)(startAdr >> 8); startAdr = (short)(0xA657 - (lg + codeDepack.Length)); bufPack[lg + 1] = (byte)(startAdr & 0xFF); bufPack[lg + 2] = (byte)(startAdr >> 8); bufPack[lg + 32] = (byte)(exec & 0xFF); bufPack[lg + 33] = (byte)(exec >> 8); lg += codeDepack.Length; exec = (short)(0xA657 - codeDepack.Length); } else { startAdr = (short)(0xA657 - lg); exec = 0; } } if (version != null) { // Sauvegarde source assembleur StreamWriter sw = SaveAsm.OpenAsm(fileName, version); int org = 0xA500 - lg - (BitmapCpc.modeVirtuel == 5 ? 600 : 0); sw.WriteLine(" ORG #"+ org.ToString("X4")); sw.WriteLine(" Nolist"); sw.WriteLine("ImageCmp:"); SaveAsm.GenereDatas(sw, bufPack, lg, 16); sw.WriteLine(" List"); if (param.withCode) { sw.WriteLine(" RUN $"); sw.WriteLine("_StartDepack:"); if (BitmapCpc.modeVirtuel == 3 || BitmapCpc.modeVirtuel == 4) { SaveAsm.GenereAfficheModeEgx(sw, BitmapCpc.Palette, overscan); } else { SaveAsm.GenereFormatEcran(sw); if (BitmapCpc.modeVirtuel == 5) { SaveAsm.GenereAfficheModeX(sw, colMode5, overscan); } else { SaveAsm.GenereAfficheStd(sw, img, BitmapCpc.modeVirtuel, BitmapCpc.Palette, overscan); } } } SaveAsm.CloseAsm(sw); } else { entete = CpcSystem.CreeEntete(fileName, startAdr, (short)lg, exec); BinaryWriter fp = new BinaryWriter(new FileStream(fileName, FileMode.Create)); fp.Write(CpcSystem.AmsdosToByte(entete)); fp.Write(compact ? bufPack : bitmapCpc.bmpCpc, 0, lg); fp.Close(); } return(lg); }